Map enum en JPA con valores fijos?

Esto ahora es posible con JPA 2.1:

@Column(name = "RIGHT")
@Enumerated(EnumType.STRING)
private Right right;

Más detalles:

• http://java.dzone.com/articles/mapping-enums-done-right
• http://www.thoughts-on-java.org/jpa-21-how-to-implement-type-converter /

El mejor enfoque sería asignar un ID único a cada tipo de enumeración, evitando así las trampas de ORDINAL y STRING. Vea este post que describe 5 formas en que puede mapear una enumeración.

Tomado del enlace de arriba:

1&2. Usando @Enumerated

Actualmente hay 2 formas en que puede asignar enumeraciones dentro de sus entidades JPA utilizando la anotación @Enumerated. Desafortunadamente tanto EnumType.STRING y EnumType.ORDINAL tienen sus limitaciones.

Si usa EnumType.String luego cambiar el nombre de uno de sus tipos de enumeración hará que su valor de enumeración no esté sincronizado con los valores guardados en la base de datos. Si usa EnumType.ORDINAL luego eliminar o reordenar los tipos dentro de su enumeración hará que los valores guardados en la base de datos se asignen a los tipos de enumeración incorrectos.

Ambas opciones son frágiles. Si la enumeración se modifica sin realizar una migración de la base de datos, podría poner en peligro la integridad de sus datos.

3. Lifecycle Callbacks

Una posible solución sería usar las anotaciones de devolución de llamada del ciclo de vida de JPA, @PrePersist y @PostLoad. Esto se siente bastante feo ya que ahora tendrá dos variables en su entidad. Uno mapea el valor almacenado en la base de datos, y el otro, la enumeración real.

4. Asignación de ID único a cada tipo de enumeración

La solución preferida es asignar su enumeración a un valor fijo, o ID, definido dentro de la enumeración. La asignación a un valor fijo predefinido hace que su código sea más robusto. Cualquier modificación en el orden de los tipos de enumeraciones, o la refactorización de los nombres, no causará ningún efecto adverso.

5. Usando Java EE7 @Convert

Si está utilizando JPA 2.1 tiene la opción de usar la nueva anotación @Convert. Esto requiere la creación de una clase de convertidor, anotada con @Converter, dentro de la cual definiría qué valores se guardan en la base de datos para cada tipo de enumeración. Dentro de su entidad, entonces anotaría su enumeración con @Convertir.

Mi preferencia: (Número 4)

La razón por la que prefiero definir mis ID dentro de la enumeración en oposición al uso de un convertidor, es una buena encapsulación. Solo el tipo de enumeración debe saber de su ID, y solo la entidad debe saber cómo se asigna la enumeración a la base de datos.

Ver el original post para el ejemplo de código.

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

¿No sería esto más elegante que usar un @Converter para resolver el problema?

// Note: this code won't work!!
// it is just a sample of how I *would* want it to work!
@Enumerated
public enum Language {
  ENGLISH_US("en-US"),
  ENGLISH_BRITISH("en-BR"),
  FRENCH("fr"),
  FRENCH_CANADIAN("fr-CA");
  @ID
  private String code;
  @Column(name="DESCRIPTION")
  private String description;

  Language(String code) {
    this.code = code;
  }

  public String getCode() {
    return code;
  }

  public String getDescription() {
    return description;
  }
}

Desde JPA 2.1 puedes usar AttributeConverter.

Crea una clase enumerada así:

public enum NodeType {

    ROOT("root-node"),
    BRANCH("branch-node"),
    LEAF("leaf-node");

    private final String code;

    private NodeType(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

Y crea un convertidor como este:

import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

@Converter(autoApply = true)
public class NodeTypeConverter implements AttributeConverter<NodeType, String> {

    @Override
    public String convertToDatabaseColumn(NodeType nodeType) {
        return nodeType.getCode();
    }

    @Override
    public NodeType convertToEntityAttribute(String dbData) {
        for (NodeType nodeType : values()) {
            if (nodeType.getCode().equals(dbData)) {
                return nodeType;
            }
        }

        throw new IllegalArgumentException("Unknown database value:" + dbData);
    }
}

En la entidad solo necesitas:

@Column(name = "node_type_code")

Su suerte con @Converter(autoApply = true) puede variar según el contenedor, pero probado para funcionar en Wildfly 8.1.0. Si no funciona, puede agregar @Convert(converter = NodeTypeConverter.class) en la columna entity class.

Posiblemente código relacionado cercano de Pascal

@Entity
@Table(name = "AUTHORITY_")
public class Authority implements Serializable {

    public enum Right {
        READ(100), WRITE(200), EDITOR(300);

        private Integer value;

        private Right(Integer value) {
            this.value = value;
        }

        // Reverse lookup Right for getting a Key from it's values
        private static final Map<Integer, Right> lookup = new HashMap<Integer, Right>();
        static {
            for (Right item : Right.values())
                lookup.put(item.getValue(), item);
        }

        public Integer getValue() {
            return value;
        }

        public static Right getKey(Integer value) {
            return lookup.get(value);
        }

    };

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "AUTHORITY_ID")
    private Long id;

    @Column(name = "RIGHT_ID")
    private Integer rightId;

    public Right getRight() {
        return Right.getKey(this.rightId);
    }

    public void setRight(Right right) {
        this.rightId = right.getValue();
    }

}

Haría lo siguiente:

Declarar separadamente la enumeración, en su propio archivo:

public enum RightEnum {
      READ(100), WRITE(200), EDITOR (300);

      private int value;

      private RightEnum (int value) { this.value = value; }


      @Override
      public static Etapa valueOf(Integer value){
           for( RightEnum r : RightEnum .values() ){
              if ( r.getValue().equals(value))
                 return r;
           }
           return null;//or throw exception
     }

      public int getValue() { return value; }


}

Declarar una nueva entidad JPA llamada Right

@Entity
public class Right{
    @Id
    private Integer id;
    //FIElDS

    // constructor
    public Right(RightEnum rightEnum){
          this.id = rightEnum.getValue();
    }

    public Right getInstance(RightEnum rightEnum){
          return new Right(rightEnum);
    }


}

También necesitará un convertidor para recibir estos valores (solo JPA 2.1 y hay un problema que no discutiré aquí con estas enumeraciones que se persistirán directamente usando el convertidor, por lo que será un camino de una sola dirección)

import mypackage.RightEnum;
import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

/**
 * 
 * 
 */
@Converter(autoApply = true)
public class RightEnumConverter implements AttributeConverter<RightEnum, Integer>{

    @Override //this method shoudn´t be used, but I implemented anyway, just in case
    public Integer convertToDatabaseColumn(RightEnum attribute) {
        return attribute.getValue();
    }

    @Override
    public RightEnum convertToEntityAttribute(Integer dbData) {
        return RightEnum.valueOf(dbData);
    }

}

La entidad de autoridad:

@Entity
@Table(name = "AUTHORITY_")
public class Authority implements Serializable {


  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "AUTHORITY_ID")
  private Long id;

  // the **Entity** to map : 
  private Right right;

  // the **Enum** to map (not to be persisted or updated) : 
  @Column(name="COLUMN1", insertable = false, updatable = false)
  @Convert(converter = RightEnumConverter.class)
  private RightEnum rightEnum;

}

Al hacer esto, no puede establecer directamente en el campo enumeración. Sin embargo, puede establecer el campo correcto en Autoridad usando

autorithy.setRight( Right.getInstance( RightEnum.READ ) );//for example

Y si necesitas comparar, puedes usar:

authority.getRight().equals( RightEnum.READ ); //for example

Lo cual es bastante genial, creo. No es totalmente correcto, ya que el convertidor no está destinado a ser utilizado con enumeraciones. En realidad, la documentación dice que nunca lo use para este propósito, debe usar la anotación @Enumerated en su lugar. El problema es que solo hay dos tipos de enum: ORDINAL o STRING, pero el ORDINAL es complicado y no seguro.

Sin embargo, si no te satisface, puedes hacer algo un poco más hackeado y simple (o no).

Veamos.

El RightEnum:

public enum RightEnum {
      READ(100), WRITE(200), EDITOR (300);

      private int value;

      private RightEnum (int value) { 
            try {
                  this.value= value;
                  final Field field = this.getClass().getSuperclass().getDeclaredField("ordinal");
                  field.setAccessible(true);
                  field.set(this, value);
             } catch (Exception e) {//or use more multicatch if you use JDK 1.7+
                  throw new RuntimeException(e);
            }
      }


      @Override
      public static Etapa valueOf(Integer value){
           for( RightEnum r : RightEnum .values() ){
              if ( r.getValue().equals(value))
                 return r;
           }
           return null;//or throw exception
     }

      public int getValue() { return value; }


}

Y la entidad autoridad

@Entity
@Table(name = "AUTHORITY_")
public class Authority implements Serializable {


  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "AUTHORITY_ID")
  private Long id;


  // the **Enum** to map (to be persisted or updated) : 
  @Column(name="COLUMN1")
  @Enumerated(EnumType.ORDINAL)
  private RightEnum rightEnum;

}

En esta segunda idea, no es una situación perfecta ya que hackeamos el atributo ordinal, pero es una codificación mucho más pequeña.

Creo que la especificación de JPA debería incluir EnumType.ID donde el campo de valor de enumeración debe anotarse con algún tipo de anotación @EnumId.