Collection de cartes JPA d'énumérations

Existe-t-il un moyen dans JPA de mapper une collection d'énumérations dans la classe Entity? Ou la seule solution consiste à encapsuler Enum avec une autre classe de domaine et à l'utiliser pour mapper la collection?

@Entity
public class Person {
    public enum InterestsEnum {Books, Sport, etc...  }
    //@???
    Collection<InterestsEnum> interests;
}

J'utilise la mise en œuvre Hibernate JPA, mais je préférerais bien sûr une solution indépendante de la mise en œuvre.

en utilisant Hibernate, vous pouvez faire

@CollectionOfElements(targetElement = InterestsEnum.class)
@JoinTable(name = "tblInterests", joinColumns = @JoinColumn(name = "personID"))
@Column(name = "interest", nullable = false)
@Enumerated(EnumType.STRING)
Collection<InterestsEnum> interests;

Le lien dans la réponse d'Andy est un excellent point de départ pour mapper des collections d'objets "non-Entity" dans JPA 2, mais n'est pas tout à fait complet lorsqu'il s'agit de mapper des énumérations. Voici ce que j'ai proposé à la place.

@Entity
public class Person {
    @ElementCollection(targetClass=InterestsEnum.class)
    @Enumerated(EnumType.STRING) // Possibly optional (I'm not sure) but defaults to ORDINAL.
    @CollectionTable(name="person_interest")
    @Column(name="interest") // Column name in person_interest
    Collection<InterestsEnum> interests;
}

J'ai pu accomplir cela de cette manière simple:

@ElementCollection(fetch = FetchType.EAGER)
Collection<InterestsEnum> interests;

Un chargement hâtif est nécessaire afin d'éviter une erreur d'initialisation du chargement paresseux comme expliqué ici .

J'utilise une légère modification de java.util.RegularEnumSet pour avoir un EnumSet persistant:

@MappedSuperclass
@Access(AccessType.FIELD)
public class PersistentEnumSet<E extends Enum<E>> 
    extends AbstractSet<E> {
  private long elements;

  @Transient
  private final Class<E> elementType;

  @Transient
  private final E[] universe;

  public PersistentEnumSet(final Class<E> elementType) {
    this.elementType = elementType;
    try {
      this.universe = (E[]) elementType.getMethod("values").invoke(null);
    } catch (final ReflectiveOperationException e) {
      throw new IllegalArgumentException("Not an enum type: " + elementType, e);
    }
    if (this.universe.length > 64) {
      throw new IllegalArgumentException("More than 64 enum elements are not allowed");
    }
  }

  // Copy everything else from java.util.RegularEnumSet
  // ...
}

Cette classe est maintenant la base de tous mes ensembles d'énumérations:

@Embeddable
public class InterestsSet extends PersistentEnumSet<InterestsEnum> {
  public InterestsSet() {
    super(InterestsEnum.class);
  }
}

Et cet ensemble que je peux utiliser dans mon entité:

@Entity
public class MyEntity {
  // ...
  @Embedded
  @AttributeOverride(name="elements", column=@Column(name="interests"))
  private InterestsSet interests = new InterestsSet();
}

Avantages:

• Travailler avec une énumération de type sûre et performante dans votre code (voir java.util.EnumSet pour une description)
• L'ensemble est juste une colonne numérique dans la base de données
• tout est JPA simple (aucun type personnalisé spécifique au fournisseur )
• déclaration simple (et courte) de nouveaux champs du même type, par rapport aux autres solutions

Désavantages:

• Duplication de code (RegularEnumSet et PersistentEnumSetsont presque les mêmes)
  • Vous pouvez envelopper le résultat de EnumSet.noneOf(enumType)dans votre PersistenEnumSet, déclarer AccessType.PROPERTYet fournir deux méthodes d'accès qui utilisent la réflexion pour lire et écrire le elementschamp
• Une classe d'ensemble supplémentaire est nécessaire pour chaque classe d'énumération qui doit être stockée dans un ensemble persistant
  • Si votre fournisseur de persistance prend en charge intégrables sans constructeur public, vous pouvez ajouter @Embeddableà PersistentEnumSetdéposer la classe supplémentaire ( ... interests = new PersistentEnumSet<>(InterestsEnum.class);)
• Vous devez utiliser un @AttributeOverride, comme indiqué dans mon exemple, si vous en avez plus d'unPersistentEnumSet dans votre entité (sinon les deux seraient stockés dans la même colonne "éléments")
• L'accès à values()avec réflexion dans le constructeur n'est pas optimal (surtout lorsqu'on regarde les performances), mais les deux autres options ont aussi leurs inconvénients:
  • Une implémentation comme EnumSet.getUniverse()utilise une sun.miscclasse
  • Fournir le tableau de valeurs en tant que paramètre présente le risque que les valeurs données ne soient pas les bonnes
• Seules les énumérations avec jusqu'à 64 valeurs sont prises en charge (est-ce vraiment un inconvénient?)
  • Vous pouvez utiliser BigInteger à la place
• Il n'est pas facile d'utiliser le champ des éléments dans une requête de critères ou JPQL
  • Vous pouvez utiliser des opérateurs binaires ou une colonne de masque de bits avec les fonctions appropriées, si votre base de données prend en charge cela

tl; dr Une solution courte serait la suivante:

@ElementCollection(targetClass = InterestsEnum.class)
@CollectionTable
@Enumerated(EnumType.STRING)
Collection<InterestsEnum> interests;

La réponse longue est qu'avec ces annotations, JPA créera une table qui contiendra la liste d'InterestsEnum pointant vers l'identificateur de classe principal (Person.class dans ce cas).

@ElementCollections spécifie où JPA peut trouver des informations sur Enum

@CollectionTable crée la table qui contient la relation de Person à IntérêtsEnum

@Enumerated (EnumType.STRING) indique à JPA de conserver Enum en tant que chaîne, pourrait être EnumType.ORDINAL

Les collections dans JPA font référence à des relations un-à-plusieurs ou plusieurs-à-plusieurs et elles ne peuvent contenir que d'autres entités. Désolé, mais vous devez intégrer ces énumérations dans une entité. Si vous y réfléchissez, vous aurez besoin d'une sorte de champ d'identification et de clé étrangère pour stocker ces informations de toute façon. C'est à moins que vous ne fassiez quelque chose de fou comme stocker une liste séparée par des virgules dans une chaîne (ne faites pas cela!).