[关闭]
@yudesong 2018-02-17T06:51:57.000000Z 字数 9886 阅读 586

Hibernate 简介

Hibernate

Hibernate 是由 Gavin King 于 2001 年创建的开放源代码的对象关系框架。它强大且高效的构建具有关系对象持久性和查询服务的 Java 应用程序。Hibernate 将Java类映射到数据表中从Java 数据类型中映射到 SQL 数据类型中，并把开发人员从 95%的公共数据持续性编程工作中解放出来。

Hibernate 优势

Hibernate 应用程序架构视图


下面是一个详细的 Hibernate 应用程序体系结构视图以及一些重要的类。

  1. 配置对象
    配置对象是你在任何 Hibernate 应用程序中创造的第一个 Hibernate 对象，并且经常只在应用程序初始化期间创造。它代表了 Hibernate 所需一个配置或属性文件。配置对象提供了两种基础组件。

    • 数据库连接：由 Hibernate 支持的一个或多个配置文件处理。这些文件是 hibernate.properties 和 hibernate.cfg.xml。
    • 类映射设置：这个组件创造了 Java 类和数据库表格之间的联系。

  2. SessionFactory 对象
    配置对象被用于创造一个 SessionFactory 对象，使用提供的配置文件为应用程序依次配置 Hibernate，并允许实例化一个会话对象。SessionFactory 是一个线程安全对象并由应用程序所有的线程所使用。
    SessionFactory 是一个重量级对象所以通常它都是在应用程序启动时创造然后留存为以后使用。每个数据库需要一个 SessionFactory 对象使用一个单独的配置文件。所以如果你使用多种数据库那么你要创造多种 SessionFactory 对象。

  3. Session 对象
    一个会话被用于与数据库的物理连接。Session 对象是轻量级的，并被设计为每次实例化都需要与数据库的交互。持久对象通过 Session 对象保存和检索。
    Session 对象不应该长时间保持开启状态因为它们通常情况下并非线程安全，并且它们应该按照所需创造和销毁。

  4. Transaction 对象
    一个事务代表了与数据库工作的一个单元并且大部分 RDBMS 支持事务功能。在 Hibernate 中事务由底层事务管理器和事务（来自 JDBC 或者 JTA）处理。
    这是一个选择性对象，Hibernate 应用程序可能不选择使用这个接口，而是在自己应用程序代码中管理事务。

  5. Query 对象
    Query 对象使用 SQL 或者 Hibernate 查询语言（HQL）字符串在数据库中来检索数据并创造对象。一个查询的实例被用于连结查询参数，限制由查询返回的结果数量，并最终执行查询。

  6. Criteria 对象
    Criteria 对象被用于创造和执行面向规则查询的对象来检索对象。

会话

Session 用于获取与数据库的物理连接。 Session 对象是轻量级的，并且设计为在每次需要与数据库进行交互时被实例化。持久态对象被保存，并通过 Session 对象检索找回。

该 Session 对象不应该长时间保持开放状态，因为它们通常不能保证线程安全，而应该根据需求被创建和销毁。Session 的主要功能是为映射实体类的实例提供创建，读取和删除操作。这些实例可能在给定时间点时存在于以下三种状态之一：

  1. Session session = factory.openSession();
  2. Transaction tx = null;
  3. try {
  4.    tx = session.beginTransaction();
  5.    // do some work
  6.    ...
  7.    tx.commit();
  8. }
  9. catch (Exception e) {
  10.    if (tx!=null) tx.rollback();
  11.    e.printStackTrace(); 
  12. }finally {
  13.    session.close();
  14. }

持久化类

在 Hibernate 中，其对象或实例将会被存储在数据库表单中的 Java 类被称为持久化类。

  1. public class Employee {
  2.    private int id;
  3.    private String firstName; 
  4.    private String lastName;   
  5.    private int salary;  
  7.    public Employee() {}
  8.    public Employee(String fname, String lname, int salary) {
  9.       this.firstName = fname;
  10.       this.lastName = lname;
  11.       this.salary = salary;
  12.    }
  13.    public int getId() {
  14.       return id;
  15.    }
  16.    public void setId( int id ) {
  17.       this.id = id;
  18.    }
  19.    public String getFirstName() {
  20.       return firstName;
  21.    }
  22.    public void setFirstName( String first_name ) {
  23.       this.firstName = first_name;
  24.    }
  25.    public String getLastName() {
  26.       return lastName;
  27.    }
  28.    public void setLastName( String last_name ) {
  29.       this.lastName = last_name;
  30.    }
  31.    public int getSalary() {
  32.       return salary;
  33.    }
  34.    public void setSalary( int salary ) {
  35.       this.salary = salary;
  36.    }
  37. }

映射文件

一个对象/关系型映射一般定义在 XML 文件中。映射文件指示 Hibernate 如何将已经定义的类或类组与数据库中的表对应起来。
Employee.hbm.xml

  1. create table EMPLOYEE (
  2.     id INT NOT NULL auto_increment,
  3.     first_name VARCHAR(20) default NULL,
  4.     last_name  VARCHAR(20) default NULL,
  5.     salary     INT  default NULL,
  6.     PRIMARY KEY (id)
  7. );
  9. <?xml version="1.0" encoding="utf-8"?>
  10. <!DOCTYPE hibernate-mapping PUBLIC 
  11.  "-//Hibernate/Hibernate Mapping DTD//EN"
  12.  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  14. <hibernate-mapping>
  15.    <class name="Employee" table="EMPLOYEE">
  16.       <meta attribute="class-description">
  17.          This class contains the employee detail. 
  18.       </meta>
  19.       <id name="id" type="int" column="id">
  20.          <generator class="native"/>
  21.       </id>
  22.       <property name="firstName" column="first_name" type="string"/>
  23.       <property name="lastName" column="last_name" type="string"/>
  24.       <property name="salary" column="salary" type="int"/>
  25.    </class>
  26. </hibernate-mapping>

hibernate.cfg.xml

  1. <?xml version='1.0' encoding='UTF-8'?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
  8.         <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
  9.         <property name="connection.username">root</property>
  10.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  11.         <property name="show_sql">true</property>
  12.         <property name="hibernate.hbm2ddl.auto">update</property>
  13.         <mapping resource="com/hibernate/User.hbm.xml"/>
  14.     </session-factory>
  15. </hibernate-configuration>

操作数据库

  1. public class ManageEmployee {
  2.    private static SessionFactory factory; 
  3.    public static void main(String[] args) {
  4.       try{
  5.          factory = new Configuration().configure().buildSessionFactory();
  6.       }catch (Throwable ex) { 
  7.          System.err.println("Failed to create sessionFactory object." + ex);
  8.          throw new ExceptionInInitializerError(ex); 
  9.       }
  10.       ManageEmployee ME = new ManageEmployee();
  12.       /* Add few employee records in database */
  13.       Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
  14.       Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
  15.       Integer empID3 = ME.addEmployee("John", "Paul", 10000);
  17.       /* List down all the employees */
  18.       ME.listEmployees();
  20.       /* Update employee's records */
  21.       ME.updateEmployee(empID1, 5000);
  23.       /* Delete an employee from the database */
  24.       ME.deleteEmployee(empID2);
  26.       /* List down new list of the employees */
  27.       ME.listEmployees();
  28.    }
  29.    /* Method to CREATE an employee in the database */
  30.    public Integer addEmployee(String fname, String lname, int salary){
  31.       Session session = factory.openSession();
  32.       Transaction tx = null;
  33.       Integer employeeID = null;
  34.       try{
  35.          tx = session.beginTransaction();
  36.          Employee employee = new Employee(fname, lname, salary);
  37.          employeeID = (Integer) session.save(employee); 
  38.          tx.commit();
  39.       }catch (HibernateException e) {
  40.          if (tx!=null) tx.rollback();
  41.          e.printStackTrace(); 
  42.       }finally {
  43.          session.close(); 
  44.       }
  45.       return employeeID;
  46.    }
  47.    /* Method to  READ all the employees */
  48.    public void listEmployees( ){
  49.       Session session = factory.openSession();
  50.       Transaction tx = null;
  51.       try{
  52.          tx = session.beginTransaction();
  53.          List employees = session.createQuery("FROM Employee").list(); 
  54.          for (Iterator iterator = 
  55.                            employees.iterator(); iterator.hasNext();){
  56.             Employee employee = (Employee) iterator.next(); 
  57.             System.out.print("First Name: " + employee.getFirstName()); 
  58.             System.out.print("  Last Name: " + employee.getLastName()); 
  59.             System.out.println("  Salary: " + employee.getSalary()); 
  60.          }
  61.          tx.commit();
  62.       }catch (HibernateException e) {
  63.          if (tx!=null) tx.rollback();
  64.          e.printStackTrace(); 
  65.       }finally {
  66.          session.close(); 
  67.       }
  68.    }
  69.    /* Method to UPDATE salary for an employee */
  70.    public void updateEmployee(Integer EmployeeID, int salary ){
  71.       Session session = factory.openSession();
  72.       Transaction tx = null;
  73.       try{
  74.          tx = session.beginTransaction();
  75.          Employee employee = 
  76.                     (Employee)session.get(Employee.class, EmployeeID); 
  77.          employee.setSalary( salary );
  78.          session.update(employee); 
  79.          tx.commit();
  80.       }catch (HibernateException e) {
  81.          if (tx!=null) tx.rollback();
  82.          e.printStackTrace(); 
  83.       }finally {
  84.          session.close(); 
  85.       }
  86.    }
  87.    /* Method to DELETE an employee from the records */
  88.    public void deleteEmployee(Integer EmployeeID){
  89.       Session session = factory.openSession();
  90.       Transaction tx = null;
  91.       try{
  92.          tx = session.beginTransaction();
  93.          Employee employee = 
  94.                    (Employee)session.get(Employee.class, EmployeeID); 
  95.          session.delete(employee); 
  96.          tx.commit();
  97.       }catch (HibernateException e) {
  98.          if (tx!=null) tx.rollback();
  99.          e.printStackTrace(); 
  100.       }finally {
  101.          session.close(); 
  102.       }
  103.    }
  104. }

注释

  1. @Entity
  2. @Table(name = "EMPLOYEE")
  3. public class Employee {
  4.    @Id @GeneratedValue
  5.    @Column(name = "id")
  6.    private int id;
  8.    @Column(name = "first_name")
  9.    private String firstName;
  11.    @Column(name = "last_name")
  12.    private String lastName;
  14.    @Column(name = "salary")
  15.    private int salary;  
  17.    public Employee() {}
  18.    public int getId() {
  19.       return id;
  20.    }
  21.    public void setId( int id ) {
  22.       this.id = id;
  23.    }
  24.    public String getFirstName() {
  25.       return firstName;
  26.    }
  27.    public void setFirstName( String first_name ) {
  28.       this.firstName = first_name;
  29.    }
  30.    public String getLastName() {
  31.       return lastName;
  32.    }
  33.    public void setLastName( String last_name ) {
  34.       this.lastName = last_name;
  35.    }
  36.    public int getSalary() {
  37.       return salary;
  38.    }
  39.    public void setSalary( int salary ) {
  40.       this.salary = salary;
  41.    }
  42. }

创建应用类

  1. public class ManageEmployee {
  2.    private static SessionFactory factory; 
  3.    public static void main(String[] args) {
  4.       try{
  5.          factory = new AnnotationConfiguration().
  6.                    configure().
  7.                    //addPackage("com.xyz") //add package if used.
  8.                    addAnnotatedClass(Employee.class).
  9.                    buildSessionFactory();
  10.       }catch (Throwable ex) { 
  11.          System.err.println("Failed to create sessionFactory object." + ex);
  12.          throw new ExceptionInInitializerError(ex); 
  13.       }
  14.       ManageEmployee ME = new ManageEmployee();
  16.       /* Add few employee records in database */
  17.       Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
  18.       Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
  19.       Integer empID3 = ME.addEmployee("John", "Paul", 10000);
  21.       /* List down all the employees */
  22.       ME.listEmployees();
  24.       /* Update employee's records */
  25.       ME.updateEmployee(empID1, 5000);
  27.       /* Delete an employee from the database */
  28.       ME.deleteEmployee(empID2);
  30.       /* List down new list of the employees */
  31.       ME.listEmployees();
  32.    }
  33.    /* Method to CREATE an employee in the database */
  34.    public Integer addEmployee(String fname, String lname, int salary){
  35.       Session session = factory.openSession();
  36.       Transaction tx = null;
  37.       Integer employeeID = null;
  38.       try{
  39.          tx = session.beginTransaction();
  40.          Employee employee = new Employee();
  41.          employee.setFirstName(fname);
  42.          employee.setLastName(lname);
  43.          employee.setSalary(salary);
  44.          employeeID = (Integer) session.save(employee); 
  45.          tx.commit();
  46.       }catch (HibernateException e) {
  47.          if (tx!=null) tx.rollback();
  48.          e.printStackTrace(); 
  49.       }finally {
  50.          session.close(); 
  51.       }
  52.       return employeeID;
  53.    }
  54.    /* Method to  READ all the employees */
  55.    public void listEmployees( ){
  56.       Session session = factory.openSession();
  57.       Transaction tx = null;
  58.       try{
  59.          tx = session.beginTransaction();
  60.          List employees = session.createQuery("FROM Employee").list(); 
  61.          for (Iterator iterator = 
  62.                            employees.iterator(); iterator.hasNext();){
  63.             Employee employee = (Employee) iterator.next(); 
  64.             System.out.print("First Name: " + employee.getFirstName()); 
  65.             System.out.print("  Last Name: " + employee.getLastName()); 
  66.             System.out.println("  Salary: " + employee.getSalary()); 
  67.          }
  68.          tx.commit();
  69.       }catch (HibernateException e) {
  70.          if (tx!=null) tx.rollback();
  71.          e.printStackTrace(); 
  72.       }finally {
  73.          session.close(); 
  74.       }
  75.    }
  76.    /* Method to UPDATE salary for an employee */
  77.    public void updateEmployee(Integer EmployeeID, int salary ){
  78.       Session session = factory.openSession();
  79.       Transaction tx = null;
  80.       try{
  81.          tx = session.beginTransaction();
  82.          Employee employee = 
  83.                     (Employee)session.get(Employee.class, EmployeeID); 
  84.          employee.setSalary( salary );
  85.          session.update(employee); 
  86.          tx.commit();
  87.       }catch (HibernateException e) {
  88.          if (tx!=null) tx.rollback();
  89.          e.printStackTrace(); 
  90.       }finally {
  91.          session.close(); 
  92.       }
  93.    }
  94.    /* Method to DELETE an employee from the records */
  95.    public void deleteEmployee(Integer EmployeeID){
  96.       Session session = factory.openSession();
  97.       Transaction tx = null;
  98.       try{
  99.          tx = session.beginTransaction();
  100.          Employee employee = 
  101.                    (Employee)session.get(Employee.class, EmployeeID); 
  102.          session.delete(employee); 
  103.          tx.commit();
  104.       }catch (HibernateException e) {
  105.          if (tx!=null) tx.rollback();
  106.          e.printStackTrace(); 
  107.       }finally {
  108.          session.close(); 
  109.       }
  110.    }
  111. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注