Cómo usar enumeraciones con JPA

¿Ha intentado almacenar el valor ordinal? Almacenar el valor de la cadena funciona bien si no tiene una cadena asociada al valor:

@Enumerated(EnumType.ORDINAL)

Tiene un problema aquí y es que las capacidades limitadas de JPA cuando se trata de manejar enumeraciones. Con enums tienes dos opciones:

1. Almacenarlos como un número igual a Enum.ordinal(), que es una idea terrible (en mi humilde opinión); o
2. Almacenarlos como una cadena igual a Enum.name(). Nota: no toString() como es de esperar, especialmente porque el comportamiento predeterminado para Enum.toString() es devolver name().

Personalmente creo que la mejor opción es (2).

Ahora tienes un problema en que está definiendo valores que no representan nombres de instancia de vailid en Java (es decir, utilizando un guion). Así que sus opciones son:

• Cambie sus datos;
• Persisten los campos de cadena y los convierten implícitamente a o desde enumeraciones en sus objetos; o
• Use extensiones no estándar como TypeConverters.

Las haría en ese orden (primero a último) como un orden de preferencia.

Alguien sugirió el convertidor de Oracle TopLink, pero probablemente esté utilizando Toplink Essentials, siendo la implementación de referencia JPA 1.0, que es un subconjunto del producto comercial Oracle Toplink.

Como otra sugerencia, recomiendo encarecidamente cambiar a EclipseLink. Es una implementación mucho más completa que Toplink Essentials y Eclipselink será la implementación de referencia de JPA 2.0 cuando se lance (esperado por JavaOne a mediados del próximo año).

public enum Rating {

    UNRATED ( "" ),
    G ( "G" ), 
    PG ( "PG" ),
    PG13 ( "PG-13" ),
    R ( "R" ),
    NC17 ( "NC-17" );

    private String rating;

    private static Map<String, Rating> ratings = new HashMap<String, Rating>();
    static {
        for (Rating r : EnumSet.allOf(Rating.class)) {
            ratings.put(r.toString(), r);
        }
    }

    private static Rating getRating(String rating) {
        return ratings.get(rating);
    }

    private Rating(String rating) {
        this.rating = rating;
    }

    @Override
    public String toString() {
        return rating;
    }
}

No se como hacer las asignaciones en el lado TopLink anotado de las cosas sin embargo.

No conozco los aspectos internos de toplink, pero mi conjetura educada es la siguiente: utiliza la calificación.Método valueOf (String s) para mapear en la otra dirección. no es posible anular valueOf (), por lo que debe atenerse a la convención de nomenclatura de java, para permitir un método valueOf correcto.

public enum Rating {

    UNRATED,
    G, 
    PG,
    PG_13 ,
    R ,
    NC_17 ;

    public String getRating() {
        return name().replace("_","-");;
    }
}

GetRating produce la calificación "legible por humanos". tenga en cuenta que el chanracter "-" no está permitido en el identificador de enumeración.

Por supuesto, tendrá que almacenar los valores en la base de datos como NC_17.

El problema es, creo, que JPA nunca se inició con la idea en mente de que podríamos tener un Esquema preexistente complejo ya en su lugar.

Creo que hay dos deficiencias principales resultantes de esto, específicas de Enum:

1. La limitación de usar name() y ordinal(). ¿Por qué no marcar un getter con @Id, como lo hacemos con @Entity?
2. Las enumeraciones suelen tener representación en la base de datos para permitir la asociación con todo tipo de metadatos, incluyendo nombre, un nombre descriptivo, tal vez algo con localización, etc. Necesitamos la facilidad de uso de una Enumeración combinada con la flexibilidad de una Entidad.

Ayuda a mi causa y vota sobre JPA_SPEC-47

¿Qué pasa con esto

public String getRating{  
   return rating.toString();
}

pubic void setRating(String rating){  
   //parse rating string to rating enum
   //JPA will use this getter to set the values when getting data from DB   
}  

@Transient  
public Rating getRatingValue(){  
   return rating;
}

@Transient  
public Rating setRatingValue(Rating rating){  
   this.rating = rating;
}

Con esto se usan las clasificaciones como Cadena tanto en la base de datos como en la entidad, pero se usa la enumeración para todo lo demás.

Use esta anotación

@Column(columnDefinition="ENUM('User', 'Admin')")

Enumeración public enum ParentalControlLevelsEnum { U("U"), PG("PG"), _12("12"), _15("15"), _18("18");

private final String value;

ParentalControlLevelsEnum(final String value) {
    this.value = value;
}

public String getValue() {
    return value;
}

public static ParentalControlLevelsEnum fromString(final String value) {
    for (ParentalControlLevelsEnum level : ParentalControlLevelsEnum.values()) {
        if (level.getValue().equalsIgnoreCase(value)) {
            return level;
        }
    }
    return null;
}

}

Comparar - > Enumeración

Public class RatingComparator implementa Comparator {

public int compare(final ParentalControlLevelsEnum o1, final ParentalControlLevelsEnum o2) {
    if (o1.ordinal() < o2.ordinal()) {
        return -1;
    } else {
        return 1;
    }
}

}

Resuelto!!! Donde encontré la respuesta: http://programming.itags.org/development-tools/65254 /

Brevemente, la conversión busca el nombre de enum, no el valor del atributo 'rating'. En su caso: Si tiene en la base de datos valores "NC-17", necesita tener en su enumeración:

Clasificación enum {
(...)
NC-17 ( "NC-17" );
(...)