Comment faire une carte personnalisée énumérés entier ordinaux avec mise en veille prolongée?

J'ai un enum classe nommée Statut de

public enum Status {
    PENDING(0), SUCCESS(1), FAILED(-1);

    private int st;

    private Status(int st){
        this.st = st;
    }
}

et de l'autre classe j'essaie de carte ce statut enum

public void setStatus(Status status) {
        this.status = status;
    }

    @Enumerated(EnumType.ORDINAL)
    public Status getStatus() {
        return status;
    }

lorsque j'exécute ce code, j'obtiens

java.lang.IllegalArgumentException: Inconnu valeur ordinale pour enum données de la classe.Statut: -1
au org.mise en veille prolongée.type.EnumType.nullSafeGet(EnumType.java:93)
au org.mise en veille prolongée.type.CustomType.nullSafeGet(CustomType.java:124)
au org.mise en veille prolongée.type.AbstractType.hydrate(AbstractType.java:106)
au

mais j'ai déjà -1 dans enum définition.

OriginalL'auteur user1479203 | 2012-07-16

  1. 10

    Vous pouvez définir votre propre UserType qui définit le mode mise en veille prolongée doit mapper ces énumérations.

    Noter que l'ordinal définit l'index de la valeur d'enum et donc FAILED aurait l'ordinal 2. Pour la carte enum l'aide de ses propriétés de votre besoin d'un UserType mise en œuvre.

    Quelques liens:

    Utilisez le lien ci-dessous pour un bon tutoriel. Il m'a aidé à comprendre clairement. gabiaxel.com/2011/01/better-enum-mapping-with-hibernate.html

    OriginalL'auteur Thomas

  2. 8

    Voici une solution où une chaîne de caractères de l'étiquette est utilisée à la place d'un int id, cependant, il est simple de s'adapter.

    public class User { 
@Id
private int id;
@Type(type = "com.example.hibernate.LabeledEnumType")
private Role role;
}
public enum Role implements LabeledEnum {
ADMIN("admin"), USER("user"), ANONYMOUS("anon");
private final String label;
Role(String label) {
this.label = label;
}
@Override
public String getLabel() {
return label;
}
}
public interface LabeledEnum {
String getLabel();
}
public final class LabeledEnumType implements DynamicParameterizedType, UserType {
private Class<? extends Enum> enumClass;
@Override
public Object assemble(Serializable cached, Object owner)
throws HibernateException {
return cached;
}
@Override
public Object deepCopy(Object value) throws HibernateException {
return value;
}
@Override
public Serializable disassemble(Object value) throws HibernateException {
return (Serializable) value;
}
@Override
public boolean equals(Object x, Object y) throws HibernateException {
return x == y;
}
@Override
public int hashCode(Object x) throws HibernateException {
return x == null ? 0 : x.hashCode();
}
@Override
public boolean isMutable() {
return false;
}
@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
throws HibernateException, SQLException {
String label = rs.getString(names[0]);
if (rs.wasNull()) {
return null;
}
for (Enum value : returnedClass().getEnumConstants()) {
if (value instanceof LabeledEnum) {
LabeledEnum labeledEnum = (LabeledEnum) value;
if (labeledEnum.getLabel().equals(label)) {
return value;
}
}
}
throw new IllegalStateException("Unknown " + returnedClass().getSimpleName() + " label");
}
@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
throws HibernateException, SQLException {
if (value == null) {
st.setNull(index, Types.VARCHAR);
} else {
st.setString(index, ((LabeledEnum) value).getLabel());
}
}
@Override
public Object replace(Object original, Object target, Object owner)
throws HibernateException {
return original;
}
@Override
public Class<? extends Enum> returnedClass() {
return enumClass;
}
@Override
public int[] sqlTypes() {
return new int[]{Types.VARCHAR};
}
@Override
public void setParameterValues(Properties parameters) {
ParameterType params = (ParameterType) parameters.get( PARAMETER_TYPE );
enumClass = params.getReturnedClass();
}
}
    J'ai fait de même. Mais il me donner colonne "user_role_type" est de type utilisateurs.user_role, mais l'expression est de type bytea

    OriginalL'auteur user3099799

  3. 1

    Je voudrais suggérer solution de contournement suivante. J'ai d'abord été supprised il a travaillé, mais il est vraiment très simple:
    Pour enum:

        public enum Status {
PENDING(0), SUCCESS(1), FAILED(-1);
private int status;
private Status(int status){
this.status = status;
}
public String getStatus() {
return status;
}
public static Status parse(int id) {
Status status = null; //Default
for (Status item : Status.values()) {
if (item.getStatus().equals(id)) {
Status = item;
break;
}
}
return Status;
}
}

    classe

    class StatedObject{
@Column("status")
private int statusInt;
public Status getStatus() {
return Status.parse(statusString);
}
public void setStatus(Status paymentStatus) {
this.statusInt = paymentStatus.getStatus();
}
public String getStatusInt() {
return statusString;
}
public void setStatusInt(int statusInt) {
this.statusInt = statusInt;
}
}

    si vous êtes en utilisant hibernate dans hibernate fichier xml, il serait:

     <property name="statusInt "    column="status" type="java.lang.Integer" />

    qu'est-ce

    OriginalL'auteur Dariusz Dudziński