1. El ciclo de vida del objeto persistente
Después de que la aplicación use el marco Hibernate, los objetos persistentes creados por la aplicación pasarán por un conjunto completo de ciclos de vida para completar las operaciones de la base de datos, entre los cuales los tres estados principales son transitorios, persistencia y separados. Las transiciones de estos tres estados se pueden controlar en la aplicación, como se muestra en la figura a continuación:
Para comprender claramente estos estados, aquí hay un ejemplo para ver las diferencias entre los objetos en estos estados. Los siguientes códigos en los Estados son los siguientes:
(1) Cree un ensamblaje Hibernate_Session y agregue un paquete JAR correspondiente;
(2) Configure Hibernate, agregue la clase de usuario de entidad correspondiente y sus archivos de mapeo, y configure la conexión de base de datos correspondiente;
Archivo de mapeo de archivo de clase de usuario user.hbm.xml Código:
<? xml versión = "1.0"?> < -> <hibernate-mapping> <class name = "com.hibernate.user"> <id name = "id"> <generador/> </id> <propiedad name = "name"/> <propiedad name = "contraseña"/> <propiedad name = "createTime"/> <Property name = "expireMime"/> </scalase> </bercernate-mapping>
Código de configuración de conexión de la base de datos Hibernate:
<? xml versión = "1.0" encoding = "utf-8"?> < <Sessionfactory> <Property name = "Hibernate.Connection.driver_class"> com.mysql.jdbc.driver </propiedad> <propiedad name = "hibernate.connection.url"> jdbc: mysql: // localhost: 3306/hibernate_session </propiedad> <product name = "HiBernate.connection.ConnectioneMeMe <property name="hibernate.connection.password">ab12</property> <!-- dialect:Dialect, the encapsulated underlying API, similar to Runtime, converts the database into the corresponding language in the configuration--> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <mapping Resource = "com/hibernate/user.hbm.xml"/> </session-factory> </hibernate-configuration>
(3) Agregue una clase pública del miembro estático SessionFactory para crear una SessionFactory y su objeto de sesión;
paquete com.Hibernate; importar org.hibernate.session; importar org.hibernate.sessionFactory; importar org.hibernate.cfg.configuration; Sesión de clase pública {fábrica privada de sesión de sesión estática; // Declarar la variable local estática SessionFactory, Mirror de la base de datos Static {try {// Cree y obtenga el archivo de configuración para la base de datos de configuración, y obtenga hibernate.cfg.xml Configuración cfg = nueva configuración (). Configuración (); fábrica = cfg.BuildSessionFactory (); // construir una imagen de base de datos} capt (excepción e) {e.printstackTrace (); // Mensaje de error de impresión}} Sesión estática pública getSession () {return factory.opensession (); // devuelve el objeto de sesión creado} public sessionFactory getSessionFactory () {return fábrica; // Devuelve el SessionFactory correspondiente} // Cerrar el objeto de sesión Public static void closesession (sesión de sesión) {if (session! = Null) {if (session.isopen ()) {session.close (); }}}}}(4) Agregue una carpeta de origen y agregue un paquete llamado com.Hibernate en la carpeta y agregue un archivo de clase llamado SessionTest al paquete.
paquete com.Hibernate; import java.util.date; import junit.framework.testcase; importar org.hibernate.session; importar org.hibernate.transaction; Public Class Sessiontest extiende TestCase {} 2. Método de conversión de estado
1. El objeto ingresa directamente al estado persistente
1.1 Get Method
Obtenga una fila de información de la base de datos y sincronice la información en el objeto creado. Este método devuelve un objeto de objeto y devuelve nulo si no se encuentra contenido. El siguiente ejemplo utiliza el método Get Session para obtener un objeto y convertir el objeto en una instancia.
public void testget1 () {session session = null; Transacción tx = nulo; intente {session = hibernateUtils.getSession (); // Abrir transacción tx = session.begintransaction (); // El objeto cargado por GET es un objeto persistente // ejecutar para emitir una instrucción de consulta inmediatamente, y si no existe, devolverá usuarios de usuario nulo = (usuario) session.get (user.class, "ff80808145bc28cc0145bc28ce020002"); System.out.println (user.getName ()); // Estado persistente // Objeto con cambios de estado persistentes cuando cambian las propiedades del objeto // Hibernate sincronizará user.setName ("zhao liu"); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); if (tx! = null) {tx.rollback (); }} finalmente {hibernateUtils.clossessession (sesión); }} Establezca puntos de interrupción para obtener el objeto de usuario.
Se obtiene este objeto y se obtiene un objeto de usuario después de la fundición. El método SetName se agrega al programa, lo que significa que se actualizará el nombre en la base de datos. Después de completar la ejecución, se verificará la base de datos, como se muestra en la figura a continuación para actualizar los resultados.
1.2 Método de carga
La función es similar al método GET, y también obtiene datos de la base de datos y lo sincroniza en el objeto. Este método admite operación perezosa. Devuelve un objeto persistente o un proxy, por lo que debe convertirse.
public void testLoad1 () {session session = null; intente {session = hibernateUtils.getSession (); // La instrucción de consulta no se verificará de inmediato porque la carga admite lazy (carga de retraso/carga perezosa) // ¿Qué enseñar perezoso? Solo cuando este objeto se use realmente y luego se cree, se emitirá la declaración de consulta para Hibernate. Es principalmente para mejorar el rendimiento. Lazy es una característica muy importante en Hibernate. ¿Cómo se implementa el vago de Hibernate? Implementado por objetos proxy. Los objetos de proxy usan principalmente // generados por la biblioteca CGLIB en lugar del proxy dinámico de JDK, porque el proxy dinámico de JDK solo puede generar proxy para las clases que implementan excusas. CGLIB puede generar // proxy para clases. Adopta el método de herencia user usuario = (usuario) session.load (user.class, "8A1B653745BCC7B50145BCC7B7B7140001"); System.out.println (user.getName ()); // Estado persistente // Objetos con estado persistente, cuando las propiedades del objeto cambian // Hibernate sincronizará user.setName ("zhaoliu"); session.getTransaction (). Commit (); } catch (Exception e) {E.PrintStackTrace (); } finalmente {hibernateUtils.clossessession (sesión); }} Consulta para obtener el objeto de usuario como se muestra en la figura a continuación:
Analizando la figura anterior, el objeto de usuario obtenido no está completo, o no hay objeto de usuario común, pero es un proxy. Utiliza CGLIB para precargar el objeto y solo se crea realmente cuando se usa el objeto.
1.3 Get VS Load
Los métodos de obtener y carga son muy importantes. A menudo se toman durante las entrevistas con Hibernate. La siguiente es una comparación de los siguientes dos.
Similitudes:
(1) Las funciones son las mismas, y los datos de la relación se convierten en objetos;
(2) El método de uso es el mismo, y también se requieren dos diferencias en los parámetros:
(1) El método de carga admite operación perezosa, precarga el objeto y se crea solo cuando se usa. Obtener directamente convierte los datos relacionales en objetos;
(2) Si el objeto de carga de carga no existe, se lanzará ObjectNotFoundException, y si Get no obtiene los datos, devolverá nulo.
2. Construya manualmente objetos separados
Hay otro método para obtener un objeto. Es diferente de los métodos Get and Load. Es un método manual. Primero, un objeto es común, y luego los datos del objeto se obtienen formulando una ID. El método es el siguiente:
public void testuer () {session session = null; intente {session = hibernateUtils.getSession (); session.BeginTransaction (); // construye manualmente el usuario de ObjectUser separado = new User (); user.setID ("8A1B653745BCC7B50145BCC7B7B7140001"); // Estado persistente // Objeto con estado persistente, cuando cambian las propiedades del objeto // Hibernate sincronizará session.getTransaction (). Commit () con la base de datos al limpiar el caché (verificación de datos sucios); } catch (Exception e) {E.PrintStackTrace (); } finalmente {hibernateUtils.clossessession (sesión); }} Ver el diagrama de resultados obtenido:
El diagrama de resultados de análisis se usa en el código para establecer el número de identificación del objeto. Después de formular el número de identificación, el objeto se puede operar. Después de enviar la transacción, se sincroniza con la base de datos, y la especificación manual se utiliza para especificar manualmente la información del objeto.
2.1 Método de eliminación
Para eliminar el objeto especificado en la base de datos, el objeto debe convertirse al estado persistente antes de eliminarlo. Puede usar métodos Get, Load o Manual para especificar el objeto. El método es el siguiente:
sesión = hibernateUtils.getSession (); session.BeginTransaction (); Usuario user = (usuario) session.load (user.class, "8a1b653745bcc6d50145bcc6d67a0001"); // se recomienda usar este método para eliminar, cargar primero y luego eliminar session.delete (usuario);
2.2 Actualización
Actualizar los datos, este método modificará los datos en la base de datos. Al usarlo, habrá una situación en la cantidad, que actualizará el valor de un cierto campo en la base de datos o actualizará la fila completa de la base de datos.
2.2.1 Actualizar un valor de campo
Si solo desea actualizar el valor de un cierto campo, antes de actualizar, debe usar la carga o convertir el objeto en un código de estado persistente de la siguiente manera:
// Get Session Object Session = HibernateUtils.getSession (); // Abrir transacción session.BeginTransaction (); // o puede usar otro método para habilitar //session.getTransaction (). Begin (); // Cargar para obtener el objeto de usuario // Método 1: Use el método de carga // usuario de usuario = (usuario) session.load (user.class, "8a1b653745bcc7b50145bcc7b7b7140001"); // Método 2: Obtener manualmente el usuario de usuario = nuevo usuario (); user.setID ("8A1B653745BCC7B50145BCC7B7B7140001"); // actualizar el nombre user.setName ("zhangsan"); session.update (usuario); session.getTransaction (). Commit ();2.2.2 Actualice toda la línea <Br /> Si desea actualizar los datos de toda la línea, puede convertir manualmente el estado en el estado separado y especificar manualmente el valor de identificación del objeto. El código es el siguiente:
// Get Session Object Session = HibernateUtils.getSession (); // Abrir transacción session.BeginTransaction (); // o puede usar otro método para habilitar //session.getTransaction (). Begin (); // Obtener manualmente user usuario = nuevo usuario (); user.setID ("8A1B653745BCC7B50145BCC7B7B7140001"); // actualizar el nombre user.setName ("zhangsan"); session.update (usuario); session.getTransaction (). Commit (); Ver resultados de actualización:
Al analizar los resultados de la actualización, en realidad actualiza la fila completa de datos de la base de datos. Hay demasiadas incertidumbres en esta operación de actualización y no se recomienda usarla.
2.3 Método de guardado
Insertar datos. Al ejecutar el método Guardar, se llama a la instrucción Insertar la base de datos para agregar una nueva fila a la base de datos. El objeto guardado se convertirá en estado persistente. En este estado, el objeto puede actualizar el objeto nuevamente y se actualizará a la base de datos con cambios cuando finalmente se envíe la transacción. como sigue:
public void testSave2 () {session session = null; Transacción tx = nulo; intente {session = hibernateUtils.getSession (); // Abrir transacción tx = session.begintransaction (); // Estado transitorio usuario user = new User (); user.setName ("zhangsi"); user.setPassword ("123"); user.setCreateTime (nueva fecha ()); user.setExpireTime (nueva fecha ()); // Estado persistente // Objeto con cambios de estado persistentes cuando cambian las propiedades del objeto // Hibernate sincronizará session.save (usuario); user.setName ("lisi"); tx.commit (); } catch (Exception e) {E.PrintStackTrace (); if (tx! = null) {tx.rollback (); }} finalmente {hibernateUtils.clossessession (sesión); } // estado separado} Ver el ejemplo anterior Ejecutar la vista de resultados:
Resultado del análisis: la sesión en realidad realiza dos operaciones al enviar la transacción. Combinado con el proceso de actualización en el código, en primer lugar, se agrega un nuevo objeto de usuario y luego se ejecuta una operación de guardado. Llamará a la instrucción Insertar, luego se realiza una operación SetName en el código y el nombre se vuelve a modificar. Sin embargo, no se ha sincronizado con la base de datos en este momento, pero está en la memoria. En este momento, habrá dos estados. Decimos que los bits de datos en este momento son datos sucios y finalmente se actualizan a la base de datos al enviar la transacción.