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.setMemberDetails( memberDetails );
+
 		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;
@@ -15,6 +16,7 @@
 import org.hibernate.Incubating;
 import org.hibernate.Internal;
 import org.hibernate.MappingException;
+import org.hibernate.models.spi.MemberDetails;
 import org.hibernate.type.TimeZoneStorageStrategy;
 import org.hibernate.annotations.SoftDelete;
 import org.hibernate.annotations.SoftDeleteType;
@@ -85,6 +87,7 @@
 
 /**
  * @author Steve Ebersole
+ * @author Yanming Zhou
  */
 public class BasicValue extends SimpleValue
 		implements JdbcTypeIndicators, Resolvable, JpaAttributeConverterCreationContext {
@@ -1080,9 +1083,10 @@ public void setExplicitCustomType(Class<? extends UserType<?>> explicitCustomTyp
 			else {
 				final var typeProperties = getCustomTypeProperties();
 				final var typeAnnotation = getTypeAnnotation();
+				final var memberDetails = getMemberDetails();
 				resolution = new UserTypeResolution<>(
 						new CustomType<>(
-								getConfiguredUserTypeBean( explicitCustomType, typeProperties, typeAnnotation ),
+								getConfiguredUserTypeBean( explicitCustomType, typeProperties, typeAnnotation, memberDetails ),
 								getTypeConfiguration()
 						),
 						null,
@@ -1104,8 +1108,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, MemberDetails memberDetails) {
+		final var typeInstance = instantiateUserType( explicitCustomType, properties, typeAnnotation, memberDetails );
 
 		if ( typeInstance instanceof TypeConfigurationAware configurationAware ) {
 			configurationAware.setTypeConfiguration( getTypeConfiguration() );
@@ -1127,21 +1131,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, MemberDetails memberDetails ) {
+		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( memberDetails.toJavaMember() );
 			}
-			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, memberDetails.toJavaMember() );
+					}
+					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

@@ -89,6 +89,7 @@ public abstract class SimpleValue implements KeyValue {
 	private String typeName;
 	private Properties typeParameters;
 	private Annotation typeAnnotation;
+	private MemberDetails memberDetails;
 	private boolean isVersion;
 	private boolean isNationalized;
 	private boolean isLob;
@@ -135,6 +136,7 @@ protected SimpleValue(SimpleValue original) {
 		this.typeName = original.typeName;
 		this.typeParameters = original.typeParameters == null ? null : new Properties( original.typeParameters );
 		this.typeAnnotation = original.typeAnnotation;
+		this.memberDetails = original.memberDetails;
 		this.isVersion = original.isVersion;
 		this.isNationalized = original.isNationalized;
 		this.isLob = original.isLob;
@@ -804,6 +806,10 @@ public void setTypeAnnotation(Annotation typeAnnotation) {
 		this.typeAnnotation = typeAnnotation;
 	}
 
+	public void setMemberDetails(MemberDetails memberDetails) {
+		this.memberDetails = memberDetails;
+	}
+
 	public Properties getTypeParameters() {
 		return typeParameters;
 	}
@@ -812,6 +818,10 @@ public Annotation getTypeAnnotation() {
 		return typeAnnotation;
 	}
 
+	public MemberDetails getMemberDetails() {
+		return memberDetails;
+	}
+
 	public void copyTypeFrom(SimpleValue sourceValue ) {
 		setTypeName( sourceValue.getTypeName() );
 		setTypeParameters( sourceValue.getTypeParameters() );
@@ -835,6 +845,7 @@ public boolean isSame(SimpleValue other) {
 			&& Objects.equals( typeName, other.typeName )
 			&& Objects.equals( typeParameters, other.typeParameters )
 			&& Objects.equals( typeAnnotation, other.typeAnnotation )
+			&& Objects.equals( memberDetails, other.memberDetails )
 			&& 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