HHH-19993 Allow custom UserType constructor accepts Member as parameter

Signed-off-by: Yanming Zhou <zhouyanming@gmail.com>

Author: quaff

hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java

@@ -1193,6 +1193,9 @@ else if ( aggregateComponent != null ) {
 }
 
 public void fillSimpleValue() {
+
+basicValue.setMember( memberDetails.toJavaMember() );
+
 basicValue.setExplicitTypeParams( explicitLocalCustomTypeParams );
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java

@@ -6,6 +6,7 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
@@ -85,6 +86,7 @@
 
 /**
  * @author Steve Ebersole
+ * @author Yanming Zhou
  */
 public class BasicValue extends SimpleValue
 implements JdbcTypeIndicators, Resolvable, JpaAttributeConverterCreationContext {
@@ -1080,9 +1082,10 @@ public void setExplicitCustomType(Class<? extends UserType<?>> explicitCustomTyp
 else {
 final var typeProperties = getCustomTypeProperties();
 final var typeAnnotation = getTypeAnnotation();
+final var member = getMember();
 resolution = new UserTypeResolution<>(
 new CustomType<>(
-getConfiguredUserTypeBean( explicitCustomType, typeProperties, typeAnnotation ),
+getConfiguredUserTypeBean( explicitCustomType, typeProperties, typeAnnotation, member ),
 getTypeConfiguration()
 ),
 null,
@@ -1104,8 +1107,8 @@ private Properties getCustomTypeProperties() {
 }
 
 private UserType<?> getConfiguredUserTypeBean(
-Class<? extends UserType<?>> explicitCustomType, Properties properties, Annotation typeAnnotation) {
-final var typeInstance = instantiateUserType( explicitCustomType, properties, typeAnnotation );
+Class<? extends UserType<?>> explicitCustomType, Properties properties, Annotation typeAnnotation, Member member) {
+final var typeInstance = instantiateUserType( explicitCustomType, properties, typeAnnotation, member );
 
 if ( typeInstance instanceof TypeConfigurationAware configurationAware ) {
 configurationAware.setTypeConfiguration( getTypeConfiguration() );
@@ -1127,21 +1130,41 @@ private UserType<?> getConfiguredUserTypeBean(
 }
 
 private <T extends UserType<?>> T instantiateUserType(
-Class<T> customType, Properties properties, Annotation typeAnnotation) {
-if ( typeAnnotation != null ) {
-// attempt to instantiate it with the annotation as a constructor argument
+Class<T> customType, Properties properties, Annotation typeAnnotation, Member member ) {
+try {
+// attempt to instantiate it with the member as a constructor argument
 try {
-final var constructor = customType.getDeclaredConstructor( typeAnnotation.annotationType() );
+final var constructor = customType.getDeclaredConstructor( Member.class );
 constructor.setAccessible( true );
-return constructor.newInstance( typeAnnotation );
+return constructor.newInstance( member );
 }
-catch ( NoSuchMethodException ignored ) {
-// no such constructor, instantiate it the old way
+catch (NoSuchMethodException ignored) {
 }
-catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
-throw new org.hibernate.InstantiationException( "Could not instantiate custom type", customType, e );
+
+if ( typeAnnotation != null ) {
+// attempt to instantiate it with the annotation as a constructor argument
+try {
+final var constructor = customType.getDeclaredConstructor( typeAnnotation.annotationType() );
+constructor.setAccessible( true );
+return constructor.newInstance( typeAnnotation );
+}
+catch (NoSuchMethodException ignored) {
+// attempt to instantiate it with the annotation and member as constructor arguments
+try {
+final var constructor = customType.getDeclaredConstructor( typeAnnotation.annotationType(),
+Member.class );
+constructor.setAccessible( true );
+return constructor.newInstance( typeAnnotation, member );
+}
+catch (NoSuchMethodException ignored_) {
+// no such constructor, instantiate it the old way
+}
+}
 }
 }
+catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
+throw new org.hibernate.InstantiationException( "Could not instantiate custom type", customType, e );
+}
 
 return getBuildingContext().getBuildingOptions().isAllowExtensionsInCdi()
 ? getUserTypeBean( customType, properties ).getBeanInstance()

hibernate-core/src/main/java/org/hibernate/mapping/SimpleValue.java

@@ -6,6 +6,7 @@
 
 import java.io.Serializable;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
 import java.sql.Types;
 import java.util.ArrayList;
 import java.util.List;
@@ -89,6 +90,7 @@ public abstract class SimpleValue implements KeyValue {
 private String typeName;
 private Properties typeParameters;
 private Annotation typeAnnotation;
+private Member member;
 private boolean isVersion;
 private boolean isNationalized;
 private boolean isLob;
@@ -135,6 +137,7 @@ protected SimpleValue(SimpleValue original) {
 this.typeName = original.typeName;
 this.typeParameters = original.typeParameters == null ? null : new Properties( original.typeParameters );
 this.typeAnnotation = original.typeAnnotation;
+this.member = original.member;
 this.isVersion = original.isVersion;
 this.isNationalized = original.isNationalized;
 this.isLob = original.isLob;
@@ -804,6 +807,10 @@ public void setTypeAnnotation(Annotation typeAnnotation) {
 this.typeAnnotation = typeAnnotation;
 }
 
+public void setMember(Member member) {
+this.member = member;
+}
+
 public Properties getTypeParameters() {
 return typeParameters;
 }
@@ -812,6 +819,10 @@ public Annotation getTypeAnnotation() {
 return typeAnnotation;
 }
 
+public Member getMember() {
+return member;
+}
+
 public void copyTypeFrom(SimpleValue sourceValue ) {
 setTypeName( sourceValue.getTypeName() );
 setTypeParameters( sourceValue.getTypeParameters() );
@@ -835,6 +846,7 @@ public boolean isSame(SimpleValue other) {
 && Objects.equals( typeName, other.typeName )
 && Objects.equals( typeParameters, other.typeParameters )
 && Objects.equals( typeAnnotation, other.typeAnnotation )
+&& Objects.equals( member, other.member )
 && Objects.equals( table, other.table )
 && Objects.equals( foreignKeyName, other.foreignKeyName )
 && Objects.equals( foreignKeyDefinition, other.foreignKeyDefinition );

hibernate-core/src/main/java/org/hibernate/usertype/UserType.java

@@ -214,8 +214,9 @@
  * }
  * </pre>
  * <p>
- * Every implementor of {@code UserType} must be immutable and must
- * declare a public default constructor.
+ * Every implementor of {@code UserType} must be immutable and could
+ * declare a constructor accepts the {@link java.lang.reflect.Member},
+ * or the annotation type, or the annotation type and the member.
  * <p>
  * A custom type implemented as a {@code UserType} is treated as a
  * non-composite value, and does not have persistent attributes which

hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/MetaUserTypeTest.java

@@ -18,6 +18,8 @@
 import java.io.Serializable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -33,7 +35,8 @@
 import static java.sql.Types.VARCHAR;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@Jpa(annotatedClasses = {MetaUserTypeTest.Thing.class, MetaUserTypeTest.Things.class})
+@Jpa(annotatedClasses = {MetaUserTypeTest.Thing.class, MetaUserTypeTest.SecondThing.class,
+MetaUserTypeTest.ThirdThing.class, MetaUserTypeTest.Things.class})
 public class MetaUserTypeTest {
 
 @Test void test(EntityManagerFactoryScope scope) {
@@ -48,6 +51,30 @@ public class MetaUserTypeTest {
 assertEquals( Period.of( 1, 2, 3 ), thing.period );
 assertEquals( Period.ofDays( 42 ), thing.days );
 } );
+
+scope.inTransaction( em -> {
+SecondThing thing = new SecondThing();
+thing.period = Period.of( 1, 2, 3 );
+thing.days = Period.ofDays( 42 );
+em.persist( thing );
+} );
+scope.inTransaction( em -> {
+SecondThing thing = em.find( SecondThing.class, 1 );
+assertEquals( Period.of( 1, 2, 3 ), thing.period );
+assertEquals( Period.ofDays( 42 ), thing.days );
+} );
+
+scope.inTransaction( em -> {
+ThirdThing thing = new ThirdThing();
+thing.period = Period.of( 1, 2, 3 );
+thing.days = Period.ofDays( 42 );
+em.persist( thing );
+} );
+scope.inTransaction( em -> {
+ThirdThing thing = em.find( ThirdThing.class, 1 );
+assertEquals( Period.of( 1, 2, 3 ), thing.period );
+assertEquals( Period.ofDays( 42 ), thing.days );
+} );
 }
 
 @Test void testCollection(EntityManagerFactoryScope scope) {
@@ -73,6 +100,24 @@ public class MetaUserTypeTest {
 Period days;
 }
 
+@Entity static class SecondThing {
+@Id @GeneratedValue
+long id;
+@SecondTimePeriod
+Period period;
+@SecondTimePeriod(days = true)
+Period days;
+}
+
+@Entity static class ThirdThing {
+@Id @GeneratedValue
+long id;
+@ThirdTimePeriod
+Period period;
+@ThirdTimePeriod(days = true)
+Period days;
+}
+
 @Entity static class Things {
 @Id @GeneratedValue
 long id;
@@ -89,11 +134,52 @@ public class MetaUserTypeTest {
 boolean days() default false;
 }
 
-static class PeriodType implements UserType<Period> {
-private final boolean days;
+@Type(SecondPeriodType.class)
+@Target({METHOD, FIELD})
+@Retention(RUNTIME)
+public @interface SecondTimePeriod {
+boolean days() default false;
+}
+
+@Type(ThirdPeriodType.class)
+@Target({METHOD, FIELD})
+@Retention(RUNTIME)
+public @interface ThirdTimePeriod {
+boolean days() default false;
+}
+
+static class PeriodType extends AbstractPeriodType {
 
 PeriodType(TimePeriod timePeriod) {
-days = timePeriod.days();
+super(timePeriod.days());
+}
+
+}
+
+static class SecondPeriodType extends AbstractPeriodType {
+
+SecondPeriodType(Member member) {
+super( ( (Field) member ).getAnnotation( SecondTimePeriod.class ).days() );
+}
+
+}
+
+static class ThirdPeriodType extends AbstractPeriodType {
+
+ThirdPeriodType(ThirdTimePeriod timePeriod, Member member) {
+super(timePeriod.days());
+if ( !timePeriod.equals( ( (Field) member ).getAnnotation( ThirdTimePeriod.class ) )) {
+throw new IllegalArgumentException(member + " should be annotated with " + timePeriod);
+}
+}
+
+}
+
+static abstract class AbstractPeriodType implements UserType<Period> {
+private final boolean days;
+
+AbstractPeriodType(boolean days) {
+this.days = days;
 }
 
 @Override