Est-il possible d'écrire un générique enum convertisseur pour JPA?

Ce que vous devez faire est d'écrire une classe générique de base, puis d'étendre que pour chaque type enum vous souhaitez persister. Ensuite, utilisez le type étendu dans le @Converter annotation:

public abstract class GenericEnumUppercaseConverter<E extends Enum<E>> implements AttributeConverter<E, String> {
    ...
}

public FooConverter
    extends GenericEnumUppercaseConverter<Foo> 
    implements AttributeConverter<Foo, String> //See Bug HHH-8854
{
    public FooConverter() {
        super(Foo.class);
    }
}

où Foo est l'enum vous souhaitez gérer.

L'alternative consisterait à définir un d'annotations personnalisées, le patch, la JPA fournisseur de reconnaître cette annotation. De cette façon, vous pouvez examiner le type de champ que vous construire la cartographie de l'information et de nourrir le nécessaire d'un type enum uniquement un convertisseur générique.

Connexes:

• https://hibernate.atlassian.net/browse/HHH-8854

Ma solution à ce problème ressemble et permet également l'utilisation de la JPA 2.1 Convertisseur de facilité. Hélas, les types génériques en Java 8 ne sont pas réifiée, et donc il ne semble pas être un moyen facile d'éviter d'écrire une catégorie distincte pour chaque enum de Java que vous voulez être en mesure de convertir vers/à partir d'un format de base de données.

Vous pouvez toutefois réduire le processus de rédaction d'un enum classe de convertisseur pur passe-partout. Les composants de cette solution sont:

1. Encodeable de l'interface; le contrat pour un enum classe qui donne accès à une String jeton pour chaque constante enum (également une usine pour obtenir la constante enum correspondant jeton)
2. AbstractEnumConverter classe; fournit le code pour traduire les jetons vers/à partir de enum constantes
3. Java énumérer les classes qui implémentent l' Encodeable interface
4. JPA convertisseur de classes qui étendent la AbstractEnumConverter classe

La Encodeable interface est simple et contient statique méthode de fabrique, forToken(), pour l'obtention d'enum constantes:

public interface Encodeable {

    String token();

    public static <E extends Enum<E> & Encodeable> E forToken(Class<E> cls, String tok) {
        final String t = tok.trim().toUpperCase();
        return Stream.of(cls.getEnumConstants())
                .filter(e -> e.token().equals(t))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Unknown token '" +
                        tok + "' for enum " + cls.getName()));
    }
}

La AbstractEnumConverter classe est une classe générique est aussi simple. Il met en œuvre la JPA 2.1 AttributeConverter interface, mais ne fournit aucune implémentations pour ses méthodes (parce que cette classe ne peut pas connaître les types de béton nécessaire pour obtenir les enum constantes). Au lieu de cela, il définit les méthodes d'aide que le béton convertisseur classes de la chaîne d':

public abstract class AbstractEnumConverter<E extends Enum<E> & Encodeable>
            implements AttributeConverter<E, String> {

    public String toDatabaseColumn(E attr) {
        return (attr == null)
                ? null
                : attr.token();
    }

    public E toEntityAttribute(Class<E> cls, String dbCol) {
        return (dbCol == null)
                ? null
                : Encodeable.forToken(cls, dbCol);
    }
}

Un exemple concret enum class que l'on pourrait maintenant être conservées dans une base de données avec JPA 2.1 Convertisseur installation est indiqué ci-dessous (notez qu'il met en œuvre Encodeable, et que le jeton pour chaque enum constante est définie comme un champ privé):

public enum GenderCode implements Encodeable {

    MALE   ("M"), 
    FEMALE ("F"), 
    OTHER  ("O");

    final String e_token;

    GenderCode(String v) {
        this.e_token = v;
    }

    @Override
    public String token() {
        return this.e_token;
    }
}

Le passe-partout pour tous les JPA 2.1 Convertisseur de classe devrait maintenant ressembler à ceci (notez que chaque convertisseur devra étendre AbstractEnumConverter et de fournir des implémentations pour les méthodes de la JPA AttributeConverter interface):

@Converter
public class GenderCodeConverter 
            extends AbstractEnumConverter<GenderCode> {

    @Override
    public String convertToDatabaseColumn(GenderCode attribute) {
        return this.toDatabaseColumn(attribute);
    }

    @Override
    public GenderCode convertToEntityAttribute(String dbData) {
        return this.toEntityAttribute(GenderCode.class, dbData);
    }
}