Hibernate 快速上手操作入門

本文主要是從技術操作角度去介紹hibernate，並且簡單描述如何快速的上手操作hibernate，用於作為與數據庫的連接的持久層。

簡單講述一下hibernate究竟是什么，它有什么作用，在理解它的作用之前，我們先想一想，在一個項目當中，我們需要將項目當中的數據存入數據庫，或者從數據庫中讀取項目當中需要的數據進行操作，我們往常一般使用什么方法呢？首先想到的就是通過JDBC去對數據庫進行手動的操作，編寫一個連接數據庫的模塊，通過加載driver並且手動編寫增刪改查方法聯通程序與數據庫當中的數據，這種方式很繁瑣，並且在對不同的表格操作的時候，還需要手動修改SQL語句，與我們面向對象編程的設計思想不符，於是提出了ORM。

所謂的ORM（Object ralational mapping）是一種為了解決面向對象與關系型數據庫存在的互不匹配的現象的技術，簡單說：ORM是通過使用描述對象和數據庫之間映射的元數據，將Java程序中的對象自動持久化到關系數據中。即將數據庫表當中的一行數據，轉化到java當中的某個pojo類的實例，本質上就是將數據從一種形式轉換到另外一種形式。

從圖中的每層之間的關系也可以很直觀的看出，本文所介紹的Hibernate主要就是用於做持久層，並且提供ORM的重要組件。

通過Hibernate，我們將對象轉換存入數據庫，或者反向將數據從數據庫提取生成對象就無需再手動編寫jdbc的增刪改查並且向對象填入字段的代碼模塊，在建立好orm映射之后，我們只需要操作我們所定義的pojo類，並且使用Hibernate提供的方法即可將pojo對象存入對應的數據庫當中，無需關注實現細節，便於簡化編程。

在理解什么是orm，並且知道Hibernate在我們編程當中所扮演的角色以及所提供的作用之后，我們開始來了解如何使用Hibernate來實現我們的程序持久層，本文采用的是hibernate 5.1版本對mysql數據進行連接，進行demo演示，首先創建一個java project，並且將hibernate根目錄下的 /lib/required 文件夾下的所有jar包引入工程，並且再將 /lib/java8 目錄下的jar包引入工程當中，除此之外，因為要與mysql數據庫進行連接，還需要提供mysql數據庫連接的驅動jar包mysql-connector-java-5.1.26-bin.jar，將這些包都引入並且build the path之后，我們的工程環境就搭建完成。

在通過hibernate去進行ORM的時候，一般的設計流程為Domain Object ->mapping ->DB：

1.需要連接的pojo類對象的設計，這個部分的設計根據所需要實現的程序的功能去進行，比如需要做一個用戶信息的統計程序，那么就肯定需要一個名為User的Pojo類，並且該Pojo類里頭需要定義用戶的屬性，如：姓名，性別，年齡等。

2.需要配置的pojo.hbm.xml配置文件，作為類向關系型的映射，即提供pojo類到數據庫某張表的對應映射信息。

3.在包外配置hibernate.cfg.xml配置文件，其中Sesson-factory作為連接數據庫信息的配置。

如同上述的設計思路流程，首先我們先設計我們的pojo類，就以用戶信息為例，代碼如下：

package wellhold.hibernate.domain;

import java.util.Date;

public class User {
    
    private int id;
    private String name;
    private Date birthday;

    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", birthday=" + birthday
                + "]";
    }

}

在這里需要額外提示一下，根據筆者查閱的資料當中，大部分人都表示在hibernate因為反射機制的需求，所定義的pojo類需要有一個空白無參數的構造函數才能對對象進行反射，但是筆者在制作測試demo的時候，將這個空白的構造函數進行去除之后，程序還是沒有任何問題，所以這個空白構造函數的必須性還有待商議。

在設計好pojo類之后，我們需要建立對象到數據庫的映射關系，即hbm.xml配置文件的建立，如下：

<?xml version="1.0"?>
<!-- ~ Hibernate, Relational Persistence for Idiomatic Java ~ ~ License: 
    GNU Lesser General Public License (LGPL), version 2.1 or later. ~ See the 
    lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- -->

<hibernate-mapping package="wellhold.hibernate.domain">

    <class name="User">
        <!-- 當類名和表明一樣的時候，table="" 這個關鍵字不需要寫 -->

        <id name="id">
            <!-- name指的是屬性名，即java類里頭的屬性 -->
            <!-- 有一次屬性名unsaved-value="-1" 指的是如果ID的值為-1的時候則表示這個對象未保存 -->

            <generator class="native" />
            <!-- 主鍵產生的方式，其中native是主鍵生成器 -->

        </id>

        <property name="name" />
        <property name="birthday" />

    </class>

</hibernate-mapping>

hibernate會根據我們提供的這個hbm.xml去建立User這個Pojo類與數據庫當中User這張表的映射關系。

之后我們需要對全局的hibernate進行配置，通過.cfg.xml對hibernate進行配置，包括提供所需要連接的數據庫信息，以及一些功能參數的設定，session-factory的設置，注意在hibernate當中，對數據庫的所有操作都是通過SessionFactory進行的，所以SessionFactory是一個很重要的概念，可以理解成是一個對jdbc進行更上一層封裝的對象。

<?xml version='1.0' encoding='utf-8'?>
<!-- ~ Hibernate, Relational Persistence for Idiomatic Java ~ ~ License: 
    GNU Lesser General Public License (LGPL), version 2.1 or later. ~ See the 
    lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. -->
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql:///testconnect</property>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 使用方言，用於在Sql語句的設計上是存在差異的 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 在不存在表格的情況，自動在數據庫生成表格 -->
        <property name="show_sql">false</property>
        <!-- 顯示Hibernate底層調用的SQL -->
        <mapping resource="wellhold/hibernate/domain/User.hbm.xml" />

        <!-- 在數據庫當中自動生成表格 -->

    </session-factory>

</hibernate-configuration>

至此，hibernate的映射環境就已經構建完成，接下來我們通過編寫測試用例去進行測試我們所搭建的hibernate是否可以正常工作。

一般在使用Hibernate，我們可以先對原生的Hibernate提供的一些方法進行更高一層的封裝，比如Hibernate的SessionFactory所提供的sava方法，update方法，delete方法，get方法，制作一個Hibernate的工具類，代碼如下：

package wellhold.hibernate;

import java.io.Serializable;

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

public final class HibernateUtil {

    private static SessionFactory sessionFactory;

    static {
        Configuration cfg = new Configuration();
        cfg.configure("hibernate.cfg.xml");
        sessionFactory = cfg.buildSessionFactory();
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static Session getSession() {
        return sessionFactory.openSession();
    }

    public static void add(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.save(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void Update(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.update(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static void delete(Object entity) {
        Session s = null;
        Transaction tx = null;
        try {
            s = HibernateUtil.getSession();
            tx = s.beginTransaction();
            s.delete(entity);
            tx.commit();
        } finally {
            if (s != null)
                s.close();
        }
    }

    public static Object get(Serializable id) {
        Session s = null;

        try {
            s = HibernateUtil.getSession();

            Object obj = s.get(User.class, id);
            return obj;

        } finally {
            if (s != null)
                s.close();
        }
    }

}

在HibernateUtil當中，通過一個static塊去加載了hibernate.cfg.xml配置文件，並且獲取到sessionfactory實例，之后是對增刪改查的封裝。這里簡單的解釋一下為什么使用的都是static的方法生命，因為在使用static的方法的時候，可以無需對HibernateUtil對象進行實例，就可以使用其靜態的方法。

最后，我們只需要制作一個程序入口，即main函數，測試HibernateUtil當中的方法即可：

package wellhold.hibernate;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import wellhold.hibernate.domain.User;

public class maintest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        User user = new User();
        user.setBirthday(new Date());
        user.setName("well");
        
        HibernateUtil.add(user);
        System.out.println("end");
        System.out.println(HibernateUtil.get(1).toString());
    }
    
//    
    
}

查看效果：

 

至此，Hibernate快速入門demo完成。