通用枚举 JPA AttributeConverter 实现

Question

我试图解决的问题

我正在尝试为 Hibernate 实现枚举映射。到目前为止，我已经研究了可用的选项，并且@Enumerated(EnumType.ORDINAL)和似乎都@Enumerated(EnumType.STRING)不足以满足我的需求。这@Enumerated(EnumType.ORDINAL)似乎很容易出错，因为仅仅对枚举常量进行重新排序就会搞乱映射，而且这也@Enumerated(EnumType.STRING)不够，因为我使用的数据库已经充满了要映射的值，而这些值并不是什么我希望我的枚举常量被命名为（值是外语字符串/整数）。

目前，所有这些值都被映射到字符串/整数属性。同时，属性应该只允许有限的值集（想象一下meetingStatus属性允许字符串：PLANNED、CANCELED和DONE。或者另一个属性允许有限的整数值集：1、2、3、4、5）。

我的想法是用枚举替换实现以提高代码的类型安全性。String / Integer 实现可能导致错误的一个很好的例子是表示此类值的 String 方法参数 - 使用 String 时，任何内容都会发生。另一方面，拥有 Enum 参数类型会引入编译时安全性。

到目前为止我最好的方法

似乎满足我需求的唯一解决方案是为每个枚举实现javax.persistence.AttributeConverter带有@Converter注释的自定义。由于我的模型需要相当多的枚举，因此为每个枚举编写自定义转换器很快就开始变得疯狂。因此，我寻找问题的通用解决方案 - >如何为任何类型的枚举编写通用转换器。以下答案在这里有很大帮助： https: //stackoverflow.com/a/23564597/7024402。答案中的代码示例提供了某种通用的实现，但对于每个枚举，仍然需要一个单独的转换器类。答案的作者还继续说道：

“另一种方法是定义一个自定义注释，修补 JPA 提供程序以识别该注释。这样，您可以在构建映射信息时检查字段类型，并将必要的枚举类型提供给纯通用转换器。”

这就是我认为我会感兴趣的。不幸的是，我找不到更多关于此的信息，并且我需要更多的指导来了解需要做什么以及它如何与这种方法一起工作。

目前的实施

public interface PersistableEnum<T> {
    T getValue();
}

public enum IntegerEnum implements PersistableEnum<Integer> {
    ONE(1),
    TWO(2),
    THREE(3),
    FOUR(4),
    FIVE(5),
    SIX(6);

    private int value;

    IntegerEnum(int value) {
        this.value = value;
    }

    @Override
    public Integer getValue() {
        return value;
    }
}

public abstract class PersistableEnumConverter<E extends PersistableEnum<T>, T> implements AttributeConverter<E, T> {

    private Class<E> enumType;

    public PersistableEnumConverter(Class<E> enumType) {
        this.enumType = enumType;
    }

    @Override
    public T convertToDatabaseColumn(E attribute) {
        return attribute.getValue();
    }

    @Override
    public E convertToEntityAttribute(T dbData) {
        for (E enumConstant : enumType.getEnumConstants()) {
            if (enumConstant.getValue().equals(dbData)) {
                return enumConstant;
            }
        }
        throw new EnumConversionException(enumType, dbData);
    }
}

@Converter
public class IntegerEnumConverter extends PersistableEnumConverter<IntegerEnum, Integer> {

    public IntegerEnumConverter() {
        super(IntegerEnum.class);
    }
}

这就是我能够实现部分通用转换器实现的方式。

目标：无需为每个枚举创建新的转换器类。

Answer 1

幸运的是，您不应该为此修补休眠状态。

1. 您可以声明如下所示的注释：

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.sql.Types;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


@Target({METHOD, FIELD}) 
@Retention(RUNTIME)
public @interface EnumConverter
{
   Class<? extends PersistableEnum<?>> enumClass() default IntegerEnum.class;

   int sqlType() default Types.INTEGER;
}

2. Hibernate 用户类型如下：

import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Objects;
import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.usertype.DynamicParameterizedType;
import org.hibernate.usertype.UserType;

public class PersistableEnumType implements UserType, DynamicParameterizedType
{
   private int sqlType;
   private Class<? extends PersistableEnum<?>> clazz;

   @Override
   public void setParameterValues(Properties parameters)
   {
      ParameterType reader = (ParameterType) parameters.get(PARAMETER_TYPE);

      EnumConverter converter = getEnumConverter(reader);
      sqlType = converter.sqlType();
      clazz = converter.enumClass();
   }

   private EnumConverter getEnumConverter(ParameterType reader)
   {
      for (Annotation annotation : reader.getAnnotationsMethod()){
         if (annotation instanceof EnumConverter) {
            return (EnumConverter) annotation;
         }
      }
      throw new IllegalStateException("The PersistableEnumType should be used with @EnumConverter annotation.");
   }

   @Override
   public int[] sqlTypes()
   {
      return new int[] {sqlType};
   }

   @Override
   public Class<?> returnedClass()
   {
      return clazz;
   }

   @Override
   public boolean equals(Object x, Object y) throws HibernateException
   {
      return Objects.equals(x, y);
   }

   @Override
   public int hashCode(Object x) throws HibernateException
   {
      return Objects.hashCode(x);
   }

   @Override
   public Object nullSafeGet(ResultSet rs,
         String[] names,
         SharedSessionContractImplementor session,
         Object owner) throws HibernateException, SQLException 
   {
      Object val = null;
      if (sqlType == Types.INTEGER) val = rs.getInt(names[0]);
      if (sqlType == Types.VARCHAR) val = rs.getString(names[0]);

      if (rs.wasNull()) return null;

      for (PersistableEnum<?> pEnum : clazz.getEnumConstants())
      {
         if (Objects.equals(pEnum.getValue(), val)) return pEnum;
      }
      throw new IllegalArgumentException("Can not convert " + val + " to enum " + clazz.getName());
   }

   @Override
   public void nullSafeSet(PreparedStatement st,
         Object value,
         int index,
         SharedSessionContractImplementor session) throws HibernateException, SQLException
   {
      if (value == null) {
         st.setNull(index, sqlType);
      }
      else {
         PersistableEnum<?> pEnum = (PersistableEnum<?>) value;
         if (sqlType == Types.INTEGER) st.setInt(index, (Integer) pEnum.getValue());
         if (sqlType == Types.VARCHAR) st.setString(index, (String) pEnum.getValue());
      }
   }

   @Override
   public Object deepCopy(Object value) throws HibernateException
   {
      return value;
   }

   @Override
   public boolean isMutable()
   {
      return false;
   }

   @Override
   public Serializable disassemble(Object value) throws HibernateException
   {
      return Objects.toString(value);
   }

   @Override
   public Object assemble(Serializable cached, Object owner) throws HibernateException
   {
      return cached;
   }

   @Override
   public Object replace(Object original, Object target, Object owner) throws HibernateException
   {
      return original;
   }
}

3. 然后，您可以使用它：

import org.hibernate.annotations.Type;

@Entity
@Table(name="TST_DATA")
public class TestData
{
   ...

   @EnumConverter(enumClass = IntegerEnum.class, sqlType = Types.INTEGER)
   @Type(type = "com.example.converter.PersistableEnumType")
   @Column(name="INT_VAL")
   public IntegerEnum getIntValue()
   ...

   @EnumConverter(enumClass = StringEnum.class, sqlType = Types.VARCHAR)
   @Type(type = "com.example.converter.PersistableEnumType")
   @Column(name="STR_VAL")
   public StringEnum getStrValue()
   ...
}

另请参阅Bauer、King、Gregory 撰写的优秀著作“Java Persistence with Hibernate”中的第5.3.3 章“Extending Hibernate with UserTypes ” 。