Java Enums, JPA et Postgres enums - Comment puis-je les faire travailler ensemble?

Nous avons une postgres DB avec postgres des enums. Nous commençons à construire JPA dans notre application. Nous avons aussi Java énumérations qui reflètent les postgres des enums. Maintenant la grande question est de savoir comment obtenir JPA pour comprendre Java enums sur un côté et postgres enums sur l'autre? La Java côté devrait être assez facile, mais je ne suis pas sûr de la façon de faire de postgres côté.

nous nous dirigeons maintenant notre système de JPA trop, mais nous avons java enums mappés à des colonnes varchar encore eu aucun problème avec Hibernate

InformationsquelleAutor Jasper Floor | 2009-05-12

22

Cela implique de faire des correspondances multiples.

Tout d'abord, une Postgres enum est renvoyé par le pilote JDBC comme une instance de type PGObject. Le type de propriété de ce qui a le nom de votre postgres enum, et la valeur de la propriété à sa valeur. (L'ordinal n'est pas stocké cependant, techniquement, ce n'est pas un enum plus et même complètement inutile à cause de cela)

De toute façon, si vous avez une définition de ce genre dans Postgres:
```
CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
 
```
Puis le resultset contient un PGObject de type "humeur" et "heureux" d'une colonne d'avoir ce type d'énumération et une ligne avec la valeur "heureux".

Prochaine chose à faire est d'écrire quelques intercepteur code qui se trouve entre l'endroit où JPA lit à partir de la crue resultset et définit la valeur de votre entité. E. g. supposons que vous avez eu l'entité suivante en Java:
```
public @Entity class Person {

  public static enum Mood {sad, ok, happy}

  @Id Long ID;
  Mood mood;

}
 
```
Malheureusement, JPA n'est pas facile d'interception point où vous pouvez faire la conversion de PGObject à la Java enum Humeur. La plupart des APC, les vendeurs ont cependant certaines propriétaire de soutien pour cette. Hibernate, par exemple, la définition de type et d'annotations de Type pour ce (à partir de Hibernate-annotations.jar).
```
@TypeDef(name="myEnumConverter", typeClass=MyEnumConverter.class)
public @Entity class Person {

  public static enum Mood {sad, ok, happy}

  @Id Long ID;
  @Type(type="myEnumConverter") Mood mood;
 
```
Ces vous permettent de fournir une instance de UserType (à partir de Hibernate-core.jar) qui effectue la conversion:
```
public class MyEnumConverter implements UserType {

    private static final int[] SQL_TYPES = new int[]{Types.OTHER};

    public Object nullSafeGet(ResultSet arg0, String[] arg1, Object arg2) throws HibernateException, SQLException {

        Object pgObject = arg0.getObject(X); //X is the column containing the enum

        try {
            Method valueMethod = pgObject.getClass().getMethod("getValue");
            String value = (String)valueMethod.invoke(pgObject);            
            return Mood.valueOf(value);     
        }
        catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    public int[] sqlTypes() {       
        return SQL_TYPES;
    }

    //Rest of methods omitted

}
 
```
Ce n'est pas une complète solution de travail, mais juste un petit pointeur espérons-le, dans la bonne direction.
- >nous nous dirigeons maintenant notre système de JPA trop, mais nous avons java enums mappés à des colonnes varchar encore eu aucun problème avec Hibernate varchars agréable à regarder dans la bd, mais vous oubliez 2 choses par rapport à la vraie énumérations dans la base de données: * Type de sécurité, sauf si vous souhaitez ajouter une contrainte de vérification pour chaque colonne ou d'utiliser un FK à une autre table qui contient tous les types varchar valeurs de PK. * La vitesse. chaîne de recherches et compare sont plus lents, même lors de l'indexation. Si ses un compromis de toute façon. Soit vous utilisez varchars, et sauf les restrictions ci-dessus, ou si vous utilisez natif PG enums et accepter la non-cartographie automatique.
- p.s. Il existe une troisième voie, la cartographie par ordinale, mais ce n'est pas vraiment recommandé; à rendre le code difficile à lire un fragile; si vous ou supprimer une seule constante de votre enum de Java, tous les ordinaux qui sont déjà dans la base de données peut devenir non valide!
- Est-il une raison pour utiliser la réflexion au lieu de casting pour PgObject?
- pour éviter le temps de compilation de dépendance. Pas chaque projet possède le pilote sur son chemin de classe, par exemple, souvent le conducteur est dans certains /lib dossier du serveur. Si ce n'est pas une question pour vous, vous n'avez pas à utiliser la réflexion.
InformationsquelleAutor Arjan Tijms
20

En fait, j'ai été en utilisant une méthode plus simple que celle avec PGObject et les Convertisseurs. Depuis dans Postgres les énumérations sont convertis tout à fait naturellement à partir du texte, vous avez juste besoin de le laisser faire ce qu'il fait de mieux. Je vais emprunter Arjan de l'exemple de la bonne humeur, s'il n'a pas l'esprit:

Le type enum dans Postgres:
```
CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
```
La classe enum en Java:
```
public @Entity class Person {

  public static enum Mood {sad, ok, happy};

  @Enumerated(EnumType.STRING)
  Mood mood;
```
}

Que @Énumérés tag dit que la sérialisation/désérialisation de l'enum doit être fait dans le texte. Sans cela, il utilise des int, ce qui est plus gênant qu'autre chose.

À ce stade, vous avez deux options. Vous pouvez soit:
1. Ajouter chaînetapez=non spécifié à la chaîne de connexion, comme expliqué dans Les paramètres de la connexion JDBC.Cela vous permet de Postgres deviner le côté droit type et de convertir tout de manière adéquate, puisqu'il reçoit quelque chose comme 'enum = inconnu", qui est une expression qu'il sait déjà de quoi faire avec (nourrir ? la valeur de la main gauche type deserialiser). C'est l'option préférée, comme il devrait fonctionner pour tous les simples Udt tels que les enums en une seule fois.
```
jdbc:postgresql://localhost:5432/dbname?stringtype=unspecified
```
Ou:
1. Créer une conversion implicite de type varchar enum dans la base de données. Donc, dans ce second cas, la base de données reçoit une affectation ou de comparaison comme "enum = varchar" et il trouve une règle dans son catalogue interne en disant qu'il puisse passer à la droite de la valeur grâce à la fonction de sérialisation de type varchar, suivie par la désérialisation fonction de l'enum. C'est plus d'étapes que doit être nécessaire; et avoir trop de conversions implicites dans le catalogue peuvent causer des requêtes arbitraires d'avoir des interprétations ambiguës, afin de l'utiliser avec parcimonie. La fonte de la création est:
  
  CRÉER CAST (CHARACTER VARYING que l'humeur) AVEC INOUT IMPLICITE;
Devrait travailler avec cela.
- C'est de loin l'option la plus simple pour des applications récentes.
InformationsquelleAutor Arthur Nascimento
4

J'ai déposé un rapport de bug avec un patch inclus pour la mise en veille prolongée: HHH-5188

Le patch fonctionne pour moi de lire un PostgreSQL enum dans un enum de Java à l'aide de JPA.
- Correctif est en veille prolongée 4.1.7.
- Cela semble être brisé même de pire en 4.3.5. Maintenant je ne peux même pas persister enum pour Postgres parce que Hibernate semble insister sur l'écriture sous la forme de texte ou d'un entier.
InformationsquelleAutor Stefan L

J'ai trouvé la meilleure solution:

public class PostgreSQLEnumType extends org.hibernate.type.EnumType {

    public void nullSafeSet(
            PreparedStatement st,
            Object value,
            int index,
            SharedSessionContractImplementor session)
            throws HibernateException, SQLException {
        if(value == null) {
            st.setNull( index, Types.OTHER );
        }
        else {
            st.setObject(
                    index,
                    value.toString(),
                    Types.OTHER
            );
        }
    }
}

Maintenant, nous pouvons utiliser la PostgreSQLEnumType comme suit:

@Entity
@TypeDef(name = "mood", typeClass = PostgreSQLEnumType.class)
public class Person {

    @Enumerated(EnumType.STRING)
    @Type(type = "mood")
    Mood mood;
}

InformationsquelleAutor anton

Vous devez vous connecter pour publier un commentaire.