HHH-18998 pass annotation to constructor of UserType

Author: gavinking

hibernate-core/src/main/java/org/hibernate/annotations/Type.java

@@ -31,7 +31,7 @@
  * BigDecimal amount;
  * </pre>
  * <p>
- * we may define an annotation type:
+ * we may define a custom annotation type:
  * <pre>
  * &#64;Retention(RUNTIME)
  * &#64;Target({METHOD,FIELD})
@@ -47,6 +47,27 @@
  * <p>
  * which is much cleaner.
  * <p>
+ * An implementation of {@link UserType} applied via a custom annotation
+ * may declare a constructor which accepts the annotation instance,
+ * allowing the annotation to be used to configure the type.
+ * <pre>
+ * &#64;Retention(RUNTIME)
+ * &#64;Target({METHOD,FIELD})
+ * &#64;Type(MonetaryAmountUserType.class)
+ * public @interface MonetaryAmount {
+ * public Currency currency();
+ * }
+ * </pre>
+ * <pre>
+ * public class MonetaryAmountUserType implements UserType&lt;Amount&gt; {
+ * private final Currency currency;
+ * public MonetaryAmountUserType(MonetaryAmount annotation) {
+ * currency = annotation.currency();
+ * }
+ * ...
+ * }
+ * </pre>
+ * <p>
  * The use of a {@code UserType} is usually mutually exclusive with the
  * compositional approach of {@link JavaType} and {@link JdbcType}.
  *

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 );
 }
@@ -144,16 +144,15 @@ private static <T> BasicValue.Resolution<T> createResolution(
 MetadataBuildingContext context) {
 final var bootstrapContext = context.getBootstrapContext();
 final var typeConfiguration = bootstrapContext.getTypeConfiguration();
-final var instanceProducer = bootstrapContext.getCustomTypeProducer();
+
 final boolean isKnownType =
 Type.class.isAssignableFrom( typeImplementorClass )
 || UserType.class.isAssignableFrom( typeImplementorClass );
-
 // 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 );

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) {

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 );
 }
 }
 

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();

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 );

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

@@ -116,6 +116,13 @@
  * And then use the {@code @TimePeriod} annotation to apply our {@code UserType}:
  * <pre>&#64;TimePeriod Period period;</pre>
  * <p>
+ * The {@code @TimePeriod} annotation might even have members:
+ * <pre>&#64;TimePeriod(precision=DAYS) Period period;</pre>
+ * <p>
+ * In this case, the implementation of {@code UserType} may declare a constructor
+ * which accepts the annotation type, and use the values assigned to the members
+ * to customize its behavior.
+ * <p>
  * Finally, we could ask for our custom type to be used by default:
  * <pre>&#64;TypeRegistration(basicClass = Period.class, userType = PeriodType.class)</pre>
  * <p>

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));