Caché hibernado
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:
Sesión session = sessionFactory.opensession (); Query Query = Session.CreateQuery ("De Empleado"); Query.SetCachable (true); List Users = Query.List (); SessionFactory.Closessession ();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.
Sesión session = sessionFactory.Opensession (); Query Query = Session.CreateQuery ("De Empleado"); Query.SetCacheable (verdadero); Query.SetCacheregion ("Empleado"); List Users = Query.List (); SessionFactory.Clossessession ();Este código utiliza un método para decirle a Hibernate que almacene y encuentre consultas en los empleados en el caché.
SQL nativo hibernado
Puede usar SQL nativo para expresar consultas de bases de datos. Si desea utilizar funciones específicas de la base de datos, como indicaciones de consulta o conectar palabras clave en Oracle. Hibernate3.x permite el uso de declaraciones SQL escritas a mano, incluidos los procedimientos almacenados, todas las operaciones de creación, actualización, eliminación y carga.
La aplicación creará una consulta SQL nativa (en la interfaz de sesión) desde el método de sesión createSQLQuery ():
Public SQLQuery CreateSQLQuery (String SQLString) lanza HibernateException
Al pasar una consulta SQL al método CreateSQLQuery (), puede usar el método Addentity () asociado con cualquier entidad Hibernate existente, o un resultado escalar utilizando el método Addentity (), AddJoin () y AddScalar ().
Consulta escalar:
La consulta SQL más básica es obtener una lista de escalares (valores numéricos) de una o más tablas. Estos son los valores de la sintaxis utilizando los escalares SQL nativos:
String sql = "Seleccione First_Name, Salario de Empleado"; SqlQuery Query = Session.CreateSQLQuery (SQL); Query.SetResultTransformer (criteria.alias_to_entity_map); Lista de resultados = query.list ();
Consulta de la entidad:
Las consultas anteriores todos devuelven los valores escalares, es decir, los datos "desnudos" devueltos desde el conjunto de resultados. La siguiente es la sintaxis para obtener objetos de entidad en su conjunto de la consulta SQL nativa a través del método Addentity ().
String sql = "select * de empleado"; sqlQuery Query = session.createsqlQuery (sql); query.AddEntity (empleado.class); list resultados = query.list ();
Se llama consulta SQL:
La siguiente es la sintaxis para obtener objetos de entidad de consultas SQL nativas y usar consultas SQL con nombre a través del método Addentity ().
String sql = "select * de empleado donde id =: empleado_id"; sqlquery query = session.createSqlQuery (sql); query.addentity (empleado.class); query.setParameter ("Empleado_id", 10); Lista de resultados = Query.list (); Ejemplo de SQL nativo:
Considere la siguiente clase POJO:
Empleado de clase pública {private int id; cadena privada FirstName; cadena privada lastname; salario privado int; 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; }}Creemos la siguiente tabla de empleados para almacenar el objeto del empleado:
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));
Los siguientes se asignarán archivos.
<? 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" column = "Last_name" type = "String"/> <Property name = "salary" column = "salary type =" int "/> <class> <</class> </hibber
Finalmente, crearemos el método Main () de la clase de aplicación para ejecutar, y utilizaremos aplicaciones de consulta SQL nativa:
import java.util.*; importar org.hibernate.HibernateException; importar org.hibernate.session; importar org.hibernate.transaction; import org.hibernate.sessionFactory; import org.hibernate.sqlQuery; import. 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 (); / * Agregar pocos registros de empleados en la base de datos */ Integer Empid1 = me.addemployee ("Zara", "Ali", 2000); Integer empid2 = me.addemployee ("margarita", "das", 5000); Integer empid3 = me.addemployee ("John", "Paul", 5000); Integer empid4 = me.addemployee ("mohd", "yasee", 3000); / * Enumere a los empleados y su salario utilizando consulta escalar */ me.listEmployEessCalar (); / * Enumere la información completa de los empleados utilizando la consulta de entidad */ me.listEmployEessEntity (); } / * 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 (fname, lname, 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 a todos los empleados usando consulta escalar * / public void listEmployeSsCalar () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Cadena sql = "seleccione First_Name, Salario del Empleado"; SQLQuery Query = Session.CreateSqlQuery (SQL); query.setResultTransformer (criteria.alias_to_entity_map); Lista de datos = query.list (); for (objeto objeto: data) {map row = (map) objeto; System.out.print ("Nombre:" + Row.get ("First_Name")); System.out.println (", salario:" + row.get ("salario")); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para leer a todos los empleados utilizando la consulta de entidad * / public void listEmployEessEntity () {session session = factory.opensession (); Transacción tx = nulo; intente {tx = session.beGinTransaction (); Cadena sql = "seleccionar * de empleado"; SQLQuery Query = Session.CreateSqlQuery (SQL); query.addentity (empleado.class); Lista de empleados = query.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 (); }}} 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.
Ejecute el archivo binario ManagementEmployee para ejecutar el programa.
Se obtendrán los siguientes resultados y el registro se creará en la tabla de empleados.
$ Java ManagementEmployee
......... MOHD Apellido: Yasee Salario: 3000
Si verifica la tabla de empleados, debe registrar que tiene:
mysql> select * de empleado;
+----------------------------------+----------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------