Carte enum en JPA avec des valeurs fixes?

Pour les versions antérieures à JPA 2.1, JPA ne fournit que deux façons de traiter les énumérations, par leur name ou par leur ordinal. Et la norme JPA ne prend pas en charge les types personnalisés. Donc:

• Si vous voulez faire la coutume des conversions de type, vous aurez à utiliser un fournisseur d'extension (avec mise en veille prolongée UserType, EclipseLink Converter, etc). (la deuxième solution). ~ou~
• Vous aurez à utiliser le @PrePersist et @test de charge truc (la première solution). ~ou~
• Annoter le getter et le setter de la prise et le retour de l' int valeur de ~ou~
• Utiliser un attribut entier au niveau de l'entité et d'effectuer une traduction dans les getters et les setters.

Je vais illustrer la dernière option (c'est une base de mise en œuvre, l'ajuster si nécessaire):

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

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

        private int value;

        Right(int value) { this.value = value; }    

        public int getValue() { return value; }

        public static Right parse(int id) {
            Right right = null; //Default
            for (Right item : Right.values()) {
                if (item.getValue()==id) {
                    right = item;
                    break;
                }
            }
            return right;
        }

    };

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

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

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

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

}

La meilleure approche serait à la carte un ID unique à chaque type enum, évitant ainsi les pièges de l'ORDINAL et de la CORDE. Voir ce post qui décrit les 5 façons vous pouvez mapper un enum.

Prises à partir du lien ci-dessus:

1&2. À L'Aide De @Énumérés

Actuellement, il existe 2 façons de carte enums au sein de votre entités JPA à l'aide de @Énumérés annotation. Malheureusement, les deux EnumType.CHAÎNE et EnumType.ORDINAL ont leurs limites.

Si vous utilisez EnumType.Chaîne puis de renommer l'un de vos types enum sera la cause de votre valeur d'enum à être en décalage avec les valeurs enregistrées dans la base de données. Si vous utilisez EnumType.ORDINAL alors la suppression ou la réorganisation de la des types dans votre enum va provoquer les valeurs enregistrées dans la base de données de la carte de la mauvaise enums types.

Ces deux options sont fragiles. Si l'enum est modifiée sans procéder à une migration de base de données, vous pouvez jeopodise l'intégrité de vos données.

3. Callbacks

Une solution possible serait d'utiliser la JPA du cycle de vie de retour d'appel annotations @PrePersist et @test de charge. C'est assez laid que vous aurez maintenant deux variables dans votre entité. Une cartographie de la valeur stockée dans la base de données, et de l'autre, le réel de l'enum.

4. Cartographie ID unique à chaque type enum

La meilleure solution est de faire un plan de votre enum à une valeur fixe, ou ID, défini dans l'enum. La cartographie de prédéfinies, fixe la valeur de votre code plus robuste. Toute modification de la commande de la enums types, ou le refactoring des noms, ne provoque pas d'effets indésirables.

5. À l'aide de Java EE7 @Convertir

Si vous êtes en utilisant JPA 2.1, vous avez la possibilité d'utiliser le nouveau @Convertir annotation. Cela nécessite la création d'une classe de convertisseur, annotée avec @Convertisseur, à l'intérieur de ce qui vous permettrait de définir quelles sont les valeurs sont enregistrées dans la base de données pour chaque type enum. Au sein de votre entité, vous serait alors d'annoter vos enum avec @Convertir.

Ma préférence: (Numéro 4)

La raison pourquoi je préfère définir mon ID est dans l'énumération que s'opposer à l'utilisation d'un convertisseur, il est bon de l'encapsulation. Seul le type enum doit connaître son ID, et seule l'entité doit savoir au sujet de la façon dont il les cartes de l'enum à la base de données.

Voir l'original post pour l'exemple de code.

Le problème est, je pense, que JPA n'a jamais été initié à l'esprit l'idée que nous pourrions avoir un complexe préexistante Schéma déjà en place.

Je pense qu'il y a deux principaux défauts qui en résultent, et spécifiques à Enum:

1. La limitation de l'utilisation de (nom) et ordinal(). Pourquoi ne pas se contenter de marquer un getter avec @Id, la façon dont nous le faisons avec @Entity?
2. Enum ont généralement de la représentation dans la base de données pour permettre à l'association avec toutes sortes de métadonnées, y compris un nom propre, un nom descriptif, peut-être quelque chose avec la localisation etc. Nous avons besoin de la facilité d'utilisation d'un Enum combinée avec la souplesse d'une Entité.

Aider ma cause et de voter sur JPA_SPEC-47

Ne serait-ce pas plus élégant qu'à l'aide d'un @Convertisseur pour résoudre le problème?

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

Je voudrais faire ce qui suit:

Déclarer separetly l'enum, dans son propre fichier:

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


}

Déclarer une nouvelle JPA entité nommée Droit

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


}

Vous aurez également besoin d'un convertisseur pour la réception de ces valeurs (JPA 2.1 seule et theres un problème de Mauvais pas ici discuter avec ces énumérations d'être directement persisté à l'aide du convertisseur, donc ce sera une route à sens unique seulement)

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

}

L'Autorité de l'entité:

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

}

En procédant de cette façon, tu ne peux pas régler directement à l'enum champ. Toutefois, vous pouvez définir le champ de Droite au pouvoir, de l'aide

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

Et si vous avez besoin de comparer, vous pouvez utiliser:

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

Qui est plutôt cool, je pense. Son pas tout à fait correcte, puisque le convertisseur de ses pas destiné à être utilisé avec des enums. En fait, la documentation dit de ne jamais l'utiliser à cette fin, vous devez utiliser le @Énumérés annotation à la place. Le problème, c'est qu'il y a seulement deux types enum: ORDINALE ou de la CHAÎNE, mais l'ORDINAL est délicate et risqué.

---

Cependant, si il ne marche pas vous satisfaire, vous pouvez faire quelque chose d'un peu plus hacky et plus simple (ou pas).

Permet de voir.

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


}

et l'Autorité de l'entité

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

}

Dans cette deuxième idée, ce n'est pas une situation parfaite puisque nous pirater l'attribut ordinal, mais son beaucoup moins de codage.

Je pense que la spécification JPA devrait inclure la EnumType.ID où la valeur d'enum champ doit être annoté avec une sorte de @EnumId annotation.