Tópicos do Hibernate

O conteúdo é principalmente enfadonho e não há um entendimento real ainda.

definição:

Simplificando, a função do Hibernate é mapear classes Java para tabelas relacionais no banco de dados.

O Hibernate é um framework objeto-relacional de código aberto criado por Gavin King em 2001 . É poderoso e eficiente construir aplicativos Java com persistência de objeto relacional e serviços de consulta.

O Hibernate mapeia classes Java para tabelas de banco de dados, de tipos de dados Java a tipos de dados SQL, e libera os desenvolvedores de 95% da programação contínua de dados públicos.

O Hibernate é uma ponte entre objetos Java tradicionais e servidores de banco de dados para processar esses objetos com base em padrões e mecanismos de mapeamento O / R.

Definição do Baidu : Hibernate é um framework de mapeamento objeto-relacional de código aberto, que encapsula objetos JDBC muito leves. Ele estabelece uma relação de mapeamento entre POJOs e tabelas de banco de dados. É um framework ORM totalmente automático que pode ser gerado automaticamente pelo hibernate. executado automaticamente, permitindo que os programadores Java usem o pensamento de programação de objetos para manipular o banco de dados como quiserem. O Hibernate pode ser usado em qualquer ocasião em que JDBC seja usado, tanto em programas cliente Java ou em aplicações Web Servlet / JSP.

ORM: Object Relation Mapping (inglês: Object Relation Mapping, ORM para abreviar, ou O / RM, ou mapeamento O / R), é um tipo de tecnologia de programação usada para realizar os dados entre diferentes tipos de sistemas em linguagens de programação orientadas a objetos Conversão.

Arquitetura e etapas de desenvolvimento:

O Hibernate usa o banco de dados e os dados de configuração para fornecer serviços contínuos para os aplicativos.

Arquitetura:

Abaixo está uma visão de alto nível da arquitetura do aplicativo Hibernate.

Abaixo está uma visão detalhada da arquitetura do aplicativo Hibernate e algumas classes importantes.

Etapas de desenvolvimento:

1. Crie uma classe persistente
2. Criar arquivo de mapeamento objeto-relacional
3. Criar arquivo de configuração do Hibernate
4. Escreva o código para acessar o banco de dados através da API Hibernate
   

Sessão em Hibernate

A sessão é usada para obter uma conexão física com o banco de dados. O objeto Session é leve e projetado para ser instanciado toda vez que precisar interagir com o banco de dados. O objeto persistente é salvo e recuperado por meio do objeto Session.

Os objetos Session não devem permanecer abertos por muito tempo, porque geralmente não podem garantir a segurança do thread e devem ser criados e destruídos conforme necessário. A principal função da Sessão é fornecer operações de criação, leitura e exclusão para instâncias de classes de entidade mapeadas. Essas instâncias podem existir em um dos três estados a seguir em um determinado momento:

1. Estado transiente: Uma nova instância persistente, considerada pelo Hibernate como instantânea, não está associada à Sessão, não há nenhum registro associado a ela no banco de dados e nenhum valor de identificador.
2. Estado persistente: uma instância de estado transiente pode ser transformada em uma instância de estado persistente ao ser associada a uma Sessão. A instância de estado persistente não tem nenhum registro associado a ela no banco de dados, tem um valor de identificador e está associada a uma Sessão.
3. Estado desconectado: Assim que a Sessão do Hibernate for fechada, a instância de estado persistente se tornará a instância de estado não gerenciado.

Classes persistentes no Hibernate

O conceito completo do Hibernate é extrair os valores nas propriedades da classe Java e salvá-los no formulário de banco de dados . O arquivo de mapeamento pode ajudar o Hibernate a determinar como extrair valores da classe e mapeá-los em tabelas e campos relacionados.

No Hibernate, as classes Java cujos objetos ou instâncias serão armazenados em formulários de banco de dados são chamadas de classes persistentes. Se esta classe seguir algumas regras simples ou o conhecido modelo de programação Plain Old Java Object (POJO) , o Hibernate estará em seu melhor estado de execução. A seguir estão as principais regras da classe de persistência, no entanto, nenhuma dessas regras são requisitos rígidos.

1. Todas as classes Java que serão persistidas precisam de um construtor padrão.
2. Para que o objeto seja facilmente identificado no Hibernate e no banco de dados, todas as classes precisam conter um ID. Este atributo é mapeado para a coluna de chave primária da tabela do banco de dados.
3. Todas as propriedades que serão persistidas devem ser declaradas como privadas e ter os métodos getXXX e setXXX definidos pelo estilo JavaBean.
4. Um recurso importante do Hibernate é o proxy, que depende se a classe de persistência não é final ou está em uma
   interface onde todos os métodos são declarados como públicos .
5. Todas as classes são classes e interfaces especiais que não são extensíveis ou implementadas de acordo com os requisitos EJB . (?)

Exemplos de classes 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;
   }
}

Relação de mapeamento do Hibernate:

1. Mapeamento de coleção

2. Mapeamento de associação

3. Mapeamento de componentes

Status do objeto Hibernate:

O estado do objeto no Hibernate: estado temporário / transitório, estado persistente, estado livre .

1. 
   Características de status temporário :
   objetos novos diretamente;
   não está sob gerenciamento de sessão;
   nenhum registro de objeto no banco de dados;
2. Estado persistente
   Ao chamar os métodos save / saveOrUpdate / get / load / list da sessão, o objeto é o estado persistente.
   Objetos em um estado persistente serão refletidos no banco de dados quando as propriedades do objeto são alteradas!
   Características:
   no gerenciamento de sessão,
   há registros correspondentes no banco de dados;
3. 
   Recursos de estado livre
   Não no gerenciamento de sessão,
   há um registro correspondente no banco de dados
   após o encerramento da sessão, o estado do objeto;

Exemplos de aplicativos do Hibernate:

1. Crie a classe POJO (parece semelhante ao 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. Crie uma tabela relacional no banco de dados (pode não ser necessariamente uma tabela relacional, mas atualmente aprendo apenas bancos de dados relacionais)

Parece ser um banco de dados mysql. Não o pratiquei especificamente, mas não deve ser difícil construir uma tabela.

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. Crie um arquivo de configuração de mapeamento

<?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. O documento de mapeamento é um documento no formato XML que tem como elemento raiz, esse elemento contém todos os elementos.
2. Elementos são usados ​​para definir mapeamentos específicos de classes Java para tabelas de banco de dados. O nome da classe Java é específico, ele usa o
   atributo name do elemento de classe, e o nome da tabela do banco de dados também é específico, ele usa o atributo table.
3. O elemento é um elemento opcional que pode ser usado para criar uma descrição da classe.
4. O elemento mapeia um atributo de ID específico na classe para a tabela de chave principal do banco de dados. O atributo name do elemento id se refere aos atributos na classe e o atributo column se refere às colunas na tabela do banco de dados. O atributo type controla o tipo de mapeamento de hibernação, que será transferido do tipo de dados Java para SQL.
5. Os elementos no elemento id são usados ​​para gerar automaticamente o valor da palavra-chave principal. Defina o atributo de classe do elemento gerador como nativo para que o Hibernate possa usar a identidade, sequência ou algoritmo hilo para criar as principais palavras-chave com base no desempenho do banco de dados subjacente.
6. Elementos são usados ​​para mapear os atributos de uma classe Java para colunas na tabela de banco de dados. O atributo name deste elemento está relacionado aos atributos da classe e o atributo column está relacionado às colunas da tabela de dados. O atributo type controla o tipo de mapeamento do Hibernate, que será transferido do tipo de dados Java para SQL.

4. Crie uma classe de aplicativo

Parece semelhante ao Dao. JavaBean armazena objetos de classe e seus atributos. Dao é responsável por manipular o banco de dados.

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(); 
      }
   }
}

Referência: Exemplos de Hibernate
Referência: Hibernate Detalhado