Mapeo de muchos a uno
Las asociaciones de muchas a uno son las relaciones de asociación más comunes, donde un objeto puede asociarse con múltiples objetos. Por ejemplo, un objeto de dirección idéntico puede estar asociado con objetos de múltiples empleados.
Defina la tabla RDBMS:
Considere una situación en la que necesitamos que los registros de los empleados se almacenen en la tabla de empleados, que tendrá la siguiente estructura:
Crear tabla empleado (id int no null auto_incement, first_name varchar (20) predeterminado NULL, last_name varchar (20) predeterminado nulo, salary int predeterminado nulo, dirección no nulo, clave primaria (id));
Además, muchos empleados pueden tener la misma dirección, por lo que esta asociación puede presentarse utilizando muchas asociaciones uno a uno. Almacenamos la información relacionada con la dirección en una tabla separada con la siguiente estructura:
Crear dirección de tabla (ID int no nulo auto_incement, street_name varchar (40) predeterminado nulo, city_name varchar (40) predeterminado nulo, state_name varchar (40) predeterminado nulo, zipcode varchar (10) predeterminado nulo, clave primaria (id));
Cree tablas RBDMS al mismo tiempo y déjelos prepararse para la próxima implementación.
Defina la clase POJO:
Implementemos un empleado de clase POJO que se utilizará para mantener variables del objeto y su tipo de dirección con la tabla de empleados.
import java.util.*; empleado de clase pública {private int id; cadena privada FirstName; cadena privada lastname; salario privado int; dirección de dirección privada; Public Employee () {} Public Employee (String fname, String lname, int salario, dirección dirección) {this.firstname = fname; this.lastName = lname; this.salary = salario; this.address = dirección; } public int getId () {return id; } public void setid (int id) {this.id = id; } public String getFirstName () {return FirstName; } public void setFirstName (String First_Name) {this.firstname = first_name; } public String getLastName () {return LastName; } public void setLastName (string last_name) {this.lastName = last_name; } public int getSalary () {salario de retorno; } public void setSalary (int salario) {this.salary = salary; } dirección pública getAddress () {Dirección de retorno; } public void setAddress (dirección de dirección) {this.address = dirección; }}Necesitamos definir la tabla de direcciones correspondiente para que el objeto de dirección pueda almacenar y recuperar otra clase de POJO en la tabla de direcciones.
import java.util.*; dirección de clase pública {private int id; calle de cuerda privada; Ciudad de cadena privada; estado de cadena privada; Cadena privada ZipCode; dirección pública () {} dirección pública (string street, string city, string state, string zipcode) {this.street = street; this.city = City; this.state = state; this.zipcode = zipcode; } public int getId () {return id; } public void setid (int id) {this.id = id; } cadena pública getStreet () {return street; } public void setstreet (string street) {this.street = street; } public String getCity () {return City; } public void setCity (String City) {this.city = City; } public String getState () {State de retorno; } public void setState (string state) {this.state = state; } public String getZipCode () {return zipcode; } public void setzipcode (string zipcode) {this.zipcode = zipcode; }} Definir el archivo de mapeo de hibernación:
Desarrolle nuestro archivo de asignación que instruya a Hibernate cómo definir el mapa de clases a las tablas de la base de datos. Los elementos de procesamiento <Many-to-One> se utilizarán para definir reglas para establecer una relación de muchos a uno entre las entidades de empleados y direcciones.
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping dtd // en" "http://wwww.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <HiCercnate-mapping> <calse name = "empleado" table = "Empleado"> <meta attribute = "clase-descripción"> Esta clase contiene el detalle del empleado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <propiedad name = "firstName" column = "first_name" type = "String"/> <Property Name = "LastName" columna = "Last_name" type = "String"/> <name de propiedad = "salarial" column = "salary type =" int "/> <muchos to-name name" dirección "columna" columna "columna" columna "columna" columna "columna" columna "columna" columna "columna" columna "column" no-null = "true"/> </class> <class name = "dirección" table = "dirección"> <meta attribute = "class-descripción"> Esta clase contiene el detalle de la dirección. </meta> <id name = "id" type = "int" columna = "id"> <generador/> </d> <propiedad name = "street" column = "street_name" type = "string"/> <Property name = "city" column = "city_name" type = "string"/> <name de propiedad = "estatal" columna = "state_name" type = "string"/> <property name = "zipCode" columna "columna" columna "zipcode" columna "zipcode" type = "String"/> </class> </hibernate-mapping>
El formato <classname> .hbm.xml en el archivo de asignación que debe guardar. Guarde el archivo empleado.hbm.xml en el archivo de asignación. Ya está familiarizado con la mayoría de los detalles de mapeo, pero veamos todos los elementos en el archivo de mapeo nuevamente:
Un documento mapeado es un documento XML con <Hibernate-Mapping> como un elemento raíz correspondiente a cada clase que contiene 2 elementos <class>.
El elemento <class> se usa para definir una mapeo específica de la tabla de la base de datos de una clase Java. El nombre de la clase Java especifica el atributo de nombre del elemento de clase y el nombre de la base de datos de atributos de la tabla especifica el nombre de la tabla.
El elemento <seta> es un elemento opcional que se puede usar para crear una descripción de la clase.
El elemento <id> mapea el atributo de identificación único en la clase a la clave principal de la tabla de la base de datos. El atributo de nombre del elemento ID se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El valor de clave principal en el elemento <Generator> dentro del elemento ID se usa para generar automáticamente. Establezca el atributo de clase del elemento generado para que hibernate de forma nativa elija los algoritmos de si es identidad, secuencia o hilo para crear claves primarias de acuerdo con las capacidades de soporte de la base de datos subyacente.
El elemento <Protey> se utiliza para mapear las propiedades de una clase Java a columnas en una tabla de base de datos. El atributo de nombre de un elemento se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento de procesamiento <Many-to-One> se utiliza para establecer la relación entre el empleado y la entidad que abordan. El atributo de nombre se establece en una variable definida en la clase principal, en nuestro caso es la dirección. El atributo de columna se utiliza para los nombres de la columna en el conjunto de empleados de la tabla principal.
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Utilizaremos esta aplicación para guardar a algunos empleados junto con su dirección para registrar su dirección, y luego solicitaremos la operación CRUD en el registro.
import java.util.*; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.cfg.configuration; public class Managementee {private sessionfactory factory; public static void main (string [] args) {try {factory = new Configuration (). configure (). BuildSessionFactory (); } catch (showable EX) {System.err.println ("No se pudo crear el objeto SessionFactory." + EX); arrojar nuevos excepcionios de excepcionios (ex); } ManageMloyee ME = new ManageMloyee (); / * Tengamos un objeto de dirección */ dirección dirección = me.addaddress ("kondapur", "hyderabad", "ap", "532"); / * Agregar registros de empleados en la base de datos */ Integer Empid1 = me.addemployee ("Manoj", "Kumar", 4000, dirección); / * Agregue otro registro de empleados en la base de datos */ Integer Empid2 = me.addemployee ("Dilip", "Kumar", 3000, dirección); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros salariales del empleado */ me.updateeMployee (Empid1, 5000); / * Eliminar a un empleado de la base de datos */ me.deleteEmployee (Empid2); / * Enumere a todos los empleados */ me.listEmployees (); } / * Método para agregar un registro de dirección en la base de datos * / Dirección pública DirecciónDdress (string street, string city, string state, string zipcode) {session session = factory.opensession (); Transacción tx = nulo; Integer directionId = null; Dirección dirección = nulo; intente {tx = session.beGinTransaction (); dirección = nueva dirección (calle, ciudad, estado, zipcode); directionId = (Integer) session.save (dirección); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } Dirección de retorno; } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fName, String lname, int salario, dirección de dirección) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado empleado = nuevo empleado (fname, lname, salario, dirección); EmployeeId = (Integer) Session.save (Empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } return EmployeeId; } / * Método para enumerar todos los detalles de los empleados * / public void listEmployees () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Lista de empleados = session.createQuery ("del empleado"). List (); para (iterator iterator = empleado.iterator (); iterator.hasnext ();) {empleado empleado = (empleado) iterator.next (); System.out.print ("Nombre:" + Empleado.getFirstName ()); System.out.print ("apellido:" + empleado.getLastName ()); System.out.println ("Salario:" + Empleado.getSalary ()); Dirección add = empleado.getAddress (); System.out.println ("dirección"); System.out.println ("Street:" + add.getstreet ()); System.out.println ("City:" + add.getCity ()); System.out.println ("State:" + add.getState ()); System.out.println ("Zipcode:" + add.getzipcode ()); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para actualizar el salario para un empleado * / public void UpdateEmployee (Integer EmployeeId, int salario) {sesión session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); empleado. Setsalary (salario); sesión.update (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para eliminar a un empleado de los registros * / public void DeleteEmployee (Integer EmployeeItId) {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); session.delete (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Compilar y ejecutar:
Estos son los pasos para compilar y ejecutar la aplicación anterior. Asegúrese de que la ruta y la classpath se establezcan adecuadamente antes de compilar y ejecutar.
Obtenga los siguientes resultados en la pantalla y los registros se crean tanto en las tablas de empleados como de direcciones.
$ Java ManagementEmployee
..... Varios mensajes de registro se mostrarán aquí ......... Nombre: Manoj Apellido: Kumar Salario: 4000address Street: Kondapur Ciudad: Hyderabad Estado: AP Zipcode: 532First Nombre: Dilip Apellido: Kumar Salario: 3000address Street: Kondapur City: Hyderabad Estado: AP Zipcode: 532First Nombre: ManoJ SALED Nombre: Kumar Salary: 5.mumar Salario Calle: Kondapur Ciudad: Hyderabad Estado: AP ZipCode: 532
Si verifica la tabla del empleado y las direcciones, debe registrarlo:
mysql> select * de empleado;
+----------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------
mysql> seleccionar * de la dirección;
+----------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------
Mapeo de uno a muchos
Se puede implementar una mapeo de uno a muchos utilizando un conjunto de colecciones Java que no contienen elementos duplicados. Hemos visto cómo establecer mapas en Hibernate, por lo que si ha aprendido sobre las asignaciones establecidas, entonces todas las configuraciones se pueden usar para asignaciones de uno a muchos.
El conjunto se asigna al elemento <set> en la tabla de mapas y se inicializa en java.util.hashset. Puede usar colecciones Establecer en una clase, con un elemento en la colección que no requiere duplicación.
Todavía usamos la tabla RDBMS y las clases POJO definidas en el ejemplo anterior.
Definir el archivo de mapeo de hibernación:
Instruyamos Hibernate cómo definir una clase mapeada en el archivo de asignación de una tabla de base de datos.
<? xml versión = "1.0" encoding = "utf-8"?> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapping dtd // en" "http://wwww.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <HiCercnate-mapping> <calse name = "empleado" table = "Empleado"> <meta attribute = "clase-descripción"> Esta clase contiene el detalle del empleado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <set name = "certificados" cascade = "all"> <key column = "empleado_id"/> <uno-to-many/> </set> <sperty name = "firstName" column = "first_name" type = "string"/> <propiedad de propiedad = "LastName" columna "columna" columna "columna" " type = "String"/> <Property Name = "Salario" Columna = "Salario" type = "int"/> </class> <class name = "certificado" table = "certificado"> <meta atribute = "-descripción de clases"> Esta clase contiene los registros de certificado. </meta> <id name = "id" type = "int" column = "id"> <generador/> </id> <propiedad name = "name" column = "certate_name" type = "string"/> </sclass> </ hibernate-mapping>
El formato <classname> .hbm.xml en el archivo de asignación que debe guardar. Guardamos el archivo empleado.hbm.xml en el archivo de asignación. Ya está familiarizado con la mayoría de los detalles de mapeo, pero veamos todos los elementos en el archivo de asignación nuevamente:
Un documento mapeado es un documento XML con <Hibernate-Mapping> como un elemento raíz correspondiente a cada clase que contiene 2 elementos <class>.
El elemento <class> se usa para definir una mapeo específica de la tabla de la base de datos de una clase Java. El nombre de la clase Java especifica el atributo de nombre del elemento de clase y el nombre de la base de datos de atributos de la tabla especifica el nombre de la tabla.
El elemento <seta> es un elemento opcional que se puede usar para crear una descripción de la clase.
El elemento <id> mapea el atributo de identificación único en la clase a la clave principal de la tabla de la base de datos. El atributo de nombre del elemento ID se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <Generator> dentro del elemento ID se usa para generar automáticamente el valor de clave principal. Establezca el atributo de clase del elemento generado para permitir que la identidad, secuencia o algoritmos HILO de recoger hibernación de forma nativa para crear claves primarias de acuerdo con las capacidades de soporte de la base de datos subyacente.
El elemento <Protey> se utiliza para mapear las propiedades de una clase Java a columnas en una tabla de base de datos. El atributo de nombre de un elemento se refiere a la clase del atributo y el atributo de columna se refiere a las columnas en la tabla de la base de datos. El atributo de tipo guarda el tipo de mapeo de hibernación, que se convertirá de Java a tipo de datos SQL.
El elemento <set> establece la relación entre el certificado y la clase de empleado. Usamos el elemento <Set> en el atributo Cascade para decirle a Hibernate que guarde el objeto Certificado y también sea el objeto del empleado. El atributo de nombre se establece en el conjunto de variables definidas en la clase principal, en nuestro ejemplo es el certificado. Para cada conjunto de variables, necesitamos definir un conjunto separado de elementos en el archivo de mapeo.
El elemento <Key> es el objeto principal que contiene una clave externa, es decir, la columna en la tabla de certificados. Empleado de la tabla.
El elemento <One to-muchas> indica que un objeto de empleado involucra muchos certificados.
Crear una clase de aplicación:
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Utilizaremos esta aplicación para guardar algunos empleados junto con el certificado de registro, y luego aplicaremos el registro de operación RRUD.
import java.util.*; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.cfg.configuration; public class Managementee {private sessionfactory factory; public static void main (string [] args) {try {factory = new Configuration (). configure (). BuildSessionFactory (); } catch (showable EX) {System.err.println ("No se pudo crear el objeto SessionFactory." + EX); arrojar nuevos excepcionios de excepcionios (ex); } ManageMloyee ME = new ManageMloyee (); / * Tengamos un conjunto de certificados para el primer empleado */ hashset set1 = new Hashset (); set1.add (nuevo certificado ("mcA")); set1.add (nuevo certificado ("MBA")); set1.add (nuevo certificado ("MBA")); set1.Add (nuevo certificado ("PMP")); / * Agregar registros de empleados en la base de datos */ integer empid1 = me.addemployee ("manoj", "kumar", 4000, set1); / * Otro conjunto de certificados para el segundo empleado */ hashset set2 = new Hashset (); set2.Add (nuevo certificado ("BCA")); set2.Add (nuevo certificado ("BA")); / * Agregue otro registro de empleados en la base de datos */ Integer Empid2 = me.addemployee ("Dilip", "Kumar", 3000, set2); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros salariales del empleado */ me.updateeMployee (Empid1, 5000); / * Eliminar a un empleado de la base de datos */ me.deleteEmployee (Empid2); / * Enumere a todos los empleados */ me.listEmployee (); } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fName, String lname, int salario, set cert) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado empleado = nuevo empleado (fname, lname, salario); empleado.setCertificates (cert); EmployeeId = (Integer) Session.save (Empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } return EmployeeId; } / * Método para enumerar todos los detalles de los empleados * / public void listEmployees () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Lista de empleados = session.createQuery ("del empleado"). List (); para (iterator iterator1 = empleado.iterator (); iterator1.hasnext ();) {empleado empleado = (empleado) iterator1.next (); System.out.print ("Nombre:" + Empleado.getFirstName ()); System.out.print ("apellido:" + empleado.getLastName ()); System.out.println ("Salario:" + Empleado.getSalary ()); Establecer certificados = empleado.getCertificates (); for (iterator iterator2 = certates.iterator (); iterator2.hasnext ();) {certificado certName = (certificado) iterator2.next (); System.out.println ("certificado:" + certname.getName ()); }} tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para actualizar el salario para un empleado * / public void UpdateEmployee (Integer EmployeeId, int salario) {sesión session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); empleado. Setsalary (salario); sesión.update (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para eliminar a un empleado de los registros * / public void DeleteEmployee (Integer EmployeeItId) {Session Session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Empleado Empleado Empleado = (Empleado) Session.get (Employee.Class, EmployeeId); session.delete (empleado); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Compilar y ejecutar:
$ Java ManagementEmployee
.....VARIOUS LOG MESSAGES WILL DISPLAY HERE.........First Name: Manoj Last Name: Kumar Salary: 4000Certificate: MBACertificate: PMPCertificate: MCAFirst Name: Dilip Last Name: Kumar Salary: 3000Certificate: BCACertificate: BAFirst Name: Manoj Last Name: Kumar Salary: 5000Certificate: MBACertificate: PMPCertificate: MCA
Si verifica el formulario de empleado y certificado, debe registrarlo:
mysql> select * de empleado;
+----------------------------+----------+| ID | First_Name | Last_Name | Salario |+------------------------------------+------------+----------+| 1 | Manoj | Kumar | 5000 |+--------------------------------+---------+1 fila en el set (0.00 segundos)
mysql> seleccionar * de certificado;
+----------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------