1. Mapeo de la asociación de uno a muchos unidireccionales
El modelo de objetos de una relación de uno a muchos a menudo se ve en la vida diaria. Tome a los estudiantes y clases como ejemplo. Hay varios estudiantes en una clase, por lo que la relación entre la clase y los estudiantes es una relación de uno a muchos, asignada en el modelo de objetos, como se muestra en la figura a continuación:
El modelo de objeto muestra que esta relación de uno a muchos se mantiene en un extremo, por lo que el mapeo en un modelo de relación significa que habrá varios estudiantes en un campo de clase, lo que forma una relación de uno a muchos. La información del estudiante se puede obtener a través de la clase. El modelo de relación correspondiente es el siguiente:
1. Configuración básica
Con el modelo de objeto, luego málelos en el código de relación correspondiente. Al realizar el mapeo de relaciones, debe agregar la etiqueta <One to-Many> en un extremo. Además, debe agregar el atributo establecido en un extremo. Admite la carga perezosa, y luego agregue la etiqueta establecida en el archivo de mapeo y especifique una relación de uno a muchos, para que pueda consultar y obtener el extremo múltiple en un extremo.
Clases y archivos de mapeo:
Es el final más importante del modelo. En este extremo, debe agregar el atributo de conjunto correspondiente y agregar la etiqueta de establecimiento en el archivo de configuración. Puede configurar el objeto <One-Many> correspondiente en la etiqueta establecida. El código de objeto Java de clases específico es el siguiente:
paquete com.src.Hibernate; import java.util.set; clases de clase pública {private int id; public int getId () {return id; } public void setid (int id) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } nombre de cadena privada; // set admite la carga perezosa de estudiantes privados; Public set getStudents () {return Students; } public void setStudents (set estudiantes) {this.students = students; }}El atributo establecido se usa en el objeto Classes, pero solo explica los atributos de carga retrasados y no configura el objeto correspondiente para el atributo. El objeto del atributo debe configurarse en el archivo de asignación. Debe agregar una etiqueta establecida y agregar la etiqueta <One to-Many> a la etiqueta establecida. El código específico es el siguiente:
<? xml versión = "1.0"?> < table = "t_classes"> <id name = "id"> <generador // id> <propiedad name = "name"/> <set name = "standers"> <key column = "classesid"> </ key> <ONE-Many> </ One-to-Many> </set> </class> </ HiBernate-Mapping>
El código y los archivos de mapeo en el objeto de estudiante correspondiente no requieren ninguna configuración especial, solo deben escribirse de acuerdo con el método de escritura habitual. El método de configuración específico no se describirá en detalle, es muy simple. Después de la configuración, debe generar la instrucción SQL correspondiente. Al convertir el modelo de objeto en un modelo relacional, Hibernate genera la declaración correspondiente de la siguiente manera:
Tabla de alter T_Student Drop Foree Key FK4B9075705E0Affe Tabla de caída Si existe T_Classes Tabla Drop Si existe T_STUDEN Integer, clave primaria (id)) Tabla alter T_Student Agregar índice FK4B9075705E0AFEFE (Classesid), Agregar restricción FK4B9075705E0AFEFE EXTRANJE CLAVE (Classesid) Referencias T_Classes (ID)
El modelo de relación correspondiente generado se muestra a continuación:
Al comparar las declaraciones SQL y los modelos de relación, la asociación entre las tablas correspondientes se mantiene a través de claves extranjeras. Primero, cree dos tablas, especifique la clave principal de la tabla y finalmente agregue una relación de asociación de clave extranjera de uno a muchos.
2. Operaciones básicas
Las operaciones en la base de datos no son más que leer y escribir, y la modificación también es un tipo de escritura. A continuación, veamos cómo escribir y leer operaciones en la base de datos.
(1) Escribir datos:
Al escribir datos, debe prestar atención a la relación de uno a muchos, por lo que debe agregar múltiples clases de estudiantes al agregarlos. Además, dado que el atributo establecido correspondiente se agrega a las clases, debe usar Hashset para agregar al agregar objetos de los estudiantes, para que pueda realizar una relación de uno a muchos. El código específico es el siguiente:
public void testSave2 () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); Estudiante estudiante1 = nuevo estudiante (); Student1.setName ("Zhangsan"); Session.save (Student1); Estudiante estudiante2 = nuevo estudiante (); student2.setName ("lisi"); Session.save (Student2); Clases classes = new classes (); classes.setName ("classone"); Establecer estudiantes = new Hashset (); Estudiantes. Add (Student1); Estudiantes. Add (Student2); classes.setstudents (estudiantes); // Los datos se pueden guardar con éxito //, pero se emitirá una declaración de actualización adicional para mantener la relación porque es una razón de uno a muchos session.save (clases); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }} Luego, después de que los datos correspondientes generados ejecutando el caso de prueba anterior se escriben en la base de datos, la siguiente figura es la siguiente:
(2) Leer datos:
La operación de escritura es relativamente simple. Solo necesita agregar todos los objetos cargados al estado transitorio y ejecutar el método correspondiente para insertar el contenido. Sin embargo, la operación de lectura correspondiente será un poco más complicada. Debido a que es necesario iterar para obtener todos los objetos de los estudiantes, esta relación de uno a muchos no es muy eficiente. El código específico es el siguiente:
paquete com.test.Hibernate; import java.util.iterator; import java.util.set; import com.src.Hibernate.*; import junit.framework.testcase; importar org.hibernate.session; public class One2ManyTest extiende TestCase {public void testLoad1 () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); // Obtener información de clase con clases de la clave primaria 5 clases = (clases) session.load (classes.class, 5); // Imprimir información de clase System.out.println ("classes.name ="+classes.getName ()); // Establecer el conjunto de estudiantes y cargar el Estudiante establecido a través del conjunto de clases Estudiantes = classes.getStudents (); // iterar el conjunto e imprimir la información del estudiante en el conjunto para (iterator iterator = students.iterator (); iter.hasNext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println ("student.name ="+student.getName ()); } session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }}}Las declaraciones y la información correspondientes generadas son las siguientes:
Hibernate: seleccione Classes0_.id como ID1_0_, classes0_.name as name1_0_ de t_classes classes0_ donde classes0_.id =? classes.name = classone hibernate: seleccione Students0_.classesid como classid1_, students0_.id como id1_, students0_.id como id0_0_, students0_.name as name0_0_ de t_student students0_ donde students0_.classesid =? student.name = lisi student.name = zhangsan
2. Mapeo de la Asociación Bidireccional de uno a muchos
Aquí seguimos usando estudiantes y clases como ejemplos. Hay una relación de uno a muchos entre la clase y los estudiantes. Hay varios estudiantes en una clase. A diferencia del artículo anterior, la relación aquí es bidireccional, es decir, un extremo y un extremo mantienen la relación al mismo tiempo, por lo que su diagrama de objetos es el siguiente:
El diagrama del modelo de relación correspondiente no cambia mucho, porque la relación entre ellos es bidireccional, por lo que ambos extremos del modelo de relación mantienen la relación de relación al mismo tiempo y la asignan al modelo de relación como se muestra en la figura a continuación:
En una asociación unidireccional de uno a muchos, el archivo de mapeo solo debe configurarse especialmente en un extremo. Use la configuración <One to-Many> y use el iterador SET en el modelo de objeto para establecer el modelo de objeto retirado. Sin embargo, la diferencia es que en una asociación bidireccional, la asociación de clave externa correspondiente en el otro extremo debe agregarse en el extremo múltiple. En este momento, la relación de <ingle-to-uno> debe usarse en el extremo múltiple para indicar esta bidireccionalidad.
1. Mapeo
Las clases y el estudiante también se utilizan como ejemplos aquí. El contenido en el final de las clases es el mismo que el anterior y no cambiará, pero la configuración de los estudiantes en los extremos múltiples cambiará, es decir, la etiqueta <Many-to-One> debe agregarse al archivo de asignación.
La configuración del archivo de mapeo Student.HBM.XML requiere agregar una etiqueta de columna de clave extranjera <Bleing-o-One>, y el nombre de la columna debe ser consistente con el nombre de la columna de clases de clave extranjera.hbm.xml. El código específico es el siguiente:
<? xml versión = "1.0"?> < table = "t_student"> <id name = "id"> <generador/generador/> </id> <propiedad name = "name"/> <!-Agregue una nueva columna de clases en el estudiante en un lado, y el nombre de la columna debe ser la misma que la lista de classes.hbm.xml-> <muchos to-to-name = "classes" columna = "classesid"> </Many-to-one
La configuración del archivo de mapeo classes.hbm.xml es la misma que en el artículo anterior. Cabe señalar que la asignación de atributos SET se agrega al archivo classes.java y corresponde al objeto del estudiante. Por lo tanto, la etiqueta establecida debe agregarse al archivo de mapeo para indicar que el iterador establecido se usa en el modelo de objeto. La configuración específica es la siguiente:
<? xml versión = "1.0"?> < table = "t_classes"> <id name = "id"> <generador // id> <propiedad name = "name"/> <set name = "students" inverse = "true"> <key column = "classesid"> </ey> <ONE-O-Many> </One to-Many> </set> </class> </bernate-mapping>
2. Clase
La configuración del archivo de asignación corresponde directamente a la clase, por lo que con el archivo de asignación, puede escribir la clase correspondiente. Con la misma clase, puede saber cómo escribir el archivo de asignación correspondiente. Echemos un vistazo a cómo escribir el código de clase correspondiente.
La clase Student.Java requiere agregar atributos de objetos de clase asociados a la clase, y puede obtener información relacionada con clases al cargar al estudiante.
paquete com.src.Hibernate; Estudiante de clase pública {// clases de clase de clase asociada clases de clases privadas; clases públicas getClasses () {clases de retorno; } public void setClasses (classes classes) {this.classes = classes; } // ID de estudiante ID privado int id; public int getId () {return id; } public void setid (int id) {this.id = id; } // Nombre del estudiante Nombre de cadena privada; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; }} El contenido de código específico de clases.java archivo se muestra en el artículo anterior, y no se describirá en detalle aquí.
Con el modelo de objeto, se genera el modelo de relación. La declaración SQL generada es la siguiente:
Tabla de alter T_Student Drop Foreign Key FK4B907570FC588BF4 Tabla de caída Si existe T_Classes Tabla de caída Si existe T_STUDENT CREATE TABLA T_CLASSES (ID Integer NULL NULL Auto_Increment, nombre Varchar (255), Key primaria (ID) CREATE TABLE T_STUDENT (ID ID INTER INTER NULL AUTO_INCRENT entero, clave primaria (id)) Tabla alter t_student Agregar índice FK4B907570FC588BF4 (Classesid), Agregar restricción FK4B907570FC588BF4 Clave exterior (Classesid) Referencias T_Classes (ID)
3. Operación de datos
Después de establecer una estructura de tabla, escribí un método de prueba para verificar el funcionamiento de los datos. Primero, echemos un vistazo a la inserción de datos e insertemos datos en la estructura de la tabla. Hay dos situaciones al escribir datos. Una es primero crear un objeto de clases, escribir el objeto a la base de datos, luego crear un objeto de estudiante y agregar el objeto de estudiante al objeto Classes; El otro es crear primero un objeto de estudiante, escribir el objeto de estudiante a la base de datos y luego crear un objeto de clases para agregar el objeto de estudiante al objeto Classes. Estos dos tipos de operaciones son diferentes al final, así que comparemos.
3.1 Escribe la clase primero y luego escribe a los estudiantes
Después de escribir la clase en la base de datos primero, el objeto Classes ingresa al estado transitorio y tiene una fila en la base de datos. Luego escriba el objeto del estudiante. El objeto del alumno buscará la clave primaria de las clases correspondientes y la escribirá en la tabla. Por lo tanto, los datos en el modelo de relación no son vacíos, y el código guardado es el siguiente:
public void testSave () {session session = null; Pruebe {// cree session object session = hibernateUtils.getSession (); // Abrir transacción session.BeginTransaction (); // Crear objeto de clase y escribir objeto de clase a las clases de clases de base de datos = new Classes (); classes.setName ("clase"); session.save (clases); // Crear objeto de estudiante 1 y escribir objeto de estudiante a la base de datos Student Student1 = new Student (); Student1.setName ("Zhangsan"); Student1.setClasses (clases); Session.save (Student1); // Crear objeto Student 2 y escribir el objeto de estudiante a la base de datos Student Student2 = new Student (); student2.setName ("lisi"); estudiante2.setClasses (clases); Session.save (Student2); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }} La lista de información correspondiente en la base de datos de escritura es la siguiente:
3.2 Escribe los estudiantes primero y luego la clase
Primero escriba los estudiantes en la base de datos. En este momento, debido a que la tabla de estudiantes necesita obtener la información clave principal de la columna de clase correspondiente, pero debido a que la información de la clase se convierte en el estado transitorio, habrá un valor nulo al escribir la información del estudiante. El código es el siguiente:
La vista de base de datos correspondiente después de escribir es la siguiente:
Comparando las dos operaciones de escritura, aparecen resultados diferentes porque el orden de las dos escrituras es diferente, pero debido a que es una asociación bidireccional, no se produce una excepción durante la escritura.
4. Leer operación
En comparación con la escritura de datos, la lectura de datos se vuelve muy simple. Debido a que es una asociación bidireccional, la lectura de datos también es bidireccional. La información del otro extremo se puede leer desde cualquier extremo, como se muestra en el siguiente código:
public void testLoad1 () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); // Lea la información del estudiante a través de clases de clases Classes = (Classes) Session.Load (classes.class, 1); System.out.println ("classes.name ="+classes.getName ()); Establecer estudiantes = classes.getStudents (); para (iterator iter = students.iterator (); iter.hasnext ();) {estudiante estudiante = (estudiante) iter.next (); System.out.println ("student.name ="+student.getName ()); } // leer información de clase a través de la información del estudiante Student stu = new Student (); stu = (estudiante) session.load (student.class, 1); System.out.println ("Cargar información de clase a través de clases de estudiante.id ="+stu.getClasses (). GetId ()); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }}Ejecute la instrucción de prueba anterior y la información de la declaración correspondiente generada es la siguiente:
Hibernate: seleccione Classes0_.id como ID1_0_, classes0_.name as name1_0_ de t_classes classes0_ donde classes0_.id =? classes.name = class hibernate: seleccione Estudiantes0_.classesid como classid1_, students0_.id como id1_, students0_.id como id0_0_, students0_.name as name0_0_, students0_.classesid as classid0_0_ de t_student students0_ donde students0_.classesid =? student.name = lisi student.name = zhangsan
Carga de información de clase por clases de estudiantes.id = 1