1. Mapeo de colección
1. Introducción de colección
El mapeo de recolección también es un mapeo básico, pero no se usará con frecuencia durante el proceso de desarrollo, por lo que no es necesario tener un conocimiento profundo. Solo necesita comprender los métodos de uso básicos. Solo pueda consultar la solución cuando encuentre tal problema durante el proceso de desarrollo. De hecho, la asignación del conjunto correspondiente, se refiere a mapeo del conjunto en Java a la tabla correspondiente. Es un mapeo de objetos de recolección. Hay cuatro tipos de conjuntos en Java, a saber, establecido, mapa, lista y matrices ordinarias. Hay grandes diferencias entre ellos:
(1) Conjunto, no debe haber objetos duplicados, los objetos están desordenados;
(2) la lista se puede ordenar con objetos repetidos;
(3) Mapa, aparece en pares de valores clave;
(4) Las matrices se pueden repetir, y hay un orden entre los objetos.
La diferencia entre ellos determina qué colección se usa durante el desarrollo. Por lo general, el conjunto se usa durante el desarrollo. Los objetos dentro son innecesarios y los objetos internos se pueden obtener usando un iterador. Si estos conjuntos desean asignar al modelo relacional correspondiente, debe usar las etiquetas de mapeo proporcionadas por Hibernate, <Set>, <List>, <MAP> y <RARAY>.
2. Introducción de mapeo
Continúe discutiendo el modelo de relación de mapeo de conjuntos. El mapeo establecido se refiere a un objeto correspondiente a otra colección de objetos. Al guardar, Hibernate guardará el conjunto de datos en la tabla correspondiente y guardará los datos en la tabla de datos de acuerdo con la ID que asigna. Si se asigna una nueva tabla al conjunto por separado, la ID se asignará a la ID de la tabla establecida, y la tabla de relación correspondiente es la siguiente:
3. Archivos de clase
Cómo se implementa el mapeo establecido a través del código, y la analizaremos en detalle a continuación. Aquí sellamos todas las colecciones en una clase. Llamamos a esta clase CollectionMapping.java, por lo que su código interno correspondiente es el siguiente:
paquete com.Hibernate; import java.util.list; import java.util.map; import java.util.set; @SupplesSwarnings ("RawTypes") Public Class CollectionMapping {// id Private int id; public int getId () {return id; } public void setid (int id) {this.id = id; } // nombre Nombre de cadena privada; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } // set Collection private set setValues; Public set getSetValues () {return setValues; } public void setSetValues (set setValues) {this.setValues = setValues; } // colección de la lista de listas privadas listValues; Lista pública getListValues () {return listValues; } public void setListValues (list listValues) {this.listValues = listValues; } // colección de matriz cadena privada [] ArrayValues; cadena pública [] getArrayValues () {return arrayValues; } public void setArrayValues (String [] ArrayValues) {this.ArrayValues = ArrayValues; } // colección de mapas de mapa privado mapValues; mapa público getMapValues () {return mapValues; } public void setMapValues (map mapValues) {this.mapValues = mapValues; }}Esta clase encapsula varios conjuntos de uso común. Si desea convertirlos en un modelo relacional, debe mirar el mapeo a continuación.
4. Mapeo de colección
El mapeo de una colección es en realidad bastante simple. Solo necesita agregar las etiquetas de colección correspondientes. Hibernate proporciona las etiquetas de colección <Set>, <MAP>, <LId> y <Array> respectivamente. La colección se asigna a la tabla de relaciones correspondiente utilizando la etiqueta centralizada. Además, la asociación de claves extranjeras se logra agregando la etiqueta <Key>, y otros atributos se agregan utilizando <emente>.
CollectionMapping.hbm.xml
<? xml versión = "1.0"?> < table = "t_collection_mapping"> <id name = "id"> <generador // id> <propiedad name = "name"/> <set name = "setValues" table = "t_set_values"> <key columna = "set_id"> </ key> <element type = "string" column = "set_value"> </ememement> </set> <sist name = "listvalues" table = "t_list_values"> <key columny = "list_id"/> <list-index column = "list_index"/> <element type = "string" column = "list_value"/> </list> <map name = "mapValues" table = "t_map_values"> <key column = "map_id"/> <map-key type = "string" columna "columna" columna "columna" type = "String" column = "map_value"/> </map> <array name = "arrayValues" table = "t_array_value"> <key column = "array_id"/> <index column = "array_index" type = "entero"> </index> <element type = "string" column = "array_value"/> </array> </array </shuse
Cabe señalar que la etiqueta de lista y la etiqueta de matriz. Los objetos en estos dos conjuntos están en orden. Por lo tanto, al agregar etiquetas de mapeo, debe usar etiquetas de índice o índice de lista para indicar el orden de los objetos. Además, al agregar sub-etiquetas, debe agregarlas en orden. Es decir, primero agregue la etiqueta <Key>, luego agregue la etiqueta <Dindex> y finalmente agregue la etiqueta <emente>, de lo contrario aparecerá el siguiente error:
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. Modelo relacional
El modelo de objeto configurado se convierte en el modelo relacional correspondiente, y la instrucción SQL generada es la siguiente:
Tabla de alter T_array_Value Drop for Exfore Key FK2E0DD0C067676B68 ALTER TABLA T_LIST_VALUS DRANSE CLAVE FKE01EC98BF4FCB03 TABLA DEL ALTER TABLA T_MAP_VALUS DOW CLEEZ FORRAN Tabla de caída si existe t_array_value tabla de caída si existe t_collection_mapping tabla de caída si existe t_list_values tabla de caída si existe (array_id, array_index)) create table t_collection_mapping (id integer not null auto_increment, name varchar(255), primary key (id)) create table t_list_value varchar(255), list_index integer not null, primary key (list_id, list_index)) create table t_map_values (map_id integer not null, map_value varchar (255), map_key varchar (255) no nulo, tecla primaria (map_id, map_key)) Crear tabla t_set_values (set_id integer no null, set_value varchar (255)) Tabla T_array_value Agregar índice fk2e0dd0c067676b68 (array_id), agrega restriction Fk2e0dd0c06767676b68 clave extranjera (array_id) Referencias t_collection_mapping (id) alter table t_list_values agregue índice fke01ec98bf4fcb03 (list_id), agregue restricción FKE01EC98BF4FCB03 Clave extranjera (list_id) referencias t_collection_mapping (ID) t_map_values add index FKD169BA107402B585 (map_id), add constraint FKD169BA107402B585 foreign key (map_id) references t_collection_mapping (id) alter table t_set_values add index FK7BB8D04A7E79F8BF (set_id), add constraint FK7BB8D04A7E79F8BF Clave exterior (SET_ID) Referencias T_Collection_Mapping (ID)
La vista de base de datos correspondiente generada es la siguiente:
2. Operación de datos
1. redacción de datos
Al escribir operaciones de datos, debe prestar atención a la creación de objetos de datos al escribir datos. Lista, configuración y mapa necesitan crear objetos de datos y escribir objetos de datos en la base de datos. Debido a que las tres son interfaces de objetos, debe crear un objeto y escribir el objeto a la base de datos. El código específico es el siguiente:
@SupessWarnings ({"sin verificar", "RawTypes"}) public void testSave () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); CollectionMapping CM = New CollectionMapping (); cM.SetName ("Zhangsan"); Set set = new Hashset (); set.add ("a"); set.add ("b"); cM.SetSetValues (conjunto); List List = new ArrayList (); list.add ("list1"); list.add ("list2"); cM.SetListValues (lista); String [] str = new String [] {"Array1", "Array2"}; cM.SetArrayValues (STR); Mapa map = nuevo hashmap (); map.put ("k1", "v1"); map.put ("k2", "v2"); cM.SetMapValues (mapa); Session.save (CM); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }}La declaración SQL generada es la siguiente:
Hibernate: inserte en t_collection_mapping (nombre) valores (?) Hibernate: insertar en t_set_values (set_id, set_value) valores (?,?) Hibernate: insertar en t_set_values (set_id, set_value) valores (?,?) Hibernate: insertar en t_list_values (list_id, list, list, listex, listex, listex (?, ?, ?) Hibernate: insert into t_list_values (list_id, list_index, list_value) values (?, ?, ?) Hibernate: insert into t_list_values (list_id, list_index, list_value) values (?, ?, ?) Hibernate: insert into t_list_values (list_id, list_index, list_value) values (?,?,?) Hibernate: Insertar en t_map_values (map_id, map_key, map_value) valores (?,?) Hibernate: insertar en t_map_values (map_id, map_key, map_value) valores (?,?,?) Hibernate: en t_array_value (array_id, arraye, arrayue, arrayue, arrayue) (?,?,?) Hibernate: Inserte en t_array_value (array_id, array_index, array_value) valores (?,?,?)
2. Carga de datos
El método de carga de datos es muy simple. Cargará los datos en la tabla en el objeto de acuerdo con el conjunto, y luego solo necesita obtener la recopilación de objetos correspondiente.
public void testLoad () {session session = null; intente {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 (); } finalmente {hibernateUtils.clossessession (sesión); }}El resultado generado:
Hibernate: Seleccione Collection0_.id como ID0_0_, Collection0_.name as name0_0_ desde t_collection_mapping Collection0_ donde Collection0_.id =? Hibernate: seleccione ArrayValue0_.array_id como Array1_0_, ArrayValue0_.array_value como Array2_0_, Arrayvalue0_.array_index as array3_0_ desde t_array_value arrayvalue0_ donde arrayvalue0_.array_id =? cm.name = zhangsan hibernate: seleccione listValues0_.list_id como list1_0_, listValues0_.list_value como list2_0_, listValues0_.list_index as list3_0_ de t_list_values listValues0_ donde listValues0_..list =? cm.list = [list1, list2] hibernate: seleccione MapValues0_.map_id como map1_0_, mapValues0_.map_value como map2_0_, mapvalues0_.map_key como map3_0_ de t_map_values mapValues0_ donde values0_.map_id =? cm.map= {k1=v1, k2=v2} cm.array= [Ljava.lang.String;@758d8478 Hibernate: select setvalues0_.set_id as set1_0_, setvalues0_.set_value as set2_0_ from t_set_values setvalues0_ where setvalues0_.set_id=? cm.set = [b, a] 3. Resumen
Hibernate puede persistir en instancias de las siguientes colecciones de Java, incluidas java.util.map, java.util.set, java.util.sortedmap, java.util.sortedset, java.util.list, y matrices de cualquier entidad o valores persistentes (el uso de tipos de colección de conjuntos es la mejor opción). Las propiedades del tipo java.util.collection o java.util.list también se pueden persistir utilizando la semántica de "bolsa". Las colecciones utilizadas para la persistencia no pueden retener la semántica adjunta a las clases que implementen estas interfaces, excepto la interfaz de recolección (por ejemplo: orden iterativo traído por LinkedHashset). Todas las colecciones persistentes en realidad funcionan directamente de acuerdo con la semántica de Hashmap, Hashset, Treemap, TreeSet y ArrayList. Para decirlo más profundamente, para una propiedad que contiene una colección, el tipo de Java debe definirse como una interfaz (es decir, mapa, configuración o lista, etc.), y no debe ser hashmap, árbol de árboles o arraysist. La razón de esta limitación es que cuando no lo sabe, Hibernate reemplaza en secreto su mapa, configuración y lista de instancias con su propia implementación de mapa, conjunto o lista. (Entonces, en su programa, use el operador == con precaución.) (Nota: por el rendimiento y otras razones, casi todas las interfaces de colección Java se implementan en Hibernate (para implementar algunas características de la carga perezosa).) Todas las clases de recolección ordenadas (mapas, listas, matrices) tienen una clave principal compuesta de <ke clave> y <dex>. En este caso, la actualización de la clase de recopilación es muy eficiente: la clave principal se ha indexada de manera efectiva, por lo que cuando Hibernate intenta actualizar o eliminar una fila, los datos de esa fila se pueden encontrar rápidamente. La clave principal de un conjunto (conjuntos) consiste en <Key> y otros campos de elementos. Esto es ineficiente para algunos tipos de elementos, especialmente elementos combinados o texto grande o campos binarios grandes; Es posible que la base de datos no pueda indexar efectivamente las claves primarias complejas. Por otro lado, para las asociaciones de uno a muchos, de muchas a muchos, especialmente los identificadores sintéticos, los conjuntos pueden lograr el mismo rendimiento eficiente. (Parte 1: si desea que SchemaExport cree una clave principal para su <set>, debe declarar todos los campos como no-null = "true".) El mapa <DiGbag> define la clave proxy, por lo que siempre se puede actualizar de manera eficiente. De hecho, <idbag> tiene el mejor rendimiento. La bolsa es la peor. Debido a que la bolsa permite valores de elementos duplicados y no tiene campos de índice, es imposible definir claves primarias. Hibernate no puede determinar las líneas duplicadas. Cuando se cambia dicha colección, Hibernate primero eliminará por completo la colección completa (a través de una sola eliminación) y luego recreará toda la colección. Por lo tanto, la bolsa es muy ineficiente.