Temas de hibernación

El contenido es en su mayoría aburrido y aún no hay una comprensión real.

definición:

En pocas palabras, el papel de Hibernate es mapear clases de Java a tablas relacionales en la base de datos.

Hibernate es un marco relacional de objetos de código abierto creado por Gavin King en 2001 . Es poderoso y eficiente construir aplicaciones Java con persistencia de objetos relacionales y servicios de consulta.

Hibernate asigna clases de Java a tablas de bases de datos, desde tipos de datos Java a tipos de datos SQL, y libera a los desarrolladores del 95% de la programación continua de datos públicos.

Hibernate es un puente entre los objetos tradicionales de Java y los servidores de bases de datos para procesar esos objetos según los mecanismos y patrones de mapeo O / R.

Definición de Baidu : Hibernate es un marco de mapeo relacional de objetos de código abierto, que encapsula objetos JDBC muy livianos. Establece una relación de mapeo entre POJOs y tablas de base de datos. Es un marco ORM completamente automático que puede ser generado automáticamente por hibernación. Las sentencias SQL son se ejecuta automáticamente, lo que permite a los programadores de Java utilizar el pensamiento de programación de objetos para manipular la base de datos a su gusto. Hibernate se puede utilizar en cualquier ocasión en la que se utilice JDBC, ya sea en programas cliente Java o en aplicaciones Web Servlet / JSP.

ORM: Object Relation Mapping (inglés: Object Relation Mapping, ORM para abreviar, o O / RM, o mapeo O / R), es un tipo de tecnología de programación utilizada para realizar los datos entre diferentes tipos de sistemas en lenguajes de programación orientados a objetos. Conversión.

Pasos de arquitectura y desarrollo:

Hibernate utiliza la base de datos y los datos de configuración para proporcionar servicios continuos para las aplicaciones.

Arquitectura:

A continuación se muestra una vista de muy alto nivel de la arquitectura de la aplicación Hibernate.

A continuación se muestra una vista detallada de la arquitectura de la aplicación Hibernate y algunas clases importantes.

Pasos de desarrollo:

1. Crea una clase persistente
2. Crear archivo de mapeo relacional de objetos
3. Crear archivo de configuración de Hibernate
4. Escriba código para acceder a la base de datos a través de la API de Hibernate
   

Sesión en Hibernate

La sesión se utiliza para obtener una conexión física a la base de datos. El objeto Session es ligero y está diseñado para instanciarse cada vez que necesite interactuar con la base de datos. El objeto persistente se guarda y recupera mediante el objeto Session.

Los objetos de sesión no deben permanecer abiertos durante mucho tiempo, ya que generalmente no pueden garantizar la seguridad de los subprocesos y deben crearse y destruirse según sea necesario. La función principal de Session es proporcionar operaciones de creación, lectura y eliminación para instancias de clases de entidad mapeadas. Estas instancias pueden existir en uno de los siguientes tres estados en un momento dado:

1. Estado transitorio: una nueva instancia persistente, considerada por Hibernate como instantánea, no está asociada con la sesión, no hay ningún registro asociado con ella en la base de datos y ningún valor identificador.
2. Estado persistente: una instancia de estado transitorio se puede transformar en una instancia de estado persistente al asociarse con una sesión. La instancia de estado persistente no tiene ningún registro asociado en la base de datos, tiene un valor de identificador y está asociada con una sesión.
3. Estado desconectado: una vez que se cierra la sesión de Hibernate, la instancia de estado persistente se convertirá en la instancia de estado no administrado.

Clases persistentes en Hibernate

El concepto completo de Hibernate es extraer los valores en las propiedades de la clase Java y guardarlos en el formulario de la base de datos . El archivo de mapeo puede ayudar a Hibernate a determinar cómo extraer valores de la clase y mapearlos en tablas y campos relacionados.

En Hibernate, las clases de Java cuyos objetos o instancias se almacenarán en formularios de bases de datos se denominan clases persistentes. Si esta clase sigue algunas reglas simples o el conocido modelo de programación Plain Old Java Object (POJO) , Hibernate estará en su mejor estado de ejecución. Las siguientes son las reglas principales de la clase de persistencia, sin embargo, ninguna de estas reglas es un requisito estricto.

1. Todas las clases de Java que se conservarán necesitan un constructor predeterminado.
2. Para que el objeto se pueda identificar fácilmente en Hibernate y en la base de datos, todas las clases deben contener una ID. Este atributo se asigna a la columna de clave principal de la tabla de la base de datos.
3. Todas las propiedades que se conservarán deben declararse como privadas y tener métodos getXXX y setXXX definidos por el estilo JavaBean.
4. Una característica importante de Hibernate es el proxy, que depende de si la clase de persistencia es no final o en una
   interfaz donde todos los métodos se declaran como públicos .
5. Todas las clases son clases e interfaces especiales que no son extensibles ni implementadas de acuerdo con los requisitos de EJB . (?)

Ejemplos de clases persistentes:

public class Employee {
    
    
   private int id;//主键(ID)
   private String firstName; //类似JavaBean
   private String lastName;   
   private int salary;  

   public Employee() {
    
    //默认构造函数
      firstName=null;
      lastName=null;
      salary =0;
   }
   public Employee(String fname, String lname, int salary) {
    
    
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   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() {
    
    
      return salary;
   }
   public void setSalary( int salary ) {
    
    
      this.salary = salary;
   }
}

Relación de mapeo de hibernación:

1. Mapeo de la colección

2. Mapeo de asociaciones

3. Mapeo de componentes

Estado del objeto de hibernación:

El estado del objeto en Hibernate: estado temporal / transitorio, estado persistente, estado libre .

1. 
   Funciones de estado temporal :
   objetos directamente nuevos,
   no bajo gestión de sesiones,
   no hay registros de objetos en la base de datos;
2. Estado persistente
   Al llamar a los métodos save / saveOrUpdate / get / load / list de la sesión, el objeto es el estado persistente.
   ¡Los objetos en estado persistente se reflejarán en la base de datos cuando se modifiquen las propiedades del objeto!
   Características:
   en la gestión de sesiones,
   hay registros correspondientes en la base de datos;
3. 
   Características del estado libre
   No en la gestión de sesiones,
   hay un registro correspondiente en la base de datos
   después de que se cierra la sesión, el estado del objeto;

Ejemplos de aplicaciones de Hibernate:

1. Cree la clase POJO (se siente similar a JavaBean)

public class Employee {
    
    
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {
    
    }
   public Employee(String fname, String lname, int salary) {
    
    
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   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() {
    
    
      return salary;
   }
   public void setSalary( int salary ) {
    
    
      this.salary = salary;
   }
}

2. Cree una tabla relacional en la base de datos (puede que no sea necesariamente una tabla relacional, pero actualmente solo aprendo bases de datos relacionales)

Parece ser una base de datos mysql, no la he practicado específicamente, pero no debería ser difícil construir una tabla.

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

3. Cree un archivo de configuración de mapeo

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name="Employee" table="EMPLOYEE">
      <meta attribute="class-description">
         This class contains the employee detail. 
      </meta>
      <id name="id" type="int" column="id">
         <generator class="native"/>
      </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>

1. El documento de mapeo es un documento en formato XML que tiene como elemento raíz, este elemento contiene todos los elementos.
2. Los elementos se utilizan para definir asignaciones específicas de clases Java a tablas de bases de datos. El nombre de la clase Java es específico, usa el
   atributo de nombre del elemento de clase y el nombre de la tabla de la base de datos también es específico, usa el atributo de tabla.
3. El elemento es un elemento opcional que se puede utilizar para crear una descripción de la clase.
4. El elemento asigna un atributo de ID específico en la clase a la tabla de claves principal de la base de datos. El atributo de nombre del elemento id se refiere a los atributos de la clase y el atributo de columna se refiere a las columnas de la tabla de la base de datos. El atributo type domina el tipo de mapeo de hibernación, que se transferirá del tipo de datos Java a SQL.
5. Los elementos del elemento id se utilizan para generar automáticamente el valor de la palabra clave principal. Establezca el atributo de clase del elemento generador en nativo para que Hibernate pueda usar la identidad, la secuencia o el algoritmo hilo para crear las palabras clave principales en función del rendimiento de la base de datos subyacente.
6. Los elementos se utilizan para asignar los atributos de una clase Java a las columnas de la tabla de la base de datos. El atributo de nombre de este elemento se relaciona con los atributos de la clase y el atributo de columna se relaciona con las columnas de la tabla de datos. El atributo type controla el tipo de mapeo de Hibernate, que será transferido de Java a tipo de datos SQL.

4. Crea una clase de aplicación

Se siente similar a Dao. JavaBean almacena objetos de clase y sus atributos. Dao es responsable de manipular la base de datos.

import java.util.List; 
import java.util.Date;
import java.util.Iterator; 

import org.hibernate.HibernateException; 
import org.hibernate.Session; 
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
    
    
   private static SessionFactory factory; 
   public static void main(String[] args) {
    
    
      try{
    
    
         factory = new Configuration().configure().buildSessionFactory();
      }catch (Throwable ex) {
    
     
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 10000);

      /* List down all the employees */
      ME.listEmployees();

      /* Update employee's records */
      ME.updateEmployee(empID1, 5000);

      /* Delete an employee from the database */
      ME.deleteEmployee(empID2);

      /* List down new list of the employees */
      ME.listEmployees();
   }
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
    
    
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      try{
    
    
         tx = session.beginTransaction();
         Employee employee = new Employee(fname, lname, salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      }catch (HibernateException e) {
    
    
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      }finally {
    
    
         session.close(); 
      }
      return employeeID;
   }
   /* Method to  READ all the employees */
   public void listEmployees( ){
    
    
      Session session = factory.openSession();
      Transaction tx = null;
      try{
    
    
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list(); 
         for (Iterator iterator = 
                           employees.iterator(); iterator.hasNext();){
    
    
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      }catch (HibernateException e) {
    
    
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      }finally {
    
    
         session.close(); 
      }
   }
   /* Method to UPDATE salary for an employee */
   public void updateEmployee(Integer EmployeeID, int salary ){
    
    
      Session session = factory.openSession();
      Transaction tx = null;
      try{
    
    
         tx = session.beginTransaction();
         Employee employee = 
                    (Employee)session.get(Employee.class, EmployeeID); 
         employee.setSalary( salary );
         session.update(employee); 
         tx.commit();
      }catch (HibernateException e) {
    
    
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      }finally {
    
    
         session.close(); 
      }
   }
   /* Method to DELETE an employee from the records */
   public void deleteEmployee(Integer EmployeeID){
    
    
      Session session = factory.openSession();
      Transaction tx = null;
      try{
    
    
         tx = session.beginTransaction();
         Employee employee = 
                   (Employee)session.get(Employee.class, EmployeeID); 
         session.delete(employee); 
         tx.commit();
      }catch (HibernateException e) {
    
    
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      }finally {
    
    
         session.close(); 
      }
   }
}

Referencia: Ejemplos de Hibernate
Referencia: Hibernate Detallado