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完成。