HHH-18998 pass annotation to constructor of UserType

gavinking · gavinking · commit 65de5d93e189 · 2025-12-01T16:39:32.000+01:00
diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java b/hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinition.java
@@ -108,7 +108,7 @@ public BasicValue.Resolution<?> resolve(
 			MetadataBuildingContext context,
 			JdbcTypeIndicators indicators) {
 		if ( isEmpty( localConfigParameters ) ) {
-			// we can use the re-usable resolution...
+			// we can use the reusable resolution...
 			if ( reusableResolution == null ) {
 				reusableResolution = createResolution( this.name, emptyMap(), indicators, context );
 			}
@@ -151,9 +151,10 @@ private static <T> BasicValue.Resolution<T> createResolution(
 
 		// support for AttributeConverter would be nice too
 		if ( isKnownType ) {
+
 			final T typeInstance =
 					instantiateType( bootstrapContext.getServiceRegistry(), context.getBuildingOptions(),
-							name, typeImplementorClass, instanceProducer );
+							name, typeImplementorClass, bootstrapContext.getCustomTypeProducer() );
 
 			if ( typeInstance instanceof TypeConfigurationAware configurationAware ) {
 				configurationAware.setTypeConfiguration( typeConfiguration );
diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/BasicValueBinder.java
@@ -102,7 +102,8 @@ public enum Kind {
 	// in-flight info
 
 	private Class<? extends UserType<?>> explicitCustomType;
-	private Map<String,String> explicitLocalTypeParams;
+	private Map<String,String> explicitLocalCustomTypeParams;
+	private Annotation explicitCustomTypeAnnotation;
 
 	private Function<TypeConfiguration, JdbcType> explicitJdbcTypeAccess;
 	private Function<TypeConfiguration, BasicJavaType<?>> explicitJavaTypeAccess;
@@ -338,8 +339,9 @@ private boolean applyCustomType(MemberDetails memberDetails, TypeDetails typeDet
 		final var modelContext = getSourceModelContext();
 		final var userTypeImpl = kind.mappingAccess.customType( memberDetails, modelContext );
 		if ( userTypeImpl != null ) {
-			applyExplicitType( userTypeImpl,
-					kind.mappingAccess.customTypeParameters( memberDetails, modelContext ) );
+			this.explicitCustomType = userTypeImpl;
+			this.explicitLocalCustomTypeParams = kind.mappingAccess.customTypeParameters( memberDetails, modelContext );
+			this.explicitCustomTypeAnnotation = kind.mappingAccess.customTypeAnnotation( memberDetails, modelContext );
 			// An explicit custom UserType has top precedence when we get to BasicValue resolution.
 			return true;
 		}
@@ -349,7 +351,8 @@ private boolean applyCustomType(MemberDetails memberDetails, TypeDetails typeDet
 			final var registeredUserTypeImpl =
 					getMetadataCollector().findRegisteredUserType( basicClass );
 			if ( registeredUserTypeImpl != null ) {
-				applyExplicitType( registeredUserTypeImpl, emptyMap() );
+				this.explicitCustomType = registeredUserTypeImpl;
+				this.explicitLocalCustomTypeParams = emptyMap();
 				return true;
 			}
 		}
@@ -384,11 +387,6 @@ private void prepareValue(MemberDetails value, TypeDetails typeDetails, @Nullabl
 		}
 	}
 
-	private void applyExplicitType(Class<? extends UserType<?>> userTypeImpl, Map<String,String> parameters) {
-		explicitCustomType = userTypeImpl;
-		explicitLocalTypeParams = parameters;
-	}
-
 	private void prepareCollectionId(MemberDetails attribute) {
 		final var collectionId = attribute.getDirectAnnotationUsage( CollectionId.class );
 		if ( collectionId == null ) {
@@ -1195,7 +1193,7 @@ else if ( aggregateComponent != null ) {
 	}
 
 	public void fillSimpleValue() {
-		basicValue.setExplicitTypeParams( explicitLocalTypeParams );
+		basicValue.setExplicitTypeParams( explicitLocalCustomTypeParams );
 
 		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		// todo (6.0) : we are dropping support for @Type and @TypeDef from annotations
@@ -1211,6 +1209,10 @@ public void fillSimpleValue() {
 			basicValue.setTypeParameters( createDynamicParameterizedTypeParameters() );
 		}
 
+		if ( explicitCustomType != null ) {
+			basicValue.setTypeAnnotation( explicitCustomTypeAnnotation );
+		}
+
 		if ( converterDescriptor != null ) {
 			basicValue.setJpaAttributeConverterDescriptor( converterDescriptor );
 		}
@@ -1282,8 +1284,8 @@ private Map<String, Object> createDynamicParameterizedTypeParameters() {
 			parameters.put( DynamicParameterizedType.ACCESS_TYPE, accessType.getType() );
 		}
 
-		if ( explicitLocalTypeParams != null ) {
-			parameters.putAll( explicitLocalTypeParams );
+		if ( explicitLocalCustomTypeParams != null ) {
+			parameters.putAll( explicitLocalCustomTypeParams );
 		}
 
 		return parameters;
@@ -1295,6 +1297,7 @@ private Map<String, Object> createDynamicParameterizedTypeParameters() {
 	private interface BasicMappingAccess {
 		Class<? extends UserType<?>> customType(MemberDetails attribute, ModelsContext context);
 		Map<String,String> customTypeParameters(MemberDetails attribute, ModelsContext context);
+		Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context);
 	}
 
 	private static class ValueMappingAccess implements BasicMappingAccess {
@@ -1311,6 +1314,12 @@ public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsCo
 			final var customType = attribute.locateAnnotationUsage( Type.class, context );
 			return customType == null ? null : extractParameterMap( customType.parameters() );
 		}
+
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			final var annotations = attribute.getMetaAnnotated( Type.class, context );
+			return annotations == null || annotations.isEmpty() ? null : annotations.get( 0 );
+		}
 	}
 
 	private static class AnyDiscriminatorMappingAccess implements BasicMappingAccess {
@@ -1325,6 +1334,11 @@ public Class<? extends UserType<?>> customType(MemberDetails attribute, ModelsCo
 		public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsContext context) {
 			return emptyMap();
 		}
+
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			return null;
+		}
 	}
 
 	private static class AnyKeyMappingAccess implements BasicMappingAccess {
@@ -1339,6 +1353,11 @@ public Class<? extends UserType<?>> customType(MemberDetails attribute, ModelsCo
 		public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsContext context) {
 			return emptyMap();
 		}
+
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			return null;
+		}
 	}
 
 	private static class MapKeyMappingAccess implements BasicMappingAccess {
@@ -1357,6 +1376,12 @@ public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsCo
 			return customType == null ? null : extractParameterMap( customType.parameters() );
 
 		}
+
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			final var annotations = attribute.getMetaAnnotated( MapKeyType.class, context );
+			return annotations == null || annotations.isEmpty() ? null : annotations.get( 0 );
+		}
 	}
 
 	private static class CollectionIdMappingAccess implements BasicMappingAccess {
@@ -1373,7 +1398,12 @@ public Class<? extends UserType<?>> customType(MemberDetails attribute, ModelsCo
 		public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsContext context) {
 			final var customType = attribute.locateAnnotationUsage( CollectionIdType.class, context );
 			return customType == null ? null : extractParameterMap( customType.parameters() );
+		}
 
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			final var annotations = attribute.getMetaAnnotated( CollectionIdType.class, context );
+			return annotations == null || annotations.isEmpty() ? null : annotations.get( 0 );
 		}
 	}
 
@@ -1389,6 +1419,11 @@ public Class<? extends UserType<?>> customType(MemberDetails attribute, ModelsCo
 		public Map<String,String> customTypeParameters(MemberDetails attribute, ModelsContext context) {
 			return emptyMap();
 		}
+
+		@Override
+		public Annotation customTypeAnnotation(MemberDetails attribute, ModelsContext context) {
+			return null;
+		}
 	}
 
 	private static AnnotatedJoinColumns convertToJoinColumns(AnnotatedColumns columns, MetadataBuildingContext context) {
diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/ModelBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/ModelBinder.java
@@ -2029,9 +2029,9 @@ private BasicType<?> anyDiscriminatorType(Any anyBinding, TypeResolution discrim
 			);
 		}
 		else {
-			return metadataBuildingContext.getBootstrapContext()
-					.getTypeConfiguration().getBasicTypeRegistry()
-					.resolve( StandardBasicTypes.STRING );
+			return
+					metadataBuildingContext.getBootstrapContext().getTypeConfiguration().getBasicTypeRegistry()
+							.resolve( StandardBasicTypes.STRING );
 		}
 	}
 
diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java b/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java
@@ -4,6 +4,8 @@
  */
 package org.hibernate.mapping;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
@@ -1055,13 +1057,15 @@ public void setExplicitCustomType(Class<? extends UserType<?>> explicitCustomTyp
 				throw new UnsupportedOperationException( "Unsupported attempt to set an explicit-custom-type when value is already resolved" );
 			}
 			else {
+				final var typeProperties = getCustomTypeProperties();
+				final var typeAnnotation = getTypeAnnotation();
 				resolution = new UserTypeResolution<>(
 						new CustomType<>(
-								getConfiguredUserTypeBean( explicitCustomType, getCustomTypeProperties() ),
+								getConfiguredUserTypeBean( explicitCustomType, typeProperties, typeAnnotation ),
 								getTypeConfiguration()
 						),
 						null,
-						getCustomTypeProperties()
+						typeProperties
 				);
 			}
 		}
@@ -1078,11 +1082,9 @@ private Properties getCustomTypeProperties() {
 		return properties;
 	}
 
-	private UserType<?> getConfiguredUserTypeBean(Class<? extends UserType<?>> explicitCustomType, Properties properties) {
-		final var typeInstance =
-				getBuildingContext().getBuildingOptions().isAllowExtensionsInCdi()
-						? getUserTypeBean( explicitCustomType, properties ).getBeanInstance()
-						: FallbackBeanInstanceProducer.INSTANCE.produceBeanInstance( explicitCustomType );
+	private UserType<?> getConfiguredUserTypeBean(
+			Class<? extends UserType<?>> explicitCustomType, Properties properties, Annotation typeAnnotation) {
+		final var typeInstance = instantiateUserType( explicitCustomType, properties, typeAnnotation );
 
 		if ( typeInstance instanceof TypeConfigurationAware configurationAware ) {
 			configurationAware.setTypeConfiguration( getTypeConfiguration() );
@@ -1103,6 +1105,28 @@ private UserType<?> getConfiguredUserTypeBean(Class<? extends UserType<?>> expli
 		return typeInstance;
 	}
 
+	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
+			try {
+				final var constructor = customType.getDeclaredConstructor( typeAnnotation.annotationType() );
+				constructor.setAccessible( true );
+				return constructor.newInstance( typeAnnotation );
+			}
+			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()
+				: FallbackBeanInstanceProducer.INSTANCE.produceBeanInstance( customType );
+	}
+
 	private <T> ManagedBean<? extends T> getUserTypeBean(Class<T> explicitCustomType, Properties properties) {
 		final var producer = getBootstrapContext().getCustomTypeProducer();
 		final var managedBeanRegistry = getManagedBeanRegistry();
diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/SimpleValue.java b/hibernate-core/src/main/java/org/hibernate/mapping/SimpleValue.java
@@ -88,6 +88,7 @@ public abstract class SimpleValue implements KeyValue {
 
 	private String typeName;
 	private Properties typeParameters;
+	private Annotation typeAnnotation;
 	private boolean isVersion;
 	private boolean isNationalized;
 	private boolean isLob;
@@ -127,6 +128,7 @@ protected SimpleValue(SimpleValue original) {
 		this.partitionKey = original.partitionKey;
 		this.typeName = original.typeName;
 		this.typeParameters = original.typeParameters == null ? null : new Properties( original.typeParameters );
+		this.typeAnnotation = original.typeAnnotation;
 		this.isVersion = original.isVersion;
 		this.isNationalized = original.isNationalized;
 		this.isLob = original.isLob;
@@ -792,11 +794,19 @@ public void setTypeParameters(Map<String, ?> parameters) {
 		}
 	}
 
+	public void setTypeAnnotation(Annotation typeAnnotation) {
+		this.typeAnnotation = typeAnnotation;
+	}
+
 	public Properties getTypeParameters() {
 		return typeParameters;
 	}
 
-	public void copyTypeFrom( SimpleValue sourceValue ) {
+	public Annotation getTypeAnnotation() {
+		return typeAnnotation;
+	}
+
+	public void copyTypeFrom(SimpleValue sourceValue ) {
 		setTypeName( sourceValue.getTypeName() );
 		setTypeParameters( sourceValue.getTypeParameters() );
 
@@ -818,6 +828,7 @@ public boolean isSame(SimpleValue other) {
 		return Objects.equals( columns, other.columns )
 			&& Objects.equals( typeName, other.typeName )
 			&& Objects.equals( typeParameters, other.typeParameters )
+			&& Objects.equals( typeAnnotation, other.typeAnnotation )
 			&& Objects.equals( table, other.table )
 			&& Objects.equals( foreignKeyName, other.foreignKeyName )
 			&& Objects.equals( foreignKeyDefinition, other.foreignKeyDefinition );
diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/BitSetHelper.java b/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/BitSetHelper.java
@@ -16,7 +16,7 @@ public class BitSetHelper {
 	public static String bitSetToString(BitSet bitSet) {
 		StringBuilder builder = new StringBuilder();
 		for (long token : bitSet.toLongArray()) {
-			if (builder.length() > 0) {
+			if ( !builder.isEmpty() ) {
 				builder.append(DELIMITER);
 			}
 			builder.append(Long.toString(token, 2));
diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/BitSetMetaUserTypeTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/BitSetMetaUserTypeTest.java
diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/MetaUserTypeTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/mapping/basic/bitset/MetaUserTypeTest.java

Original file line number	Diff line number	Diff line change
`@@ -2029,9 +2029,9 @@ private BasicType<?> anyDiscriminatorType(Any anyBinding, TypeResolution discrim`
`2029`	`2029`	`);`
`2030`	`2030`	`}`
`2031`	`2031`	`else {`
`2032`		`- return metadataBuildingContext.getBootstrapContext()`
`2033`		`- .getTypeConfiguration().getBasicTypeRegistry()`
`2034`		`- .resolve( StandardBasicTypes.STRING );`
	`2032`	`+ return`
	`2033`	`+ metadataBuildingContext.getBootstrapContext().getTypeConfiguration().getBasicTypeRegistry()`
	`2034`	`+ .resolve( StandardBasicTypes.STRING );`
`2035`	`2035`	`}`
`2036`	`2036`	`}`
`2037`	`2037`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class BitSetHelper {`
`16`	`16`	`public static String bitSetToString(BitSet bitSet) {`
`17`	`17`	`StringBuilder builder = new StringBuilder();`
`18`	`18`	`for (long token : bitSet.toLongArray()) {`
`19`		`- if (builder.length() > 0) {`
	`19`	`+ if ( !builder.isEmpty() ) {`
`20`	`20`	`builder.append(DELIMITER);`
`21`	`21`	`}`
`22`	`22`	`builder.append(Long.toString(token, 2));`