1. Cartographie de la collection
1. Collection Introduction
La cartographie de collecte est également une cartographie de base, mais elle ne sera pas utilisée fréquemment pendant le processus de développement, il n'est donc pas nécessaire d'avoir une compréhension approfondie. Il vous suffit de comprendre les méthodes d'utilisation de base. Être simplement en mesure d'interroger la solution lorsque vous rencontrez un tel problème pendant le processus de développement. Mappage de l'ensemble correspondant En fait, il fait référence à la cartographie de l'ensemble en Java sur la table correspondante. Il s'agit d'une cartographie des objets de collecte. Il existe quatre types d'ensembles en Java, à savoir les ensembles, la carte, la liste et les tableaux ordinaires. Il existe de grandes différences entre eux:
(1) Définir, il ne devrait pas y avoir d'objets en double, les objets sont désordonnés;
(2) la liste peut être commandée avec des objets répétés;
(3) MAP, il apparaît par paires de valeurs clés;
(4) Les tableaux peuvent être répétés et il existe un ordre entre les objets.
La différence entre eux détermine quelle collection est utilisée pendant le développement. Habituellement, l'ensemble est utilisé pendant le développement. Les objets à l'intérieur ne sont pas nécessaires et les objets internes peuvent être obtenus à l'aide d'un itérateur. Si ces ensembles souhaitent mapper sur le modèle relationnel correspondant, vous devez utiliser les balises de mappage fournies par Hibernate, <Set>, <Sist>, <Map> et <Rarray>.
2. Cartographie Introduction
Continuez à discuter du modèle relationnel de la cartographie des ensembles. Le mappage de set fait référence à un objet correspondant à une autre collection d'objets. Lors de l'enregistrement, Hibernate enregistre l'ensemble de données dans la table correspondante et enregistrera les données dans la table de données en fonction de l'ID qu'il alloue. Si une nouvelle table est attribuée à l'ensemble séparément, l'ID sera affecté à l'ID de la table SET et la table de relation correspondante est la suivante:
3. Fichiers de classe
Comment le mappage défini est implémenté via le code, et nous l'analyserons en détail ensuite. Ici, nous scellons toutes les collections dans une classe. Nous appelons cette classe CollectionMapping.java, donc son code interne correspondant est le suivant:
package com.hibernate; Importer java.util.list; importation java.util.map; import java.util.set; @SuppressWarnings ("RawTypes") CLASSE PUBLIQUE COLLECTIONMAPPAGE {// ID Private int id; public int getID () {return id; } public void setid (int id) {this.id = id; } // Nom du nom de chaîne privée; public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } // set Collection private set setValues; public set getSetValues () {return setValues; } public void setSetValues (set setValues) {this.setValues = setValues; } // List Collection Private List ListValues; Liste publique getListValues () {return listValues; } public void setListValues (list listValues) {this.listValues = listValues; } // Collection Array String privé [] ArrayValues; String public [] getArrayValues () {return arrayValues; } public void setArrayValues (String [] arrayValues) {this.arrayvalues = arrayValues; } // Collection de cartes Map Private MapValues; Map public getMapValues () {return MapValues; } public void setMapValues (map mapValues) {this.mapValues = mapValues; }}Cette classe résume plusieurs ensembles couramment utilisés. Si vous souhaitez les convertir en un modèle relationnel, vous devez regarder le mappage ci-dessous.
4. Cartographie de la collection
La cartographie d'une collection est en fait assez simple. Il vous suffit d'ajouter les balises de collecte correspondantes. HiberNate fournit respectivement les balises de collection <Set>, <aphing>, <sist> et <array>. La collection est cartographiée dans la table relationnelle correspondante en utilisant la balise centralisée. De plus, l'association des clés étrangères est réalisée en ajoutant la balise <yey>, et d'autres attributs sont ajoutés à l'aide de <element>.
Collectionmapping.hbm.xml
<? xml version = "1.0"?> <! Doctype Hibernate-Mapping public "- // Hibernate / Hibernate Mapping Dtd 3.0 // en" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <Hibernate-Mapping> <Class Name = "Com.hibernate. table = "t_collection_mapping"> <id name = "id"> <générateur // id> <propriété name = "name" /> <set name = "setValues" table = "t_set_values"> <key column = "set_id"> </ key> <element type = "string" chronom = "set_value"> </ element> </ set> </ set> </ set> <listvalues "" table = "t_list_values"> <key column = "list_id" /> <list-index colonnen = "list_index" /> <élément type = "string" collumn = "list_value" /> </ list> <map name = "mapvalues" table = "t_map_values"> <key column = "map_id" /> <maphkey-key = "string =" collumn = "map_id" /> <map-key-key = "string =" collumn = "mapheke <élément type = "string" chronny = "map_value" /> </ map> <array name = "arrayValues" table = "t_array_value"> <key column = "array_id" /> <index column = "array_index" type = "Integer"> </ index> <élément type = "String" colonnes = "array_value" /> </ aray> </ class> </ Hibernate-Mapping>
Il convient de noter que la balise de liste et la balise de tableau. Les objets de ces deux ensembles sont en ordre. Par conséquent, lors de l'ajout de balises de mappage, vous devez utiliser des balises list-index ou index pour indiquer l'ordre des objets. De plus, lors de l'ajout de sous-étiquettes, vous devez les ajouter dans l'ordre. C'est-à-dire, ajoutez d'abord la balise <yey>, puis ajoutez la balise <swing-index>, et enfin ajoutez la balise <element>, sinon l'erreur suivante apparaîtra:
The content of element type "list" must match "(meta*,subselect?,cache?,synchronize*,comment?,key,(index|list-index),(element|one-to-many|many-to-many|composite-element|many-to-any),loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,filter*)".
5. Modèle relationnel
Le modèle d'objet configuré est converti en modèle relationnel correspondant, et l'instruction SQL générée est la suivante:
Alter Table T_Array_Value Drop Key Foreign Key FK2E0DD0C067676B68 ALTER TABLE T_LIST_VALUes Drop Key Fke01ec98BF4FCB03 Alter Table T_MAP_VALUES DROP FORTER KEY FKD169BA107402B585 Alter Table Table Si existe T_Array_Value Table Drop Table If existe T_Collection_Mapping Drop Table If existe T_List_Values Drop Table If existe T_MAP_VALUES TABLE DE DROY array_index)) Créer la table T_Collection_Mapping (ID INTEGER NON NULL AUTO_INCRAMENT, NAME VARCHAR (255), Clé primaire (ID)) Créer la table T_List_Value Varchar (255), List_index Integer Not Null, Clé primaire (List_ID, List_Index)) Créer Table varchar (255), map_key varchar (255) non null, clé primaire (map_id, map_key)) créer la table t_set_values (set_id entier non nul FK2E0DD0C067676B68 Clé étrangère (array_id) Références t_collection_mapping (id) alter table t_list_values add index fke01ec98bf4fcb03 (list_id) t_map_values Ajouter index fkd169ba107402b585 (map_id), ajouter la contrainte fkd169ba107402b585 Foreign Key (MAP_ID) références t_collection_mapping (id) alter table t_set_values FK7BB8D04A7E79F8BF Foreign Key (set_id) références t_collection_mapping (id)
La vue de base de données correspondante générée est la suivante:
2. Fonctionnement des données
1. Écriture de données
Lorsque vous rédigez des opérations de données, vous devez faire attention à la création d'objets de données lors de la rédaction de données. Liste, définissez et MAP doit créer des objets de données et écrire des objets de données dans la base de données. Parce que tous les trois sont des interfaces d'objet, vous devez créer un objet et écrire l'objet dans la base de données. Le code spécifique est le suivant:
@SuppressWarnings ({"Unchecked", "RawTypes"}) public void testSave () {session session = null; essayez {session = hibernateutils.getSession (); session.begintransaction (); CollectionMapping cm = new CollectionMapping (); cm.setName ("Zhangsan"); Set set = new HashSet (); set.add ("a"); set.add ("b"); cm.SetSetValues (set); List list = new ArrayList (); list.add ("list1"); list.add ("list2"); cm.SetListValues (liste); String [] str = new String [] {"array1", "array2"}; CM.SetArrayValues (STR); Map map = new HashMap (); map.put ("k1", "v1"); map.put ("k2", "v2"); cm.SetMapValues (carte); Session.Save (CM); session.getTransaction (). commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {hibernateUtils.closeSession (session); }}L'instruction SQL générée est la suivante:
Hibernate: insérer dans t_collection_mapping (nom) valeurs (?) Hibernate: insérer dans t_set_values (set_id, set_value) valeurs (?,?) Hibernate: insert dans t_set_values (set_id, set_value) valeurs (?,?) VALEURS (?,?,?) Hibernate: Insérez dans T_List_Values (List_ID, List_index, List_Value) VALEURS (? ,?) HiberNate: Insérez dans T_List_Values (list_id, list_index, list_value) VALEURS (?,?) (? ,?)?) Hibernate: insérer dans t_map_values (map_id, map_key, map_value) valeurs (?, array_value) valeurs (? ,?) hibernate: insérer dans t_array_value (array_id, array_index, array_value) valeurs (? ,?)
2. Chargement des données
La méthode de chargement des données est très simple. Il chargera les données du tableau dans l'objet en fonction de l'ensemble, puis vous n'avez qu'à obtenir la collecte d'objets correspondante.
public void testload () {session session = null; essayez {session = hibernateutils.getSession (); session.begintransaction (); CollectionMapping cm = (collectionmapping) session.load (collectionmapping.class, 1); System.out.println ("cm.name =" + cm.getName ()); System.out.println ("cm.List =" + cm.getListValues ()); System.out.println ("cm.map =" + cm.getMapValues ()); System.out.println ("cm.Array =" + cm.getArrayValues ()); System.out.println ("cm.set =" + cm.getSetValues ()); session.getTransaction (). commit (); } catch (exception e) {e.printStackTrace (); session.getTransaction (). Rollback (); } enfin {hibernateUtils.closeSession (session); }}Le résultat généré:
HiberNate: sélectionnez Collection0_.id en tant qu'ID0_0_, collection0_.name as name0_0_ from t_collection_mapping collection0_ où collection0_.id =? HiberNate: sélectionnez ArrayValue0_.Array_id comme Array1_0_, ArrayValue0_.Array_Value As Array2_0_, ArrayValue0_.array_index As Array3_0_ de T_Array_Value ArrayValue0_ WHERE ArrayValue0_.array_id =? cm.Name = zhangsan hibernate: sélectionnez Listvalues0_.list_id as list1_0_, listvalues0_.list_value as list2_0_, listvalues0_.list_index as list3_0_ from t_list_values listvalues0_ where listvalues0_.list_id =? cm.List = [list1, list2] hibernate: sélectionnez MapValues0_.map_id comme MAP1_0_, MapValues0_.map_value en tant que Map2_0_, MapValues0_.map_key as MAP3_0_ de T_MAP_VALUES MAPVALUES0_ WHERE MAPVALUES0_.MAP_ID =? cm.map = {k1 = v1, k2 = v2} cm.array = [ljava.lang.string; @ 758d8478 Hibernate: sélectionnez setvalues0_.set_id as set1_0_, setvalues0_.set_value comme set2_0_ à partir de t_set_values setValues0_ où setValues0_. cm.set = [b, a] 3. Résumé
Hibernate peut persister des instances des collections Java suivantes, y compris java.util.map, java.util.set, java.util.sortedmap, java.util.sortedset, java.util.list et des tableaux de toutes les entités ou valeurs persistantes (en utilisant les types de collecte de sets est le meilleur choix). Les propriétés de type java.util.collection ou java.util.list peuvent également être persistées à l'aide de la sémantique "sac". Les collections utilisées pour la persistance ne peuvent pas conserver la sémantique attachée à toutes les classes qui implémentent ces interfaces, à l'exception de l'interface de collecte (par exemple: ordre itératif apporté par LinkedHashSet). Toutes les collections persistantes fonctionnent réellement directement en fonction de la sémantique de Hashmap, Hashset, Treemap, Treeset et ArrayList. Pour le dire plus profondément, pour une propriété qui contient une collection, le type Java doit être défini comme une interface (c'est-à-dire la carte, le set ou la liste, etc.), et ne doit pas être Hashmap, Treeset ou ArrayList. La raison de cette limitation est que lorsque vous ne le savez pas, Hibernate remplace secrètement vos instances de carte, de définition et de liste par sa propre implémentation de la carte, de la définition ou de la liste. (Donc, dans votre programme, utilisez l'opérateur == avec prudence.) (Remarque: Pour les performances et d'autres raisons, presque toutes les interfaces de collecte Java sont implémentées dans Hibernate (pour implémenter certaines fonctionnalités du chargement paresseux).) Toutes les classes de collecte ordonnées (cartes, listes, tableaux) ont une clé principale composée de <Vey> et <index>. Dans ce cas, la mise à jour de la classe de collecte est très efficace - la clé principale a été indexée efficacement, donc lorsque Hibernate essaie de mettre à jour ou de supprimer une ligne, les données de cette ligne se trouvent rapidement. La clé principale d'un ensemble (ensembles) se compose de <key> et d'autres champs d'éléments. Ceci est inefficace pour certains types d'éléments, en particulier les éléments combinés ou le grand texte ou les grands champs binaires; La base de données peut ne pas être en mesure d'indexer efficacement les clés primaires complexes. D'un autre côté, pour les associations de plusieurs à plusieurs, en particulier les identifiants synthétiques, les ensembles peuvent atteindre les mêmes performances efficaces. (Partie 1: Si vous souhaitez que SchemaExport crée une clé principale pour votre <Set>, vous devez déclarer tous les champs comme non null = "true".) La carte <dbag> définit la clé proxy, donc elle peut toujours être mise à jour efficacement. En fait, <dbag> a les meilleures performances. Le sac est le pire. Étant donné que le sac permet des valeurs d'élément en double et n'a pas de champs d'index, il est impossible de définir les clés primaires. Hibernate ne peut pas déterminer les lignes en double. Lorsqu'une telle collection est modifiée, Hibernate supprimera d'abord complètement toute la collection (via une seule suppression), puis recréera toute la collection. Le sac est donc très inefficace.