Wie benutze ich Enum mit JPA als Datenmitglied von Persisted Entity?

Question

BITTE BESTE PRAKITION UND "Wie man" Enum mit JPA als Datenmitglied von Persisted Entity verwendet. Was ist die beste Praxis? Ich möchte "C", "O" von Enum bestehen. (Codes). Wenn dies nicht der richtige Ansatz ist, schlagen Sie bitte vor.

Enum Defmination ist -

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

Erwartete Lösung:Enum -Defmination:

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);
    }

}

Entitätsdefinition:

@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

Wir bestehen als Saiten. Verwenden @Enumerated(EnumType.STRING) Verwenden Sie die String -Darstellung (anstelle des automatischen Enum -Code). Das macht Ihre Daten im DB viel lesbarer.

Wenn Sie die Enums wirklich auf spezielle Codes (Legacy -Code und dergleichen) abbilden müssen, benötigen Sie eine benutzerdefinierte Zuordnung. Zunächst eine Basisklasse, die auf die DB und den Rücken bildet:

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() };
    }

}

Jetzt eine Erweiterung, die Dbenum verwendet, um Werte für Ihre Aufzüge auf die DB und zurück zu kartieren:

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);
        }
    }
}

Die Schnittstelle:

public interface DBEnum
{
    public String getDBCode ();
}

Zuletzt müssen Sie sich ausdehnen DBEnumType Für jeden Enum -Typ möchten Sie nachordnen:

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

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

}

Im Status, Sie müssen die statische Methode implementieren, die DB -Codes in Enums ordnet:

    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;
    }

Zuletzt müssen Sie die Annotation verwenden @org.hibernate.annotations.Type() Hibernate soll die benutzerdefinierte Zuordnung verwenden.

Schlussfolgerung: Verwenden Sie keine benutzerdefinierten Codes. Sie erzeugen nur eine Menge dummer Kesselplattencode, die Sie nicht berücksichtigen können.

Answer 3

Die Aufenthalte werden standardmäßig von JPA unterstützt, aber das Problem ist, dass sie die Ordnungswerte der Werte standardmäßig verwenden, die Sie nicht kontrollieren können. Um dies zu lösen, können Sie eine kleine Logik für Ihre Getter -Setter verwenden.

@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 sollten die Konvertierung durchführen ...