1. Asociación de clave primaria bidireccional
La asociación clave primaria bidireccional es en realidad un caso especial de asociación clave primaria uno a uno. Sin embargo, la configuración <One to-One> debe realizarse en los archivos de mapeo en ambos extremos del objeto asociado, y además, el atributo de asociación de clave extranjera extranjera debe usarse en un extremo de la clave principal del mapa principal.
Aquí también usamos persona e idcard para discutir. Una persona corresponde a una tarjeta de identificación única, y una tarjeta de identificación también mapea de manera única a una persona, por lo que esto crea una relación de asociación bidireccional. La clave principal de la persona también es la clave principal de Idcard, que son las claves principales y las claves extranjeras. Esta relación de asociación se convierte en un mapeo uno a uno bidireccional, que se puede expresar en el modelo de relación como se muestra a continuación:
Las dos tablas en la figura usan la asociación de clave primaria. La clave principal de la persona es la clave principal de Idcard, por lo que forman una relación de restricción entre las claves extranjeras de Zhu, y garantizan la singularidad, la asigna al modelo de objeto y la transforman en una relación individual entre la clase de persona y la clase IDCARD, como se muestra en la figura a continuación:
Esta relación individual también mencionó en el artículo anterior que se usa la etiqueta <One to-One>, y esta mapeo uno a uno es bidireccional, por lo que necesitamos configurar <One to-One> entre dos objetos al mismo tiempo. Primero, veamos el código de clase y el código de archivo de mapeo correspondiente a IDCARD.
1. Información correspondiente a Idcard
Hay una relación uno a uno entre la clase Idcard.java, la clase Idcard y la clase persona. Por lo tanto, el atributo de persona correspondiente debe agregarse a la clase IDCARD. Esto es para agregar los atributos correspondientes a las claves extranjeras en el archivo de mapeo y establecer la clase de asociación de clave extranjera correspondiente.
paquete com.src.Hibernate; public class idcard {// id atributo private int id; public int getId () {return id; } public void setid (int id) {this.id = id; } // Atributo de número de tarjeta Cadena privada Cardno; public String getCardno () {return Cardno; } public void setcardno (string cardno) {this.cardno = cardno; } // personas correspondientes al número de tarjeta persona privada persona; Persona pública getPerson () {Return Person; } public void setperson (persona persona) {this.person = persona; }}El archivo de asignación idcard.hbm.xml agrega una persona de atributo de clave extranjera al archivo de asignación y agrega la etiqueta <One to-One> correspondiente. El propósito es forzar la clase de persona de restricción a lograr una relación de mapeo uno a uno. Finalmente, establezca el atributo restringido en verdadero en el mapeo para garantizar la relación de restricción forzada.
<? Xml versión = "1.0"?> <! DocType Hibernate-Mapping público "-// hibernate/hibernate mapping dtd 3.0 // en" "http://hibernate.sourceForge.net/Hibernate-Mapping-3.0.0.dtd"> <!-Generado 2014-5-15 23:47:00 por hibernate <hibernate-mapping> <class name = "com.src.Hibernate.idCard" table = "idcard"> <id name = "id" type = "int" columna = "personido"> <generador> <param name = "propiedad"> persona </param> </generador> </id> <propiedad name = "cardno" type = "string" columna = "cardno"> <<<propiedad> <sowon name-nombre " restringido = "true"> </ ONE-ONE> </class> </hibernate-mapping>
2. Información correspondiente de la persona
En la clase Person.java, además de agregar atributos básicos, la clase Idcard correspondiente debe agregarse como atributos, porque son una relación de asociación bidireccional individual, por lo que la clase Idcard también debe agregarse a la clase de persona. La misma razón es que los atributos de la clase de persona también se agregan a la clase Idcard.
paquete com.src.Hibernate; Persona de clase pública {// Número de identificación INT 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; } // idcard private idcard idcard; public Idcard getIdCard () {return idcard; } public void setidCard (idcard idcard) {this.idcard = idcard; }}Person.hbm.xml Mapeo de mapeo, la estrategia de generación de clave principal en este archivo no tiene requisitos especiales porque está restringido mutuamente por la clase Idcard. Su clave principal y la clave extranjera son la clave principal de Idcard. Además, debido a que es una relación uno a uno, la etiqueta <One to-One> debe agregarse al archivo de asignación para indicarlo.
<? Xml versión = "1.0"?> <! DocType Hibernate-Mapping público "-// hibernate/hibernate mapping dtd 3.0 // en" "http://hibernate.sourceForge.net/Hibernate-Mapping-3.0.0.dtd"> <!-Generado 2014-5-15 23:47:00 por hibernate <hibernate-mapping> <class name = "com.src.Hibernate.person" table = "persona"> <id name = "id" type = "int" column = "personid"> <nenerator> </generator> </id> <Property name = "name" type = "string" column = "personsname"> </propiedad> <!-one to-one etiqueta indica cómo hibrete hibrete de hibrete de su hibernidad. Por defecto, se carga de acuerdo con la clave principal, es decir, obtiene el valor del campo de relación y carga el objeto asociado de acuerdo con la clave principal del oponente-> <One-One Name = "Idcard"> </ One-One> </class> </hibernate-Mapping>
3. Archivo de mapeo de hibernado
Después de configurar la clase y el archivo de asignación anterior, se requiere la información sobre la asignación de la base de datos en Hibernate.cfg.xml para agregar dos archivos de configuración al archivo de configuración de Hibernate, de modo que los elementos de generación correspondientes se puedan encontrar al generar la base de datos correspondiente.
<? xml versión = "1.0" encoding = "utf-8"?> < <SessionFactory> <Property name = "Hibernate.Connection.Driver_Class"> com.mysql.jdbc.driver </Property> <Property Name = "Hibernate.Connection.Url"> jdbc: mysql: // localhost: 3306/HiBernate_One2One_pk1 </Property> <Property> name = "Hibernate.Connection.Username"> root </Property> <Property Name = "Hibernate.Connection.Password"> 1234 </property> <Property name = "Hibernate.dialect"> Org.Hibernate.Dialect.MysqlDialect </property> <Mapping Resource = "Com/Src/Hibernate/Person.hbM. Resource = "com/src/hibernate/idcard.hbm.xml"> </mapping> </session-factory> </hibernate-configuration>
4. Generar resultados
Después de completar la configuración, puede generar la base de datos correspondiente a partir del contenido anterior. En la base de datos, generará la estructura de la tabla correspondiente de acuerdo con el contenido configurado, y hay claves extrañas y campos de claves principales correspondientes en la tabla. Al generar la estructura de la tabla, Hibernate emitirá la instrucción SQL correspondiente en la consola, de la siguiente manera:
alter tabla IDCard Drop Foreign Key FK806F76ABAC038CD8 Tabla de caída Si existe Tabla de caída IDCARD Si existe persona crea Tabla Idcard (PersonId Integer no NULL, Cardno Varchar (255), Key primario (Personid)) Crear tabla Persona (Personid Integer no Null Auto_Increment, Personname VarCh FK806F76ABAC038CD8 (Personid), agregue restricción FK806F76ABAC038CD8 Clave externa (Personid) Referencias Persona (Personid)
La estructura de la tabla generada es la que se muestra en la figura:
La clave primaria de PersonID se genera en ambas tablas al mismo tiempo, y también es la clave extranjera correspondiente. También restringe las claves principales de las dos tablas al mismo tiempo y es única.
5. Escribir y cargar prueba
Después de generar la tabla, escriba la tabla y lea los datos de la tabla, escriba la clase de prueba correspondiente, y la prueba usa pruebas unitarias y escribe los métodos de prueba correspondientes.
5.1 Prueba de escritura
Al escribir en la base de datos, asegúrese de tener en cuenta que ambos objetos escritos deben convertirse en el estado de entrenamiento correspondiente, de lo contrario se producirá un error de conversión de estado. El código de prueba es el siguiente:
public void testSave1 () {session session = null; Pruebe {// cree una sesión de objeto de sesión = hibernateUtil.getSession (); // habilitar la transacción session session.beGinTransaction (); // Crear un objeto de persona y salvar persona persona = nueva persona (); persona.setName ("Zhangsan"); session.save (persona); // Crear un objeto IDCard y guardar idcard idcard = new IdCard (); idcard.setCardno ("1111111111111"); idcard.setperson (persona); session.save (idcard); // Enviar transacciones y modificar la base de datos session.getTransaction (). Commit (); } catch (excepción e) {// Imprimir mensaje de error E.PrintStackTrace (); // Business Rollback Session.getTransaction (). Rollback (); } Finalmente {// cierre la sesión hibernateUtil.clossession (sesión); }} Los datos insertados se muestran a continuación:
5.2 Prueba de carga
Escribe un método de carga. Debido a que la relación de asociación es bidireccional, la operación de carga correspondiente debe ser cargar el otro extremo a través de un extremo, es decir, obtener la clase de persona correspondiente y obtener la información ideal correspondiente a través de la clase de persona. Lo contrario también debe ser cierto, el código es el siguiente:
public void testLoad1 () {session session = null; Pruebe {// cree una sesión de objeto de sesión = hibernateUtil.getSession (); // habilitar la transacción session session.beGinTransaction (); // Obtener el objeto de la persona y salvar a la persona = (persona) session.load (persona.class, 5); System.out.println ("idcard.id:"+persona.getidcard (). GetId ()); System.out.println ("idcard.cardno:"+persona.getidcard (). GetCardno ()); // Crear un objeto IDCard y guardar idcard idcard = (idcard) session.load (idcard.class, 5); System.out.println ("Person.id:"+idcard.getperson (). GetId ()); System.out.println ("Person.name:"+idcard.getperson (). GetName ()); // Enviar transacciones y modificar la base de datos Session.getTransaction (). Commit (); } catch (excepción e) {// Imprimir mensaje de error E.PrintStackTrace (); // Business Rollback Session.getTransaction (). Rollback (); } Finalmente {// cierre la sesión hibernateUtil.clossession (sesión); }} Ejecute el método de prueba anterior e imprima el contenido relevante en la consola de la siguiente manera:
2. Relación de clave extranjera bidireccional
La Asociación de Clave Exterior Bidireccional puede entenderse como un caso especial de Asociación de Clave Exterior. Esta especialidad se debe principalmente a una correspondencia bidireccional. En el artículo anterior, se mencionó que si desea agregar un campo de clave extranjera a una tabla, puede usar la etiqueta <Many-to-One>, que generará la columna de clave extranjera correspondiente en el modelo de relación. Esta etiqueta debe usarse si desea lograr una asociación de clave extranjera bidireccional.
1. Modelo de objetos
Primero veamos el modelo de objeto. Las personas y las tarjetas de identificación son una relación uno a uno. Una persona corresponde a una identidad, por lo que los multiplex entre ellos son uno a uno, y esta correspondencia es de dos vías. Por lo tanto, su modelo de objeto es el mismo que la clave primaria bidireccional uno a uno, como se muestra en la figura a continuación:
2. Modelo relacional
El modelo de relación correspondiente cambiará enormemente. La relación de clave extranjera individual generará la clave extranjera correspondiente en una tabla. Cuando obtiene la persona y la tarjeta de identificación, significa que habrá una columna clave principal del número de tarjeta de identificación en el modelo de relación, y se forma una situación de bidireccional uno a uno, como se muestra en la figura a continuación:
La correspondencia entre ellos se ve en la figura anterior. Existe la clave principal de la tabla Idcard en la tabla de personas, formando una relación de asociación de clave extranjera individual, y es bidireccional. Es decir, el Idcard se puede obtener a través de la persona, y la persona también se puede obtener a través de Idcard.
El código en el objeto de persona y el objeto idcard es el mismo que el código de objeto en el artículo anterior. No figura en el código. La única diferencia es el problema de configuración en el archivo de asignación.
3. Mapeo de archivos
IDCARD.HBM.XML FILE DE MAPPACIÓN. La tabla IDCard no es la tabla principal del mapeo, por lo que al hacer mapeo uno a uno, debe usar la etiqueta <One to-One para configurarla, y debe formular atributos de clave externa en el modelo de relación de persona. El código específico es el siguiente:
<? xml versión = "1.0"?> < -> <hibernate-mapping> <class name = "com.src.Hibernate.idCard" table = "idcard"> <id name = "id" type = "int"> <generador /> < /id> <propiedad name = "cardno" type = "java.lang.string"> <name de columna = "cardno" /> </sperties> <one to-name = "persona" persona " Property-Ref = "Idcard"> </ One-To-One> </class> </hibernate-mapping>
Person.hbm.xml de mapeo, la tabla de personas es la tabla principal de la asignación. Se debe agregar una columna de atributo de clave externa a la tabla para indicar la tabla IDCARD. Por lo tanto, la etiqueta <Boste-to-One> debe usarse aquí para generar la clave externa correspondiente en el objeto de la persona, y único también debe usar exclusivo para indicar que el atributo es único.
<? xml versión = "1.0"?> < -> <hibernate-mapping> <class name = "com.src.Hibernate.person" table = "Person"> <id name = "id" type = "int" columna = "personido"> <generador /> < /id> <property name = "name" type = "java.lang.string"> <column = "name" /> </propine> <nlege-one name = "Idcard" columna "columna" columna "columna" columna "columna" columna ". unique = "true" no-null = "true"> </ingle-o-one> </class> </hibernate-mapping>
La configuración del archivo de asignación del objeto se completa y luego se genera un modelo relacional. La declaración SQL es la siguiente:
Tabla de alter Tabla Drop NECHE EXTRANJE CLAVE FK8C768F55794A52CA TABLA DE LA TABLA IDCARD IDCARD TABLA SI EXISTE CREATE CREATE TABLE IDCARD (ID Integer no nulo Auto_incement, Cardno Varchar (255), Key primaria (id)) Crear persona (Personid Integer no NULLO_INCRENT (PersonId)) Alter Tabla Persona Agregar índice FK8C768F55794A52CA (IDCARDNO), Agregar restricción FK8C768F55794A52CA Clave exterior (Idcardno) Referencias IDCARD (ID)
La declaración SQL generada es en primer lugar la tabla creada. Al crear la tabla, se especifica la columna de clave primaria. Después de completar la creación, las dos tablas se modifican para especificar atributos de clave externa para formar una relación uno a uno.
Escriba un método de prueba, adopte pruebas unitarias, cargue objetos de dos clases y obtenga otro objeto de un extremo del objeto respectivamente
// Cargue el objeto y cargue el objeto de persona usando el objeto idcard public void testLoad1 () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); // Obtenga el objeto Idcard y obtenga el objeto de la persona asociado de manera única con el objeto en Idcard idcard idcard = (idcard) session.load (idcard.class, 1); System.out.println ("Person.id ="+idcard.getperson (). GetId ()); System.out.println ("idcard.person.name ="+idcard.getperson (). GetName ()); // Objeto Getperson y obtenga el objeto Idcard que se asocie de manera única en el objeto de la persona persona persona = (persona) session.load (persona.class, 1); System.out.println ("idcard.id:"+persona.getidcard (). GetId ()); System.out.println ("idcard.cardno:"+persona.getidcard (). GetCardno ()); // Commit Transaction Session.GetTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); session.getTransaction (). Rollback (); } finalmente {hibernateUtils.clossessession (sesión); }} Contenido generado:
Comparando las dos relaciones de mapeo, la clave principal y las relaciones de mapeo de clave extranjera son relaciones de mapeo bidireccionales, y la relación de mapeo debe configurarse al mismo tiempo en ambos extremos del objeto. La diferencia es que la clave principal solo necesita usar <One to-One> porque no necesita generar columnas de atributos, pero la estrategia de generación de clave primaria extranjera debe usarse para la clave principal de la tabla y el objeto de clave extranjera está marcada; La estrategia de generación de claves exteriores debe usar la etiqueta <Many-to-One> para generar nuevas columnas de claves exteriores.
Conclusión
El mapeo uno a uno en una asociación bidireccional se ha discutido hasta ahora. Los dos artículos discuten principalmente dos usos de una asociación bidireccional. De hecho, todavía es muy simple. Recuerde usar la etiqueta <Many-to-One> si desea generar una clave extranjera. Si es único, agregue el atributo único. La etiqueta <One-One> solo indica una relación uno a uno. Solo indica cómo un objeto carga otro objeto y no agrega una nueva columna en el modelo de relación. El próximo artículo discutirá las relaciones de uno a muchos.