如何使用枚举使用JPA作为持久实体的数据成员？

Question

请最佳实践和“如何”使用枚举与JPA作为持久实体的数据成员。 什么是最好的做法是什么？ 我想从枚举坚持“C”，“O”。 （代码）。如果这不是正确的做法请建议。

枚举认定中为 -

public enum Status{
CLOSED ("C")
OPEN ("O")
private final int value;
private Status(final int pValue){
this.value = pValue;
}

public int value(){
 return this.value;
}

Answer 1

预期解决方案： 的枚举认定中：

public enum Status {
    CLOSED(1), NEW(2), RUNNING(3), OPEN(4), ADDED(5), SUCEESS(-1), DONE(0);
        private int code;
        private Status(int code) {
        this.code = code;
    }
        public int getCode() {
        return code;
    }
        public void setCode(int code) {
        this.code = code;
    }
        public static Status valueOf(int i){
        for (Status s : values()){
            if (s.code == i){
                return s;
            }
        }
        throw new IllegalArgumentException("No matching constant for " + i);
    }

}

<强>实体定义：

@Entity
@NamedQuery(name="Process.findAll", query="select p from Process p ")
public class Process {

    @Id
    private long id;
    private String name;

    @Transient
    private transient Status status; //actual enum; not stored in db
        @Column(name="STATUS")  
    private int statusCode; // enum code gets stored in db

    @PrePersist
    void populateDBFields(){
        statusCode = status.getCode();
    }

    @PostLoad
    void populateTransientFields(){
        status = Status.valueOf(statusCode);
    }
    public long getId() {
        return id;
    }
        public void setId(long id) {
        this.id = id;
    }
        public String getName() {
        return name;
    }
        public void setName(String name) {
        this.name = name;
    }
        public Status getStatus() {
        return status;
    }
        public void setStatus(Status status) {
        this.status = status;
    }
}

Answer 2

我们坚持枚举的字符串。使用@Enumerated(EnumType.STRING)使用字符串表示（而不是自动枚举代码）。这使得在DB你的数据更具有可读性。

如果你真的需要的枚举特殊代码（遗留代码等）地图，你需要一个自定义映射。第一基类，其映射枚举到DB和背面：

import java.io.Serializable;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;


public abstract class CustomEnumType implements UserType
{
    public Object deepCopy (Object value) throws HibernateException
    {
        return value;
    }

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

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

    public boolean equals (Object x, Object y) throws HibernateException
    {
        // Correct for Enums
        return x == y;
    }

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

    public boolean isMutable ()
    {
        return false;
    }

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

    public int[] sqlTypes ()
    {
        return new int[]{ Hibernate.STRING.sqlType() };
    }

}

现在其使用DBEnum为您的枚举到DB和映射回值的扩展名：

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.apache.log4j.Logger;

public abstract class DBEnumType extends CustomEnumType
{
    private final static Logger log = Logger.getLogger(DBEnumType.class);
    private static final boolean IS_VALUE_TRACING_ENABLED = log.isTraceEnabled();

    public Object nullSafeGet (ResultSet rs, String[] names, Object owner)
            throws HibernateException, SQLException
    {
        String value = rs.getString (names[0]);
        if (rs.wasNull ())
            return null;

        return toEnum (value);
    }

    public abstract Object toEnum (String value);

    public void nullSafeSet (PreparedStatement st, Object value, int index)
            throws HibernateException, SQLException
    {
        if (value == null)
            st.setNull (index, Hibernate.STRING.sqlType ());
        else
        {
            DBEnum dbEnum = (DBEnum)value;
            value = dbEnum.getDBCode();
            st.setString (index, dbEnum.getDBCode());
        }

        if (IS_VALUE_TRACING_ENABLED)
        {
            log.trace (getClass().getName()+" "+value);
        }
    }
}

接口：

public interface DBEnum
{
    public String getDBCode ();
}

最后，必须为要映射的每个枚举类型延伸DBEnumType

public class DBEnumCardType extends DBEnumType
{
    public Class returnedClass ()
    {
        return Status.class;
    }

    public Object toEnum (String value)
    {
        return Status.fromDBCode (value);
    }

}

在Status，必须实现该DB代码映射到枚举静态方法：

    private final static Map<String, Status> dbCode2Enum = new HashMap<String, Status> ();
    static {
        for (Status enm: Status.values ())
        {
            String key = enm.getDBCode ();
            if (dbCode2Enum.containsKey (key))
                throw new ShouldNotHappenException ("Duplicate key "+key+" in "+enm.getClass ());
            dbCode2Enum.put (key, enm);
        }
    }

    private String dbCode;

    private Status (String dbCode)
    {
        this.dbCode = dbCode;
    }

    public String getDBCode ()
    {
        return dbCode;
    }

    public static Status fromDBCode (String dbCode)
    {
        if (dbCode == null)
            return null;

        Status result = dbCode2Enum.get (dbCode);
        if (result == null)
            throw new ShouldNotHappenException ("Can't find key "+dbCode+" in "+Status.class);

        return result;
    }

最后，你必须使用注解@org.hibernate.annotations.Type()让Hibernate使用自定义映射。

结论：不要使用自定义代码。他们只是产生了很多愚蠢的锅炉板代码，你不能出去的因素。

Answer 3

枚举是由JPA支持默认值，但问题是，他们在默认情况下，你无法控制使用的值的序。 为了解决这个问题，你可以在你的getter setter方法使用一点逻辑。

@Column(name = "KIRSAL_METROPOL")
private String someEnum;
public YourEnum getSomeEnum() {
    return EnumUtils.getEnum(YourEnum.class, this.someEnum);
}

public void setSomeEnum(YourEnum someEnum) {
    this. someEnum = EnumUtils.getValue(someEnum);
}

EnumUtils应该做转换...