HHH-19993 Introduce AnnotationBasedUserType

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

Author: quaff

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

@@ -67,6 +67,7 @@
 import org.hibernate.type.internal.ConvertedBasicTypeImpl;
 import org.hibernate.type.spi.TypeConfiguration;
 import org.hibernate.type.spi.TypeConfigurationAware;
+import org.hibernate.usertype.AnnotationBasedUserType;
 import org.hibernate.usertype.DynamicParameterizedType;
 import org.hibernate.usertype.UserType;
 
@@ -1107,10 +1108,15 @@ private Properties getCustomTypeProperties() {
 		return properties;
 	}
 
+	@SuppressWarnings( { "unchecked", "rawtypes" } )
 	private UserType<?> getConfiguredUserTypeBean(
 			Class<? extends UserType<?>> explicitCustomType, Properties properties, Annotation typeAnnotation, MemberDetails memberDetails) {
 		final var typeInstance = instantiateUserType( explicitCustomType, properties, typeAnnotation, memberDetails );
 
+		if ( typeInstance instanceof AnnotationBasedUserType annotationBased && typeAnnotation != null ) {
+			annotationBased.initialize( typeAnnotation, memberDetails.toJavaMember() );
+		}
+
 		if ( typeInstance instanceof TypeConfigurationAware configurationAware ) {
 			configurationAware.setTypeConfiguration( getTypeConfiguration() );
 		}

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

@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.usertype;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Member;
+import java.util.Properties;
+
+
+/**
+ * A {@link UserType} which receives parameters from a custom annotation.
+ *
+ * @param <A> The user type annotation type supported by an implementation
+ * @param <J> The java type
+ *
+ * @author Yanming Zhou
+ *
+ * @since 7.3
+ */
+public interface AnnotationBasedUserType<A extends Annotation, J> extends UserType<J> {
+	/**
+	 * Initializes this generation strategy for the given annotation instance.
+	 *
+	 * @param annotation an instance of the user type annotation type. Typically,
+	 *                   implementations will retrieve the annotation's attribute
+	 *                   values and store them in fields.
+	 * @param member the Java member annotated with the user type annotation.
+	 * @throws org.hibernate.HibernateException in case an error occurred during initialization, e.g. if
+	 *                                          an implementation can't create a value for the given property type.
+	 */
+	void initialize(A annotation, Member member);
+}

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

@@ -243,6 +243,7 @@
  *
  * @see org.hibernate.type.Type
  * @see org.hibernate.type.CustomType
+ * @see org.hibernate.usertype.AnnotationBasedUserType
  *
  * @see org.hibernate.annotations.Type
  * @see org.hibernate.annotations.TypeRegistration

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

@@ -12,6 +12,7 @@
 import org.hibernate.testing.orm.junit.EntityManagerFactoryScope;
 import org.hibernate.testing.orm.junit.Jpa;
 import org.hibernate.type.descriptor.WrapperOptions;
+import org.hibernate.usertype.AnnotationBasedUserType;
 import org.hibernate.usertype.UserType;
 import org.junit.jupiter.api.Test;
 
@@ -36,7 +37,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @Jpa(annotatedClasses = {MetaUserTypeTest.Thing.class, MetaUserTypeTest.SecondThing.class,
-		MetaUserTypeTest.ThirdThing.class, MetaUserTypeTest.Things.class})
+		MetaUserTypeTest.ThirdThing.class, MetaUserTypeTest.FourthThing.class, MetaUserTypeTest.Things.class})
 public class MetaUserTypeTest {
 
 	@Test void test(EntityManagerFactoryScope scope) {
@@ -75,6 +76,18 @@ public class MetaUserTypeTest {
 			assertEquals( Period.of( 1, 2, 3 ), thing.period );
 			assertEquals( Period.ofDays( 42 ), thing.days );
 		} );
+
+		scope.inTransaction( em -> {
+			FourthThing thing = new FourthThing();
+			thing.period = Period.of( 1, 2, 3 );
+			thing.days = Period.ofDays( 42 );
+			em.persist( thing );
+		} );
+		scope.inTransaction( em -> {
+			FourthThing thing = em.find( FourthThing.class, 1 );
+			assertEquals( Period.of( 1, 2, 3 ), thing.period );
+			assertEquals( Period.ofDays( 42 ), thing.days );
+		} );
 	}
 
 	@Test void testCollection(EntityManagerFactoryScope scope) {
@@ -118,6 +131,15 @@ public class MetaUserTypeTest {
 		Period days;
 	}
 
+	@Entity static class FourthThing {
+		@Id @GeneratedValue
+		long id;
+		@FourthTimePeriod
+		Period period;
+		@FourthTimePeriod(days = true)
+		Period days;
+	}
+
 	@Entity static class Things {
 		@Id @GeneratedValue
 		long id;
@@ -148,6 +170,13 @@ public class MetaUserTypeTest {
 		boolean days() default false;
 	}
 
+	@Type(FourthPeriodType.class)
+	@Target({METHOD, FIELD})
+	@Retention(RUNTIME)
+	public @interface FourthTimePeriod {
+		boolean days() default false;
+	}
+
 	static class PeriodType extends AbstractPeriodType {
 
 		PeriodType(TimePeriod timePeriod) {
@@ -169,14 +198,31 @@ static class ThirdPeriodType extends AbstractPeriodType {
 		ThirdPeriodType(ThirdTimePeriod timePeriod, Member member) {
 			super(timePeriod.days());
 			if ( !timePeriod.equals( ( (Field) member ).getAnnotation( ThirdTimePeriod.class ) )) {
+				// only for validation
 				throw new IllegalArgumentException(member + " should be annotated with " + timePeriod);
 			}
 		}
 
 	}
 
+	static class FourthPeriodType extends AbstractPeriodType implements AnnotationBasedUserType<FourthTimePeriod, Period> {
+
+		FourthPeriodType() {
+			super(false);
+		}
+
+		@Override
+		public void initialize(FourthTimePeriod timePeriod, Member member) {
+			days = timePeriod.days();
+			if ( !timePeriod.equals( ( (Field) member ).getAnnotation( FourthTimePeriod.class ) )) {
+				// only for validation
+				throw new IllegalArgumentException(member + " should be annotated with " + timePeriod);
+			}
+		}
+	}
+
 	static abstract class AbstractPeriodType implements UserType<Period> {
-		private final boolean days;
+		boolean days;
 
 		AbstractPeriodType(boolean days) {
 			this.days = days;