使用 Hibernate 的不区分大小写的枚举映射

Question

我得到了一个带有 state 列的实体。存储在数据库中的状态是活动的和非活动的（还有更多）。我给自己写了一个像下面这样的枚举

public enum State {

    ACTIVE("active"), INACTIVE("inactive");

    private String state;

    private State(String state) {
        this.state = state;
    }

}

实体看起来像：

@Entity
@Table(name = "TEST_DB")
public class MyEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "ID")
    private Integer id;
    @Enumerated(EnumType.STRING)
    @Column(name = "STATE", nullable = false)
    private Integer state;

    // constructor, getter, setter

}

很遗憾，我收到以下错误消息：

javax.ejb.EJBTransactionRolledbackException: Unknown name value [active] for enum class [state]

是否可以对枚举进行不区分大小写的休眠映射？

Answer 1

我遇到了类似的问题，找到了简单的答案。

你可以这样做：

@Column(name = "my_type")
@ColumnTransformer(read = "UPPER(my_type)", write = "LOWER(?)")
@Enumerated(EnumType.STRING)
private MyType type;

（您不需要在@ColumnTransformer 中“写入” - 对我来说，这是为了向后兼容，因为我的行仅小写。没有write，Hibernate 将在相同的情况下写入枚举，就像在枚举中的代码中一样常数）

Answer 2

您可以将枚举映射为带有休眠注释的 ORDINAL 或 STRING，例如：

@Enumerated(EnumType.ORDINAL)
private State state;

序数映射将枚举在数据库中的序数位置。如果您更改代码中枚举值的顺序，这将与现有数据库状态冲突。字符串映射将枚举的大写名称放入数据库中。如果你重命名一个枚举值，你会遇到同样的问题。

如果您想定义自定义映射（如您上面的代码），您可以创建org.hibernate.usertype.UserType 的实现，它显式映射枚举。

首先我建议对您的枚举进行一些更改，以使以下操作成为可能：

public enum State {

    ACTIVE("active"), INACTIVE("inactive");

    private String stateName;

    private State(String stateName) {
        this.stateName = stateName;
    }

    public State forStateName(String stateName) {
        for(State state : State.values()) {
            if (state.stateName().equals(stateName)) {
                return state;
            }
        }
        throw new IllegalArgumentException("Unknown state name " + stateName);
    }

    public String stateName() {
        return stateName;
    }
}

这是一个简单的 (!) UserType 实现：

public class StateUserType implements UserType {   

    private static final int[] SQL_TYPES = {Types.VARCHAR}; 

    public int[] sqlTypes() {   
        return SQL_TYPES;   
    }   

    public Class returnedClass() {   
        return State.class;   
    }   

    public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException, SQLException {   
        String stateName = resultSet.getString(names[0]);   
        State result = null;   
        if (!resultSet.wasNull()) {   
            result = State.forStateName(stateName);
        }   
        return result;   
    }   

    public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index) throws HibernateException, SQLException {   
        if (null == value) {   
            preparedStatement.setNull(index, Types.VARCHAR);   
        } else {   
            preparedStatement.setString(index, ((State)value).stateName());   
        }   
    }   

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

    public boolean isMutable() {   
        return false;   
    }   

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

    public Serializable disassemble(Object value) throws HibernateException {   
        return (Serializable)value;   
    }   

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

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

    public boolean equals(Object x, Object y) throws HibernateException {   
        if (x == y) {
            return true;
        }   
        if (null == x || null == y) {   
            return false;
        }
        return x.equals(y);   
    }   
}   

那么映射会变成：

@Type(type="foo.bar.StateUserType")
private State state;

关于如何实现 UserType 的另一个示例，请参见：http://www.gabiaxel.com/2011/01/better-enum-mapping-with-hibernate.html