Mapeo de mapas
MAP MAP es una colección Java que almacena elementos en pares de valores clave y no permite elementos duplicados en una lista. La interfaz MAP proporciona tres vistas de colección, lo que permite que el contenido del mapa se considere como un conjunto de colecciones de valores clave, o configurando la relación de mapeo de valor clave.
El mapa se asigna a un elemento <MAP> en la tabla de mapeo y se puede inicializar un mapa desordenado en java.util.hashmap.
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, salario int predeterminado nulo, clave primaria (id));
Además, se supone que cada empleado puede tener uno o más certificados relacionados con él/ella. Almacenamos la información relevante del certificado en una tabla separada con la siguiente estructura:
Crear certificado de tabla (ID int no nulo auto_incement, certate_type varchar (40) predeterminado nulo, certificate_name varchar (30) predeterminado NULL, empleado_id int predeterminado nulo, clave primaria (id));
Hay una relación de uno a muchos entre el empleado y el objeto de certificado.
Defina la clase POJO:
Implementemos un empleado de clase POJO que se utilizará para mantener una colección de objetos en la tabla de empleados y una variable de lista con certificados.
import java.util.*; empleado de clase pública {private int id; cadena privada FirstName; cadena privada lastname; salario privado int; certificados de mapa privado; Public Employee () {} Public Employee (String fname, String lname, int salario) {this.firstname = fname; this.lastName = lname; this.salary = salario; } 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; } Mapa público getCertificates () {Certificados de retorno; } public void setCertificates (certificados de mapa) {this.certificates = certificados; }}Necesitamos la tabla de certificados correspondiente para definir otra clase de POjo, dicho objeto de certificado puede almacenar y recuperar la tabla de certificados.
Certificado de clase pública {private int id; nombre de cadena privada; Certificado público () {} Certificado público (nombre de cadena) {this.name = name; } 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; }} Definir el archivo de mapeo de hibernación:
Desarrolle un archivo de mapeo que instruya a Hibernate cómo definir una clase mapeada en una tabla de base de datos. El elemento <MAP> se usará para definir las reglas para el mapa utilizado.
<? 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> <map name = "certificados" cascade = "all"> <key column = "empleado_id"/> <index column column = "certate_type" type = "string"/> <one to-many/> </per> <name de propiedad = "primera columna" column = "firstname" type "type" name = "LastName" Column = "Last_name" type = "String"/> <Property Name = "Salario" columna = "Salario" type = "int"/> </sclass> <class name = "certificado" table = "certificado"> <meta attribute = "clase de clase"> 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 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 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 como nativo para permitir que Hibernate elija el algoritmo en 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 <MAP> se usa para establecer la relación entre el certificado y la clase de empleados. Utilizamos el elemento <MAP> del atributo Cascade para decirle a Hibernate que guarde el objeto Certificado, y también al objeto del empleado. El atributo de nombre está configurado para definir el mapVariable en la clase principal, en nuestro caso el certificado.
El elemento <dexic> se usa para representar pares de teclas/valor de claves y valores. Esta clave usará un tipo de cadena almacenado en la columna Certificado_Type.
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-Many> indica que un objeto de empleado involucra muchos objetos de certificado y, por lo tanto, el objeto de certificado debe estar relacionado con la clase principal del empleado. Puede usar los elementos <One to-One>, <nlez-to-one> o <Many-to-many> según sea necesario.
Crear una clase de aplicación:
Finalmente, cree el método Main () de la clase de aplicación para ejecutar la aplicación. Use esta aplicación para guardar los registros de los empleados junto con la lista de certificados y luego realice registros en la operación CRUD en la aplicación.
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 */ hashmap set = new Hashmap (); set.put ("ComputerScience", nuevo certificado ("MCA")); set.put ("BusinessManagement", nuevo certificado ("MBA")); set.put ("ProjectManagement", nuevo certificado ("PMP")); / * Agregar registros de empleados en la base de datos */ integer empid = me.addemployee ("manoj", "kumar", 4000, set); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros salariales del empleado */ me.updateeMployee (Empid, 5000); / * Enumere a todos los empleados */ me.listEmployees (); } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fname, String lname, int salario, certhmap cert) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); 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 ()); Mapa ec = empleado.getCertificates (); System.out.println ("certificado:" + (((((certificado) ec.get ("ComputerScience")). GetName ())); system.out.println ("certificado:" + (((((certificado) ec.get ("BusinessManagement")). GetName ())); System.Println ("Certificate:" + " ((((Certificado) EC.get ("ProjectManagement")). GetName ())); E.PrintStackTrace (); empleado.setsalary (salario); sesion = factory.opensess (); Finalmente {session.close (); Compilar y ejecutar:
Estos son los pasos para compilar y ejecutar la aplicación anterior. Asegúrese de que haya establecido ruta y classpath adecuadamente antes de compilar y ejecutar.
Los siguientes resultados se obtendrán en la pantalla y los registros se crean tanto en los formularios de empleados como de certificado.
$ Java ManagementEmployee
..... varios mensajes de registro se mostrarán aquí .........
Nombre: Manoj Apellido: Kumar Salario: 4000 Certificado: McAcertificate: Mbacertificate: PMPFirst Nombre: Manoj Apellido: Kumar Salario: 5000 Certificado: McAcertificate: Mbacertificate: PMP
Si verifica el formulario de empleado y certificado, debe registrarlo:
mysql> select * de empleado;
+-----------------------------+------------+| ID | First_Name | Last_Name | Salario |+--------------------------------------+---------------+| 60 | Manoj | Kumar | 5000 |+---------------------------------+---------+1 fila en el set (0.00 segundos)
mysql> seleccionar * de certificado;
+----------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------
Mapeo de mapas
SortedMap es un elemento almacenado en un par de valores clave y proporciona el tipo general de claves similares a las colecciones Java para mapeos. No se permiten elementos duplicados en el mapeo. El mapa se clasifica en el orden natural de sus claves, o proporcionando una comparación generalmente en el tiempo de creación del mapa ordenado.
Los elementos <MAP> y los mapas ordenados que SortedMap se asignan en la tabla de mapeo se pueden inicializar en java.util.Teemap.
Todavía usamos la tabla RDBMS y la clase POJO definida anteriormente para ilustrar el siguiente ejemplo:
Definir el archivo de mapeo de hibernación:
Desarrolle un archivo de mapeo que instruya a Hibernate cómo definir una clase mapeada en una tabla de base de datos. El elemento <MAP> se usará para definir las reglas para el mapa utilizado.
<? 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/> </d> <map name = "certificados" cascade = "all" sort = "myclass"> <key column = "empleado_id"/> <index column = "certificate_type" type = "string"/> <One--Many/> </map> <spertyName = "FirstName" columna "columna" columna "columna" columna " type = "String"/> <Property Name = "LastName" Column = "Last_Name" type = "String"/> <Property Name = "Salario" columna = "Salario" type = "int"/> </class> <class name = "certificado" table = "certificado"> <meta attribute = "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 de asignación empleado.hbm.xml. 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 un elemento raíz de <Hibernate Mapping> 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 hacer hibernado correspondiente al algoritmo en 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 <MAP> se usa para establecer la relación entre el certificado y la clase de empleados. Utilizamos el elemento <MAP> del atributo Cascade para decirle a Hibernate que guarde el objeto Certificado, y también al objeto del empleado. El atributo de nombre se establece en la variable SortedMap definida en la clase principal, en nuestro caso es un certificado. La propiedad de clasificación se puede configurar en clasificación natural, o se puede establecer en implementación de clase personalizada como java.util.comparator. Hemos utilizado una clase MyClass que lo implementa como Java.util.comparador para revertir el orden de clasificación de la implementación de la clase de certificado.
El elemento <dexic> se usa para representar la parte clave del mapa de par de clave/valor. Esta clave usará un tipo de cadena almacenado en la columna Certificado_Type.
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-Many> indica que un objeto de empleado involucra muchos objetos de certificado y, por lo tanto, el objeto de certificado debe estar asociado con el padre del empleado. Puede usar los elementos <One to-One>, <nlez-to-one> o <Many-to-many> según sea necesario.
Si usa Sort = "Natural", entonces no necesitamos crear una clase separada, porque la clase de certificado ha implementado la interfaz comparable y Hibernate utilizará Compareto en la clase de certificado definida como el método SortedMap (). Sin embargo, estamos utilizando una clase de comparación personalizada MyClass en nuestro archivo de asignación, por lo que tenemos que crear esta clase basada en nuestro algoritmo de clasificación. Hagamos la clasificación clave que está disponible en el mapa.
import java.util.comparator; public class MyClass implementa comparador <String> {public int Compare (String O1, String O2) {final int antes = -1; Final int After = 1; / * Para revertir el orden de clasificación, múltiple por -1 */ if (o2 == null) {return antes * -1; } Comparable thisCertificate = O1; Comparable thatcertificate = o2; if (thisCertificate == null) {return después * 1; } else if (thatCertificate == null) {return antes * -1; } else {return thisCertificate.compareto (thatCertificate) * -1; }}}Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Utilizaremos esta solicitud para guardar algunos registros de empleados junto con el certificado, y luego enviaremos la operación CRUD por encima de los registros.
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 */ Treemap set1 = new Treemap (); set1.put ("ComputerScience", nuevo certificado ("MCA")); set1.put ("BusinessManagement", nuevo certificado ("MBA")); set1.put ("ProjectManagement", 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 */ Treemap set2 = new Treemap (); set2.put ("ComputerScience", nuevo certificado ("MCA")); set2.put ("BusinessManagement", nuevo certificado ("MBA")); / * 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.listEmployees (); } / * Método para agregar un registro de empleado en la base de datos * / public Integer AddEmployee (String fname, String lname, int salario, treemap cert) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); 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 ()); SortedMap <String, certificado> map = empleado.getCertificates (); for (map.entry <string, certificado> entrada: map.entryset ()) {system.out.print ("/tCertificate type:" + entry.getKey ()); System.out.println (", nombre:" + (Entry.getValue ()). 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) session.get (empleado.class, empleadoid); 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:
Puede ver que los certificados se han ordenado en el orden opuesto. Puede probarlo cambiando el archivo de mapeo, simplemente establezca sort = "natural" y ejecute el programa y compare los resultados.
$ Java ManagementEmployee
..... Varios mensajes de registro se mostrarán aquí ......... Nombre: Manoj Apellido: Kumar Salario: 4000 Tipo de certificado: Proyecto Ganagement, Nombre: PMP Tipo de certificado: Computerscience, Nombre: MCA Tipo de certificado: BusinessManagement, Nombre: MBAFIRST Nombre: Dilip Apellido Nombre: Kumar SALARIO: 3000 Tipo de certificado de Certificado de ManEj: Nombre: MCA: Tipo de certificado MCA: Nombre: Nombre de ManOj. Salario de Kumar: 5000 Tipo de certificado: gestión de proyectos, nombre: Tipo de certificado de PMP: Computerscience, Nombre: Certificado MCA Tipo de certificado: Nombre, Nombre: MBA
Si verifica el formulario de empleado y certificado, debe registrarlo:
mysql> select * de empleado;
+----+--------------------+---------+| ID | First_Name | Last_Name | Salario |+------------------------------------+-------------+------------+| 74 | Manoj | Kumar | 5000 |+--------------------------------+---------+1 fila en el set (0.00 segundos)
mysql> seleccionar * de certificado;
+----------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------