anotación
Hibernate Annotation es un último método que no utiliza archivos XML para definir asignaciones. Las anotaciones se pueden usar en metadatos de mapeo XML que están separados o reemplazados.
Las anotaciones de Hibernate son una forma poderosa de proporcionar mapeos de objetos de metadatos y tablas relacionales. Todos los metadatos se aplastan junto con el archivo POJO Java. Esto puede ayudar a los usuarios a comprender la estructura de la tabla y el POJO durante el proceso de desarrollo.
Si tiene la intención de portar la aplicación a otras aplicaciones ORM específicas de EJB3, debe usar anotaciones para representar la información de mapeo, pero si desea una mayor flexibilidad, debe usar el mapeo basado en XML.
Establecer anotación de hibernación en el entorno primero, debe asegurarse de usar JDK5.0, de lo contrario, debe actualizar JDK a JDK5.0 Soporte nativo con anotaciones.
En segundo lugar, debe instalar el paquete de distribución de anotaciones 3.x de Hibernate, puede usar SourceForge: (descargue la anotación Hibernate) y copiar Hibernate-Annotations.jar, lib/hibernate-comons-annotations.jar y lib/eJb3-persestence.jar a asignar de anotaciones de hibernate a classpath de Hibernate Annotations.
Instancia de clase comentada:
Como se mencionó, todos los metadatos que funcionan con la anotación de hibernación funcionan en el archivo POJO Java por encima de esto puede ayudar a los usuarios a comprender tanto la estructura de la tabla como el POJO durante el desarrollo.
Considere el objeto que se almacenará utilizando la siguiente tabla de empleados:
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));
La siguiente es la asignación de la clase de empleados del objeto con anotaciones para mapear con la tabla de empleados definidos:
import javax.persistence.*; @entity @table (name = "empleado") empleado de clase pública {@id @GeneratedValue @column (name = "id") private int id; @Column (name = "First_Name") String private FirstName; @Column (name = "Last_Name") String privado LastName; @Column (name = "salario") Private int salario; Public Employee () {} 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; }}Hibernate detecta que la anotación @ID está en un campo y supone que debe acceder a las propiedades de un objeto directamente a través del dominio de tiempo de ejecución. Si @ID se anota con el método getId (), se accederá a la propiedad de forma predeterminada a través de los métodos de Getter y Setter. Por lo tanto, todos los demás comentarios también se colocan en el método de campo o getter, como se selecciona debajo de la política. La siguiente sección explica los comentarios utilizados en la clase anterior.
@Annotación de Entity:
La descripción de la especificación EJB3 se incluye en el paquete Javax.Persistence, por lo que importamos este paquete como el primer paso. En segundo lugar, utilizamos la anotación @Entity para marcar esta clase como una clase de empleados de Entity Bean, por lo que debe tener un constructor sin parámetros, que finalmente es visible con la protección.
@Annotación de table:
La anotación @Table permite que la tabla especificada se use para mantener información detallada sobre la entidad en la base de datos.
La anotación @Table proporciona cuatro propiedades que permiten anular el nombre de la tabla, su directorio, su esquema y ejecutar restricciones únicas en las columnas de la tabla. Ahora, estamos usando el nombre de la tabla de empleados en este momento.
@ID y @GeneratedValue Anotaciones:
Cada entidad Bean tendrá una clave principal anotada en la anotación @ID de la clase. La clave primaria puede ser un solo campo o una combinación de múltiples campos de acuerdo con la estructura de la tabla.
De manera predeterminada, la anotación @ID determina automáticamente la estrategia de generación de clave primaria más apropiada para usar, pero puede usarse aplicando la anotación @GeneratedValue, que acepta dos parámetros, estrategia y generador, no para discutir aquí, solo use la estrategia de generación de clave predeterminada predeterminada. Permita que Hibernate determine el tipo de generador para usar para hacer la portabilidad del código entre diferentes bases de datos.
@Column Annotation:
La anotación @column se usa para especificar los detalles de la columna a un campo o propiedad que se asignará. Las siguientes propiedades más utilizadas se pueden anotar usando columnas:
El atributo de nombre permite especificar explícitamente el nombre de la columna.
La propiedad de longitud permite mapear el tamaño de una columna que es especialmente para un valor de cadena.
La propiedad anulable permite que la columna se marque no al generar el esquema.
La propiedad única permite las columnas marcadas como que contienen solo valores únicos.
Crear una clase de aplicación:
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar la aplicación. Usaremos esta aplicación para guardar algunos registros de empleados y luego solicitaremos registros en las operaciones de CRUD.
import java.util.list; import java.util.date; import java.util.iterator; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.cfg.annotationConfiguration; import org.hibernate.sessionFactory; import org.hibernate.cfg.configuration; public class Managementee {Factory de sesión estática privada; public static void main (string [] args) {try {factory = new AnnotationConfiguration (). configure (). //addpackage("com.xyz ") // Agregar paquete si se usa. AddAnnotatedClass (Empleado.Class). 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 (); / * Agregar pocos registros de empleados en la base de datos */ Integer Empid1 = me.addemployee ("Zara", "Ali", 1000); Integer empid2 = me.addemployee ("margarita", "das", 5000); Integer empid3 = me.addemployee ("John", "Paul", 10000); / * Enumere a todos los empleados */ me.listEmployee (); / * Actualizar los registros del empleado */ me.updateeMployee (Empid1, 5000); / * Eliminar a un empleado de la base de datos */ me.deleteEmployee (Empid2); / * Enumere la nueva lista de los empleados */ me.listEmployee (); } / * Método para crear un empleado en la base de datos * / public Integer AddEmployee (String fname, String lname, int salario) {session session = factory.opensession (); Transacción tx = nulo; Integer EmployeeId = NULL; intente {tx = session.beGinTransaction (); Empleado empleado empleado = nuevo empleado (); empleado.setFirstName (fname); empleado.setLastName (lname); empleado. Setsalary (salario); 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 leer todos 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 ()); } 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 (); }}} Configuración de la base de datos:
Ahora, creemos un archivo de configuración hibernate.cfg.xml para definir los parámetros relevantes de la base de datos.
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Hibernate-Configuration System "http://www.hibernate.org/dtd/Hibernate-Configuration-3.0.dtd"> <HiBernate-Configuration> <session-factory> <propiety name = "HiHBERNATET" org.hibernate.dialect.mysqldialect </propiety> <Property name = "Hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <!-Assume Students es el nombre de la base de datos-> <propiedad de propiedad = "HiBernate.connection.url"> JDBC: MySQL: // name = "Hibernate.Connection.Username"> root </Property> <Property Name = "Hibernate.Connection.Password"> Cohondob </property> </session-factory> </ hibernate-configuration>
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.
Eliminar el archivo de asignación de empleados.hbm.xml de la ruta.
Cree el archivo fuente de empleado.java como se muestra en la imagen de arriba y compilarlo.
Cree el archivo de origen ManagementEmploye.Java como se muestra en la imagen de arriba y compilarlo.
Ejecute el archivo binario ManagementEmployee para ejecutar el programa.
Se obtendrán los siguientes resultados y los registros estarán en la tabla de empleados.
$ Java Managementee ......... Varios mensajes de registro se mostrarán aquí ......... Nombre: Zara Apellido: Ali Salario: 1000First Nombre: Daisy Apellido: Das Salario: 5000FIRST Nombre: John Apellido: Paul Salario: 10000 Nombre: Zara Apellido: Ali Salario: 5000FIRST Nombre: Juan apellido: Salario: 10000
Si verifica la tabla de empleados, debe tener los siguientes registros:
mysql> select * de empleado;+----+------------+-----------+--------+| ID | First_Name | Last_Name | Salario |+----+------------+-----------+--------+| 29 | Zara | Ali | 5000 || 31 | John | Pablo | 10000 |+----+------------+-----------+--------+2 filas en el set (0.00 secmysql>
cache
El almacenamiento en caché se trata de la optimización del rendimiento de la aplicación y se encuentra entre la aplicación y la base de datos para evitar múltiples accesos de base de datos y permitir que las aplicaciones críticas de rendimiento funcionen mejor.
El almacenamiento en caché es importante para Hibernate, y adopta un esquema de almacenamiento en caché de varios niveles que se describe a continuación:
Cache de nivel 1:
El caché de primer nivel es el caché de sesión, que es un caché obligatorio, y todas las solicitudes a través de él deben aprobarse. Los objetos de la sesión están constantemente alimentados por objetos antes de enviarlos a la base de datos.
Si se emiten múltiples actualizaciones, Hibernate intenta retrasar las actualizaciones el mayor tiempo posible para reducir el número de actualizaciones emitidas por declaraciones SQL. Si cierra la sesión, todos los objetos almacenados en caché se perderán, ya sea persistentes o se actualizarán en la base de datos.
Cache de nivel 2:
El caché de nivel 2 es opcional y el caché de nivel 1 que siempre se buscará antes de cualquier intento de encontrar el caché de nivel 2 de un objeto. El caché de segundo nivel se puede configurar por clase y por categoría por categoría, principalmente responsables de los objetos almacenados en caché en la sesión.
Cualquier caché de terceros puede usar Hibernate. La interfaz org.hibernate.cache.cacheprovider proporciona, y es necesario implementar una implementación de caché de identificación para proporcionar Hibernate.
Cache de nivel de consulta:
Hibernate también implementa la estrecha integración de los resultados de los resultados de consulta caché y caché de nivel 2.
Esta es una característica opcional que requiere dos cachés físicos adicionales para guardar resultados de consultas en caché y regiones cuando se actualiza una tabla por última vez. Esto es muy útil para consultas que a menudo se ejecutan con los mismos parámetros.
Cache de nivel 2:
Hibernate usa caché de nivel 1, de forma predeterminada, no hace nada con el caché de nivel 1. Vamos directamente al caché opcional de segundo nivel. No todas las clases se benefician del almacenamiento en caché, por lo que es importante deshabilitar el caché de nivel 2.
Hibernate Level 2 El caché se establece en dos pasos. Primero, debe decidir qué estrategia de concurrencia usar. Después de esto, puede configurar la cadena de caché y usar caché para proporcionar atributos físicos de caché.
Estrategia de concurrencia:
Una política de concurrencia es un mediador responsable de almacenar elementos de datos en el caché y recuperarlos del caché. Si desea habilitar el almacenamiento en caché de Nivel 2, deberá decidir qué política de concurrencia de caché usar para cada clase y colección persistente.
Transaccional: el uso de esta estrategia para leer principalmente datos para evitar transacciones concurrentes de datos obsoletos es fundamental en casos raros de actualizaciones.
Ley-Write: nuevamente utilizando esta estrategia, la lectura principal de los datos es fundamental para evitar transacciones concurrentes de datos obsoletos en casos raros de actualizaciones.
Nonstrict-Read-Write: esta estrategia no garantiza la coherencia entre el caché y la base de datos. Con esta estrategia, la clave es no prestar atención si los datos rara vez se cambian y la posibilidad de datos obsoletos es obsoleto.
Solo lectura: la política de concurrencia es adecuada para datos y nunca cambiará. Los datos utilizados son solo para referencia.
Si queremos usar el caché de segundo nivel como clase de empleado, agregemos los elementos de mapeo necesarios para decirle a Hibernate que use una política de caché legible y escritable para instancias de los empleados.
<? 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> <cache usage="read-write"/> <id name="id" type="int" column="id"> <generator/> </id> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </class> </hibernate-mapping>
La propiedad de uso = "lectura-escritura" le dice a Hibernate que use un caché definido por una política de concurrencia de lectura-escritura.
Proveedor de caché:
Después de considerar la política de concurrencia de su clase candidata de caché, el siguiente paso es seleccionar un proveedor de caché. Fuerzas de hibernación seleccionando un caché para servir a toda la aplicación.
Cache proporcionado en el archivo de configuración Hibernate.cfg.xml especificado. Seleccione Ehcache como el proveedor de caché de segundo nivel:
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Hibernate-Configuration System "http://www.hibernate.org/dtd/Hibernate-Configuration-3.0.dtd"> <HiBernate-Configuration> <session-factory> <propiety name = "HiHBERNATET" org.hibernate.dialect.mysqldialect </propiety> <Property name = "Hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <!-Assume Students es el nombre de la base de datos-> <propiedad de propiedad = "HiBernate.connection.url"> JDBC: MySQL: // name = "Hibernate.Connection.Username"> root </property> <Property name = "Hibernate.Connection.Password"> root123 </property> <Property name = "hibernate.cache.provider_class"> org.hibernate.cache.ehcacheprovider </property <! Resource = "Empleado.hbm.xml"/> </session-factory> </hibernate-Configuration>
Ahora, debe especificar las propiedades del área de caché. Ehcache tiene su propio archivo de configuración ehcache.xml, en la aplicación en classpath. En ehcache.xml, la configuración de caché de clase de empleado puede verse así:
<<diskstore path = "java.io.TmpDir"/> <<defaultCacheCheMaMaxElementEsinMemory = "1000" eternal = "falso" timetoidleseConds = "120" timetoliveSeconds = "120" overflowtodisk = "true"/> <cajero cajero censificado name = "Empleado" MaxElementSInmemory = "500" Eternal = "True" TimetoidleseConds = "0" TimetoliveSeconds = "0" OverflowTodisk = "False"/>
Eso es todo, ahora habilita el caché secundario de la clase del empleado y Hibernate ahora tiene el caché secundario, cada vez que navega a un empleado o cuando el empleado es cargado por un identificador.
Debe analizar todas sus clases y seleccionar la estrategia de almacenamiento en caché adecuada para cada clase. A veces, el caché secundario puede degradar el rendimiento de la aplicación. Por lo tanto, se recomienda a la aplicación de referencia que no habilita el almacenamiento en caché por primera vez, lo cual es muy adecuado para el almacenamiento en caché y la verificación del rendimiento. Si el caché no mejora el rendimiento del sistema, no tiene sentido hacer cualquier tipo de caché.
Cache de nivel de consulta:
Usando la memoria caché de consultas, debe activarse primero en el archivo de configuración de la propiedad Hibernate.cache.use_query_cache = "true". Si esta propiedad se establece en True, permita que Hibernate cree el caché requerido en la memoria para guardar la consulta y el conjunto de identificadores.
A continuación, utilizando la caché de consultas, puede usar el método SetCachable (boolean) de la clase de consulta. Por ejemplo:
Hibernate también admite soporte de caché de grano muy fino a través del concepto de un área de caché. El caché es parte del caché dado un nombre.
Este código utiliza un método para decirle a Hibernate que almacene y encuentre consultas en los empleados en el caché.