Cartographie enum à une table avec hibernate annotations

J'ai une table FACE et une table DEAL_TYPE. Je voudrais une carte de ce code:

public class Deal {
   DealType type;
}

public enum DealType {
   BASE("Base"), EXTRA("Extra");
}

Le problème est que les données existent déjà dans la base de données. Et je vais avoir un moment difficile de cartographie les classes de la base de données.

La base de données ressemble à quelque chose comme ça:

   TABLE DEAL {
      Long id;
      Long typeId;
   }

   TABLE DEAL_TYPE {
       Long id;
       String text;
   }

Je sais que je pourrais utiliser un simple @OneToMany relation de face à face, mais je préfère utiliser un enum. Est-ce possible?

J'ai presque eu de travail à l'aide d'un EnumType.ORDINAL type. Mais malheureusement, mon Id dans ma transaction de type tableau ne sont pas séquentiels, et ne pas commencer à 1.

Des suggestions?

InformationsquelleAutor Thierry-Dimitri Roy | 2009-04-09

17

Hibernate est une sorte de terrible à des Enums. C'est un étrange, à défaut, par ailleurs assez bon ORM. La "meilleure" façon de la contourner est de déclarer votre Enum personnalisé hibernate type. Heureusement, Hibernate a écrit un exemple de mise en œuvre de laquelle vous pouvez crèche textuellement dans votre application:

http://www.hibernate.org/265.html

Ils incluent même des instructions sur la façon de l'utiliser. C'est le modèle que j'utilise à chaque fois que je me retrouve avec la nécessité de persister enums.
- Oui, je n'ai jamais compris pourquoi ils n'ont pas une meilleure solution pour elle.
- Mais où avez-vous définir l'id de la colonne et la colonne de texte de l'enum?
- Je sais que c'est un vieux sujet, mais comment créer des getter et setter pour ce code ?
- Je ne suis pas sûr que je sais ce que tu veux dire. Normalement, j'imagine?
- oui, bien sûr. J'ai fait un peu de missread à partir d'un échantillon et j'ai eu des problème pour le voir 🙂 Nvm que. Votre réponse m'a beaucoup aidé
- Je ne comprends pas comment vous carte Enum pour une table séparée avec l'id et la description. Pourriez-vous nous donner un exemple de code comment dans Hibernate annotations? C'est ce que @Naor a demandé.
InformationsquelleAutor Brandon Yarbrough

J'ai créé une catégorie similaire comme celle proposée par hibernate seulement c'est configurable et il n'est pas nécessaire de créer un nouveau type uniquement pour cette persistance.

Peut être utilisé comme

@Type(type = "ro.raisercostin.hibernate.EnumUserType", parameters = @Parameter(name = "type", value = "DealType"))
DealType dealType;

J'ai ajouté une mise en œuvre de ParameterizedType à l'appui de l'passées en paramètre.

public class EnumUserType implements UserType, ParameterizedType {
private static final int[] SQL_TYPES = { Types.VARCHAR };
private Class clazz = null;
public EnumUserType() {
}
@Override
public void setParameterValues(Properties parameters) {
String className = (String) parameters.get("type");
try {
this.clazz = Class.forName(className);
} catch (ClassNotFoundException e) {
throw new RuntimeException("Couldn't get the class for name [" + className + "].", e);
}
}
public int[] sqlTypes() {
return SQL_TYPES;
}
public Class returnedClass() {
return clazz;
}
public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException,
SQLException {
String name = resultSet.getString(names[0]);
Object result = null;
if (!resultSet.wasNull()) {
result = Enum.valueOf(clazz, name);
}
return result;
}
public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index) throws HibernateException,
SQLException {
if (null == value) {
preparedStatement.setNull(index, Types.VARCHAR);
} else {
preparedStatement.setString(index, ((Enum) value).name());
}
}
public Object deepCopy(Object value) throws HibernateException {
return value;
}
public boolean isMutable() {
return false;
}
public Object assemble(Serializable cached, Object owner) throws HibernateException {
return cached;
}
public Serializable disassemble(Object value) throws HibernateException {
return (Serializable) value;
}
public Object replace(Object original, Object target, Object owner) throws HibernateException {
return original;
}
public int hashCode(Object x) throws HibernateException {
return x.hashCode();
}
public boolean equals(Object x, Object y) throws HibernateException {
if (x == y) {
return true;
}
if ((null == x) || (null == y)) {
return false;
}
return x.equals(y);
}
}

Il semble Hibernate élargi de la signature sur les deux méthodes, mais sinon cela fonctionne très bien pour moi. Jamais considéré comme contribuant à la Hibernate projet?
Je suis en train d'essayer ce que vous avez expliqué ci-dessus. Je ne suis pas sûr de ce que serait la valeur d'un paramètre dans l'annotation. Pouvez-vous donner des précisions sur ce point ou de la source où je peux obtenir plus d'informations sur elle.
Maintenant, je comprends. Les paramètres sont comme type: DealType où type est la clé utilisée EnumUserType de la valeur et de la classe (utiliser le nom complet de la classe, y compris l'emballage).

InformationsquelleAutor raisercostin

Vous pourrait annoter les enum avec @Entity et l'utilisation d'un custoumn tuplizer pour créer les instances de l'enum avec Enum.valueOf

La déclaration d'enum ressemble alors à:

@Entity
@Table(name = "node_interface_type")
@Tuplizer(impl = EnumTuplizer.class)
public enum Type {
WIRED, WIRELESS, WIRELESS_SENSOR_NODE;
@Id
public String name = toString();
}

Et la Tuplizer est:

public class EnumTuplizer extends PojoEntityTuplizer {
public EnumTuplizer(EntityMetamodel entityMetamodel, PersistentClass mappedEntity) {
super(entityMetamodel, mappedEntity);
}
@Override
protected Instantiator buildInstantiator(final PersistentClass persistentClass) {
return new Instantiator() {
@Override
public Object instantiate(Serializable id) {
try {
return Enum.valueOf(
(Class) persistentClass.getClass().getClassLoader().loadClass(persistentClass.getClassName()),
(String) id
);
} catch (ClassNotFoundException e) {
throw new AssertionError(e);
}
}
@Override
public Object instantiate() {
throw new UnsupportedOperationException();
}
@Override
public boolean isInstance(Object object) {
throw new UnsupportedOperationException();
}
};
}
}

Je pense que vous pouvez maintenant se débarrasser de la Tuplizer avec @Énumérés
vous êtes à la vie de veille. Avec ce que je peux démarrent des instances d'objets hibernate comme les énumérations avec des valeurs personnalisées et de les utiliser dans des référentiels
cette approche a fonctionné pour moi. Merci beaucoup.

InformationsquelleAutor don_jones

3

Si vous souhaitez utiliser l'entité juste en lecture seule, vous pouvez utiliser @Formula et @Enumerated. Essayez quelque chose comme:
```
@Entity
public class Deal {
@Formula("(select text from DEAL_TYPE dt where dt.id = typeId)")
@Enumerated(EnumType.STRING)
DealType type;
}
```
InformationsquelleAutor xmedeko
1

Bien que loin loin d'être idéale, ma solution à ce problème serait d'utiliser EnumStringType et un dénormalisée telle vue.
- Pas une mauvaise solution, car vous avez envisagé d'insérer et mettre à jour, aussi. D'autres solutions sont probablement juste pour la lecture. Bien qu'il soit possible que pour quelques DB, comme Oracle.
- Alors que j'ai mis en place ce sur MSSQL où pouvant être mis à jour points de vue sont extrêmement simples, il devrait être possible d'émuler sur la plupart des systèmes SGBDR en plaçant un "au lieu de" déclencheur sur le point de vue de modifier les tables sous-jacentes.
InformationsquelleAutor Jeff Mc

Vous devez vous connecter pour publier un commentaire.