FAQ HibernateConsultez toutes les FAQ

Nombre d'auteurs : 5, nombre de questions : 63, dernière mise à jour : 17 mars 2014  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireLes objets (5)
précédent sommaire suivant
 

Un objet détaché est un objet qui n'est plus lié à la session Hibernate. On ne peut donc plus effectuer de save ou d'update dessus. Cela arrive quand la session à laquelle il était lié a été fermée.

Mis à jour le 11 février 2008 Baptiste Wicht

Un objet persistant est un objet qui a une existence dans la base de données et qui est référencé par un id. Toutes les modifications effectuées sur cet objet seront synchronisées avec la base lors de la fin de la transaction. Vous pouvez aussi employer update() pour valider ces changements.

Mis à jour le 11 février 2008 Baptiste Wicht

Un objet transient est un objet qui n'existe pas en base et qui a été créé via l'opérateur new. Il n'existe donc nulle part d'autre que dans la JVM. Il n'a donc aucune référence dans la base de données et n'est référencé par aucun id. Il faut utiliser la méthode save() pour le faire passer à un état persistant.

Mis à jour le 28 octobre 2006 Baptiste Wicht

Vous pouvez soit employer update si vous êtes sûrs que cette session ne contient pas cet objet ou alors merge() pour mettre à jour l'objet déjà existant dans la session avec vos modifications. Vous pouvez aussi utiliser saveOrUpdate qui va directement effectuer ce qu'il faut en détectant l'état de l'objet que vous lui donnez. Ainsi plus besoin de faire attention à l'état de votre objet.

Mis à jour le 17 février 2014 Baptiste Wicht

Imaginons que vous voulez récupérer un objet mappé pour le sauvegarder dans un fichier XML ou le transmettre en sérialisation.

Si vous le faites, vous verrez bien vite que votre objet est "pollué" par des proxy Hibernate et que vos collections se sont changées en collections propriétaires d'Hibernate.

Voici une façon de récupérer votre objet "pur", avec XStream.

On va utiliser le concept de convertisseurs et d'alias XStream.
Les classes PersistentSet, PersistentBag, PersistentList et autres PersistentXXX sont les collection propriétaires qu'Hibernate utilise pour stocker les collections.

On va donc premièrement créer notre convertisseur :

Code java :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public static void registerHibernateConverter(XStream xstream) { 
    xstream.registerConverter(new CollectionConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentSet.class; 
        } 
    }); 
    xstream.aliasType("java.util.Set", PersistentSet.class); 
  
    xstream.registerConverter(new CollectionConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentBag.class; 
        } 
    }); 
    xstream.aliasType("java.util.ArrayList", PersistentBag.class); 
  
    xstream.registerConverter(new CollectionConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentList.class; 
        } 
    }); 
    xstream.aliasType("java.util.ArrayList", PersistentList.class); 
  
  
    xstream.registerConverter(new MapConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentMap.class; 
        } 
    }); 
    xstream.aliasType("java.util.HashMap", PersistentMap.class); 
  
    xstream.registerConverter(new MapConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentSortedMap.class; 
        } 
    }); 
    xstream.aliasType("java.util.SortedMap", PersistentSortedMap.class); 
  
    xstream.registerConverter(new CollectionConverter(xstream.getMapper()) { 
        public boolean canConvert(Class type) { 
            return type == PersistentSortedSet.class; 
        } 
    }); 
    xstream.aliasType("java.util.SortedSet", PersistentSortedSet.class); 
}

Et voici comment utiliser cette méthode pour récupérer un objet exempt de tout code Hibernate :
Code java :
1
2
3
4
5
6
7
8
9
public static<T> Object deepCopyObject(T o) { 
    XStream xstream = new XStream(); 
    xstream.autodetectAnnotations(true); 
    registerHibernateConverter(xstream); 
    String xml = xstream.toXML(o); 
    XStream xstreamOut = new XStream(); 
    T newObject = (T) xstreamOut.fromXML(xml); 
    return newObject; 
}

Vous avez maintenant une copie conforme de votre objet au format pur POJO.

Mis à jour le 5 juin 2009 Baptiste Wicht

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2014 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
 
 
 
Partenaires

PlanetHoster
Ikoula