请提供使用 enum 和 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;
}
预期解决方案: 枚举定义:
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;
}
}
我们将枚举保留为字符串。使用
@Enumerated(EnumType.STRING)
使用字符串表示形式(而不是自动枚举代码)。这使得数据库中的数据更具可读性。
如果您确实需要将枚举映射到特殊代码(旧代码等),则需要自定义映射。首先是一个基类,它将枚举映射到数据库并返回:
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 将枚举值映射到数据库并返回的扩展:
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
中,您必须实现将数据库代码映射到枚举的静态方法:
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 使用自定义映射。
结论:不要使用自定义代码。他们只是生成大量愚蠢的样板代码,您无法将其分解出来。
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 应该进行转换...