走進JavaWeb技術世界13：Hibernate入門經典與註解式開發

轉載自Hibernate入門這一篇就夠了

前言

本博文主要講解介紹Hibernate框架，ORM的概念和Hibernate入門，相信大家看了就會使用Hibernate了!

什麼是Hibernate框架？

Hibernate是一種ORM框架，全稱爲 Object_Relative DateBase-Mapping，在Java對象與關係數據庫之間創建某種映射，以實現直接存取Java對象！

爲何要使用Hibernate？

既然Hibernate是關於Java對象和關係數據庫之間的聯繫的話，也就是咱們MVC中的數據持久層->在編寫程序中的DAO層...

首先，咱們來回顧一下咱們在DAO層寫程序的歷程吧：

1. 在DAO層操做XML，將數據封裝到XML文件上，讀寫XML文件數據實現CRUD
2. 在DAO層使用原生JDBC鏈接數據庫，實現CRUD
3. 嫌棄JDBC的ConnectionStatementResultSet等對象太繁瑣，使用對原生JDBC的封裝組件-->DbUtils組件

咱們來看看使用DbUtils以後，程序的代碼是怎麼樣的：

public class CategoryDAOImpl implements zhongfucheng.dao.CategoryDao {

    @Override
    public void addCategory(Category category) {

        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "INSERT INTO category (id, name, description) VALUES(?,?,?)";
        try {
            queryRunner.update(sql, new Object[]{category.getId(), category.getName(), category.getDescription()});

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Category findCategory(String id) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
        String sql = "SELECT * FROM category WHERE id=?";

        try {
            Category category = (Category) queryRunner.query(sql, id, new BeanHandler(Category.class));

            return category;

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }

    }

    @Override
    public List<Category> getAllCategory() {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
        String sql = "SELECT * FROM category";

        try {
            List<Category> categories = (List<Category>) queryRunner.query(sql, new BeanListHandler(Category.class));

            return categories;
        } catch (SQLException e) {
            throw  new RuntimeException(e);
        }

    }
}

其實使用DbUtils時，DAO層中的代碼編寫是頗有規律的。

• 當插入數據的時候，就將JavaBean對象拆分，拼裝成SQL語句
• 當查詢數據的時候，用SQL把數據庫表中的列組合，拼裝成JavaBean對象

也就是說：javaBean對象和數據表中的列存在映射關係!若是程序可以自動生成SQL語句就行了....那麼Hibernate就實現了這個功能！

簡單來講：咱們使用Hibernate框架就不用咱們寫不少繁瑣的SQL語句，從而簡化咱們的開發！

• • *

ORM概述

在介紹Hibernate的時候，說了Hibernate是一種ORM的框架。那什麼是ORM呢？ORM是一種思想

• O表明的是Objcet
• R表明的是Relative
• M表明的是Mapping

ORM->對象關係映射....ORM關注是對象與數據庫中的列的關係

• • *

Hibernate快速入門

學習一個框架無非就是三個步驟：

• 引入jar開發包
• 配置相關的XML文件
• 熟悉API

引入相關jar包

咱們使用的是Hibernate3.6的版本

hibernate3.jar核心 + required 必須引入的(6個) + jpa 目錄 + 數據庫驅動包

編寫對象和對象映射

編寫一個User對象->User.java

public class User {

    private int id;
    private String username;
    private String password;
    private String cellphone;

    //各類setter和getter
}

編寫對象映射->User.hbm.xml。通常它和JavaBean對象放在同一目錄下

咱們是不知道該XML是怎麼寫的，能夠搜索一下Hibernate文件夾中後綴爲.hbm.xml。看看它們是怎麼寫的。而後複製一份過來

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

<!-- 

  This mapping demonstrates content-based discrimination for the
  table-per-hierarchy mapping strategy, using a formula
  discriminator.

-->

<hibernate-mapping 
    package="org.hibernate.test.array">

    <class name="A" lazy="true" table="aaa">

        <id name="id">
            <generator class="native"/>
        </id>

        
            <key column="a_id"/>
            <list-index column="idx"/>
            <one-to-many class="B"/>
        

    </class>

    <class name="B" lazy="true" table="bbb">
        <id name="id">
            <generator class="native"/>
        </id>
    </class>

</hibernate-mapping>

• 在上面的模板上修改～下面會具體講解這個配置文件!

<!--在domain包下-->
<hibernate-mapping package="zhongfucheng.domain">

    <!--類名爲User，表名也爲User-->
    <class name="User"  table="user">

        <!--主鍵映射，屬性名爲id，列名也爲id-->
        <id name="id" column="id">
            <!--根據底層數據庫主鍵自動增加-->
            <generator class="native"/>

        </id>

        <!--非主鍵映射，屬性和列名一一對應-->
        <property name="username" column="username"/>
        <property name="cellphone" column="cellphone"/>
        <property name="password" column="password"/>
    </class>
</hibernate-mapping>

主配置文件

hibernate.cfg.xml

若是使用Intellij Idea生成的Hibernate能夠指定生成出主配置文件hibernate.cfg.xml，它是要放在src目錄下的

若是不是自動生成的，咱們能夠在Hibernate的hibernate-distribution-3.6.0.Final\project\etc這個目錄下能夠找到

它長得這個樣子：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.url."/>
        <property name="connection.driver_class"/>
        <property name="connection.username"/>
        <property name="connection.password"/>
        <!-- DB schema will be updated if needed -->
        <!-- <property name="hbm2ddl.auto">update</property> -->
    </session-factory>
</hibernate-configuration>

經過上面的模板進行修改，後面會有對該配置文件進行講解！

<hibernate-configuration>
    <!-- 一般，一個session-factory節點表明一個數據庫 -->
    <session-factory>

        <!-- 1\. 數據庫鏈接配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///zhongfucheng</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <!--
            數據庫方法配置， hibernate在運行的時候，會根據不一樣的方言生成符合當前數據庫語法的sql
         -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- 2\. 其餘相關配置 -->
        <!-- 2.1 顯示hibernate在運行時候執行的sql語句 -->
        <property name="hibernate.show_sql">true</property>
        <!-- 2.2 格式化sql -->
        <property name="hibernate.format_sql">true</property>
        <!-- 2.3 自動建表  -->
        <property name="hibernate.hbm2ddl.auto">create</property>

        <!--3\. 加載全部映射-->
        <mapping resource="zhongfucheng/domain/User.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

測試

package zhongfucheng.domain;

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

/**
 * Created by ozc on 2017/5/6.
 */
public class App {
    public static void main(String[] args) {

        //建立對象
        User user = new User();
        user.setPassword("123");
        user.setCellphone("122222");
        user.setUsername("nihao");

        //獲取加載配置管理類
        Configuration configuration = new Configuration();

        //不給參數就默認加載hibernate.cfg.xml文件，
        configuration.configure();

        //建立Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //獲得Session對象
        Session session = factory.openSession();

        //使用Hibernate操做數據庫，都要開啓事務,獲得事務對象
        Transaction transaction = session.getTransaction();

        //開啓事務
        transaction.begin();

        //把對象添加到數據庫中
        session.save(user);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }
}

值得注意的是：JavaBean的主鍵類型只能是int類型，由於在映射關係中配置是自動增加的，String類型是不能自動增加的。若是是你設置了String類型，又使用了自動增加，那麼就會報出下面的錯誤！

Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'zhongfucheng.user' does

執行完程序後，Hibernate就爲咱們建立對應的表，並把數據存進了數據庫了

• • *

咱們看看快速入門案例的代碼用到了什麼對象吧，而後一個一個講解

public static void main(String[] args) {

        //建立對象
        User user = new User();
        user.setPassword("123");
        user.setCellphone("122222");
        user.setUsername("nihao");

        //獲取加載配置管理類
        Configuration configuration = new Configuration();

        //不給參數就默認加載hibernate.cfg.xml文件，
        configuration.configure();

        //建立Session工廠對象
        SessionFactory factory = configuration.buildSessionFactory();

        //獲得Session對象
        Session session = factory.openSession();

        //使用Hibernate操做數據庫，都要開啓事務,獲得事務對象
        Transaction transaction = session.getTransaction();

        //開啓事務
        transaction.begin();

        //把對象添加到數據庫中
        session.save(user);

        //提交事務
        transaction.commit();

        //關閉Session
        session.close();
    }

Configuration

配置管理類：主要管理配置文件的一個類

它擁有一個子類AnnotationConfiguration，也就是說：咱們可使用註解來代替XML配置文件來配置相對應的信息

configure方法

configure()方法用於加載配置文件

• 加載主配置文件的方法

  • 若是指定參數，那麼加載參數的路徑配置文件
  • 若是不指定參數，默認加載src/目錄下的hibernate.cfg.xml
• • *

buildSessionFactory方法

buildSessionFactory()用於建立Session工廠

• • *

SessionFactory

SessionFactory-->Session的工廠，也能夠說表明了hibernate.cfg.xml這個文件...hibernate.cfg.xml的就有<session-factory>這麼一個節點

openSession方法

建立一個Session對象

getCurrentSession方法

建立Session對象或取出Session對象

• • *

Session

Session是Hibernate最重要的對象，Session維護了一個鏈接（Connection），只要使用Hibernate操做數據庫，都須要用到Session對象

一般咱們在DAO層中都會有如下的方法，Session也爲咱們提供了對應的方法來實現！

public interface IEmployeeDao {

    void save(Employee emp);
    void update(Employee emp);
    Employee findById(Serializable id);
    List<Employee> getAll();
    List<Employee> getAll(String employeeName);
    List<Employee> getAll(int index, int count);
    void delete(Serializable id);

}

• • *

更新操做

咱們在快速入門中使用到了save(Objcet o)方法，調用了這個方法就把對象保存在數據庫之中了。Session對象還提供着其餘的方法來進行對數據庫的更新

• session.save(obj); 【保存一個對象】
• session.update(obj); 【更新一個對象】

• session.saveOrUpdate(obj); 【保存或者更新的方法】

  • 沒有設置主鍵，執行保存；
  • 有設置主鍵，執行更新操做;
  • 若是設置主鍵不存在報錯！

咱們來使用一下update()方法吧....既然是更新操做了，那麼確定須要設置主鍵的，不設置主鍵，數據庫怎麼知道你要更新什麼。將id爲1的記錄修改爲以下：

user.setId(1);
        user.setPassword("qwer");
        user.setCellphone("1111");
        user.setUsername("zhongfucheng");

• • *

主鍵查詢

經過主鍵來查詢數據庫的記錄，從而返回一個JavaBean對象

• session.get(javaBean.class, int id); 【傳入對應的class和id就能夠查詢】
• session.load(javaBean.class, int id); 【支持懶加載】

User重寫toString()來看一下效果：

User user1 = (User) session.get(User.class, 1);
        System.out.println(user1);

• • *

HQL查詢

HQL:hibernate query language 即hibernate提供的面向對象的查詢語言

• 查詢的是對象以及對象的屬性【它查詢的是對象以及屬性，所以是區分大小寫的！】。

SQL：Struct query language 結構化查詢語言

• 查詢的是表以及列【不區分大小寫】

HQL是面向對象的查詢語言，能夠用來查詢所有的數據！

Query query = session.createQuery("FROM User");

        List list = query.list();
        System.out.println(list);

固然啦，它也能夠傳遞參數進去查詢

Query query = session.createQuery("FROM User WHERE id=?");

        //這裏的？號是從0開始的，並不像JDBC從1開始的！
        query.setParameter(0, user.getId());

        List list = query.list();
        System.out.println(list);

• • *

QBC查詢

QBC查詢: query by criteria 徹底面向對象的查詢

從上面的HQL查詢，咱們就能夠發現：HQL查詢是須要SQL的基礎的，由於仍是要寫少部分的SQL代碼....QBC查詢就是徹底的面向對象查詢...可是呢，咱們用得比較少

咱們來看一下怎麼使用吧：

//建立關於user對象的criteria對象
        Criteria criteria = session.createCriteria(User.class);

        //添加條件
        criteria.add(Restrictions.eq("id", 1));

        //查詢所有數據
        List list = criteria.list();
        System.out.println(list);

• • *

本地SQL查詢

有的時候，若是SQL是很是複雜的，咱們不能靠HQL查詢來實現功能的話，咱們就須要使用原生的SQL來進行復雜查詢了！

可是呢，它有一個缺陷：它是不能跨平臺的...所以咱們在主配置文件中已經配置了數據庫的「方言「了。

咱們來簡單使用一下把：

//將全部的記錄封裝成User對象存進List集合中
        SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM user").addEntity(User.class);

        List list = sqlQuery.list();

        System.out.println(list);

beginTransaction方法

開啓事務，返回的是一個事務對象....Hibernate規定全部的數據庫操做都必須在事務環境下進行，不然報錯！

Hibernate註解開發

在Hibernate中咱們通常都會使用註解，這樣能夠幫助咱們大大簡化hbm映射文件的配置。下面我就來爲你們詳細介紹。

PO類註解配置

首先確定是搭建好Hibernate的開發環境啦，我在此也不過多贅述，讀者自行實踐。接着在src目錄下建立一個cn.itheima.domain包，並在該包下建立一個Book實體類，因爲Book實體類中寫有註解配置，因此就不用編寫那個映射配置文件啦！

@Entity // 定義了一個實體
@Table(name="t_book",catalog="hibernateTest")
public class Book {

    @Id // 這表示一個主鍵
    // @GeneratedValue 至關於native主鍵生成策略
    @GeneratedValue(strategy=GenerationType.IDENTITY) // 至關於identity主鍵生成策略
    private Integer id; // 主鍵

    @Column(name="c_name", length=30, nullable=true)
    private String name;

    @Temporal(TemporalType.TIMESTAMP) // 是用來定義日期類型
    private Date publicationDate; // 出版日期

    @Type(type="double") // 容許你去指定Hibernate裏面的一些類型
    private Double price; // 價格，若是沒有添加註解，也會自動的生成在表中

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getPublicationDate() {
        return publicationDate;
    }
    public void setPublicationDate(Date publicationDate) {
        this.publicationDate = publicationDate;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44

下面我就來詳細說一下Book實體類中的註解。

• @Entity：聲明一個實體。

• @Table：來描述類與表之間的對應關係。

  @Entity // 定義了一個實體
  @Table(name="t_book",catalog="hibernateTest")
  public class Book {
      ......
  }

  • 1
  • 2
  • 3
  • 4
  • 5
• @id：聲明一個主鍵。

• @GeneratedValue：用它來聲明一個主鍵生成策略。默認狀況是native主鍵生成策略。能夠選擇的主鍵生成策略有：AUTO、IDENTITY、SEQUENCE。

  @Id // 這表示一個主鍵
  // @GeneratedValue 至關於native主鍵生成策略
  @GeneratedValue(strategy=GenerationType.IDENTITY) // 至關於identity主鍵生成策略
  private Integer id; // 主鍵

  • 1
  • 2
  • 3
  • 4

• @Column：定義列。

  @Column(name="c_name", length=30, nullable=true)
  private String name;

  • 1
  • 2

**注意：對於PO類中全部屬性，若是你不寫註解，默認狀況下也會在表中生成對應的列，列的名稱就是屬性的名稱，列的類型也即屬性的類型**。

• @Temporal：聲明日期類型。

  @Temporal(TemporalType.TIMESTAMP) // 是用來定義日期類型
  private Date publicationDate; // 出版日期

  • 1
  • 2

日期類型能夠選擇的有：

*   TemporalType.DATA：只有年月日。
*   TemporalType.TIME：只有小時分鐘秒。
*   TemporalType.TIMESTAMP：有年月日小時分鐘秒。

• @Type：可容許你去指定Hibernate裏面的一些類型。

  @Type(type="double") // 容許你去指定Hibernate裏面的一些類型
  private Double price; // 價格，若是沒有添加註解，也會自動的生成在表中

  • 1
  • 2

編寫完上述Book實體類以後，千萬不要忘記下面這一步：咱們最終須要在hibernate.cfg.xml文件中將咱們類中的註解配置引用生效。即須要在Hibernate核心配置文件中添加以下配置：

<mapping />

• 1

最後咱們在src目錄下建立一個cn.itheima.test包，在該包下編寫一個HibernateAnnotationTest單元測試類，並在該類中編寫一個用於測試PO類的註解開發的方法：

public class HibernateAnnotationTest {

    // 測試PO的註解開發
    @Test
    public void test1() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Book b = new Book();
        b.setName("情書");
        b.setPrice(56.78);
        b.setPublicationDate(new Date());

        session.save(b);

        session.getTransaction().commit();
        session.close();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

如今來思考兩個問題：

1. 若是主鍵生成策略咱們想使用UUID類型呢？
2. 如何設定類的屬性不在表中映射？

這兩個問題咱們一塊兒解決。廢話很少說，直接上例子。在cn.itheima.domain包下再編寫一個Person實體類，一樣使用註解配置。

@Entity
@Table(name="t_person", catalog="hibernateTest")
public class Person {

    // 生成UUID的主鍵生成策略
    @Id
    @GenericGenerator(name="myuuid", strategy="uuid") // 聲明一種主鍵生成策略(uuid)
    @GeneratedValue(generator="myuuid") // 引用uuid主鍵生成策略
    private String id;

    @Type(type="string") // 容許你去指定Hibernate裏面的一些類型
    private String name;

    @Transient
    private String msg; // 如今這個屬性不想生成在表中

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

固然不要忘記這一步了：咱們最終須要在hibernate.cfg.xml文件中將咱們類中的註解配置引用生效，故須要在Hibernate核心配置文件中添加以下配置：

<mapping />

• 1

最後在HibernateAnnotationTest單元測試類中編寫以下一個方法：

public class HibernateAnnotationTest {

    // 測試uuid的主鍵生成策略及不生成表中映射
    @Test
    public void test2() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Person p = new Person();
        p.setName("李四");
        p.setMsg("這是一個好人");

        session.save(p);

        session.getTransaction().commit();
        session.close();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

至此，兩個問題就解決了。 
注意：對於咱們以上講解的關於屬性配置的註解，咱們也能夠在其對應的getXxx方法去使用。

Hibernate關聯映射——一對多（多對一）

仍以客戶(Customer)和訂單(Order)爲例來開始個人表演。 
在src目錄下建立一個cn.itheima.oneToMany包，並在該包編寫這兩個實體類：

• 客戶(Customer)類

  // 客戶 ---- 一的一方
  @Entity
  @Table(name="t_customer")
  public class Customer {
  
      @Id
      @GeneratedValue(strategy=GenerationType.IDENTITY)
      private Integer id; // 主鍵
      private String name; // 姓名
  
      // 描述客戶能夠有多個訂單
      /*
       * targetEntity="..."：至關於<one-to-many >

*/
    @OneToMany(targetEntity=Order.class,mappedBy="c")
    private Set<Order> orders = new HashSet<Order>();

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}
```

*   1
*   2
*   3
*   4
*   5
*   6
*   7
*   8
*   9
*   10
*   11
*   12
*   13
*   14
*   15
*   16
*   17
*   18
*   19
*   20
*   21
*   22
*   23
*   24
*   25
*   26
*   27
*   28
*   29
*   30
*   31
*   32
*   33
*   34
*   35
*   36
*   37
*   38

• 訂單(Order)類

  // 訂單 ---- 多的一方
  @Entity
  @Table(name="t_order")
  public class Order {
  
      @Id
      @GeneratedValue(strategy=GenerationType.IDENTITY)
      private Integer id;
      private Double money;
      private String receiverInfo; // 收貨地址
  
      // 訂單與客戶關聯
      @ManyToOne(targetEntity=Customer.class)
      @JoinColumn(name="c_customer_id") // 指定外鍵列
      private Customer c; // 描述訂單屬於某一個客戶
  
      public Customer getC() {
          return c;
      }
      public void setC(Customer c) {
          this.c = c;
      }
      public Integer getId() {
          return id;
      }
      public void setId(Integer id) {
          this.id = id;
      }
      public Double getMoney() {
          return money;
      }
      public void setMoney(Double money) {
          this.money = money;
      }
      public String getReceiverInfo() {
          return receiverInfo;
      }
      public void setReceiverInfo(String receiverInfo) {
          this.receiverInfo = receiverInfo;
      }
  
  }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

這兒用到了`@OneToMany`和`@ManyToOne`這兩個註解。

以上兩個實體類編寫好以後，能夠很明顯的看出咱們不須要寫它們對應的映射配置文件了，是否是很爽呢！接下來，我就要編寫測試程序測試一下了。如今個人需求是保存客戶時，順便保存訂單，對於這種狀況咱們須要在Customer類中配置cascade操做，即配置cascade="save-update"，配置的方式有兩種，下面我細細說來：

1. 第一種方式，可使用JPA提供的註解。 
   那麼@OneToMany註解就應修改成：

   @OneToMany(targetEntity=Order.class,mappedBy="c",cascade=CascadeType.ALL)
   private Set<Order> orders = new HashSet<Order>();

   • 1
   • 2

2. 第二種方式，可使用Hibernate提供的註解。 
   那麼@OneToMany註解就應修改成：

   @OneToMany(targetEntity=Order.class,mappedBy="c")
   @Cascade(CascadeType.SAVE_UPDATE)
   private Set<Order> orders = new HashSet<Order>();

   • 1
   • 2
   • 3

兩種方式均可以，口味任君選擇，不過我傾向於第二種方式。 
接下來在HibernateAnnotationTest單元測試類中編寫以下方法進行測試：

public class HibernateAnnotationTest {

    // 測試one-to-many註解操做(保存客戶時級聯保存訂單)
    @Test
    public void test3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.建立一個客戶
        Customer c = new Customer();
        c.setName("葉子");

        // 2.建立兩個訂單
        Order o1 = new Order();
        o1.setMoney(1000d);
        o1.setReceiverInfo("武漢");
        Order o2 = new Order();
        o2.setMoney(2000d);
        o2.setReceiverInfo("天門");

        // 3.創建關係
        c.getOrders().add(o1);
        c.getOrders().add(o2);

        // 4.保存客戶，並級聯保存訂單
        session.save(c);

        session.getTransaction().commit();
        session.close();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

這時運行以上方法，會發現雖然客戶表的那條記錄插進去了，可是訂單表就變成這個鬼樣了： 
 
訂單表中沒有關聯客戶的id，這是爲何呢？緣由是咱們在Customer類中配置了mappedBy=」c」，它表明的是外鍵的維護由Order方來維護，而Customer不維護，這時你在保存客戶時，級聯保存訂單，是能夠的，可是不能維護外鍵，因此，咱們必須在代碼中添加訂單與客戶之間的關係。因此須將test3方法修改成：

public class HibernateAnnotationTest {

    // 測試one-to-many註解操做(保存客戶時級聯保存訂單)
    @Test
    public void test3() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.建立一個客戶
        Customer c = new Customer();
        c.setName("葉子");

        // 2.建立兩個訂單
        Order o1 = new Order();
        o1.setMoney(1000d);
        o1.setReceiverInfo("武漢");
        Order o2 = new Order();
        o2.setMoney(2000d);
        o2.setReceiverInfo("天門");

        // 3.創建關係
        // 緣由：是爲了維護外鍵，否則的話，外鍵就不能正確的生成！！！
        o1.setC(c);
        o2.setC(c);

        // 緣由：是爲了進行級聯操做
        c.getOrders().add(o1);
        c.getOrders().add(o2);

        // 4.保存客戶，並級聯保存訂單
        session.save(c);

        session.getTransaction().commit();
        session.close();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37

這時再測試，就沒有任何問題啦！

擴展

Hibernate註解@Cascade中的DELETE_ORPHAN已通過時了，以下： 

可以使用下面方案來替換過期方案： 

Hibernate關聯映射——多對多

以學生與老師爲例開始個人表演，我是使用註解完成這種多對多的配置。使用@ManyToMany註解來配置多對多，只須要在一端配置中間表，另外一端使用mappedBy表示放置外鍵的維護權。 
在src目錄下建立一個cn.itheima.manyToMany包，並在該包編寫這兩個實體類：

• 學生類

  @Entity
  @Table(name="t_student")
  public class Student {
  
      @Id
      @GeneratedValue(strategy=GenerationType.IDENTITY)
      private Integer id;
  
      private String name;
  
      @ManyToMany(targetEntity=Teacher.class)
      // @JoinTable：使用@JoinTable來描述中間表，並描述中間表中外鍵與Student、Teacher的映射關係
      // joinColumns：它是用來描述Student與中間表的映射關係
      // inverseJoinColumns：它是用來描述Teacher與中間表的映射關係
      @JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
      private Set<Teacher> teachers = new HashSet<Teacher>();
  
      public Integer getId() {
          return id;
      }
      public void setId(Integer id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public Set<Teacher> getTeachers() {
          return teachers;
      }
      public void setTeachers(Set<Teacher> teachers) {
          this.teachers = teachers;
      }
  
  }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

• 老師類

  @Entity
  @Table(name="t_teacher")
  public class Teacher {
  
      @Id
      @GeneratedValue(strategy=GenerationType.IDENTITY)
      private Integer id;
  
      private String name;
  
      @ManyToMany(targetEntity=Student.class, mappedBy="teachers") // 表明由對方來維護外鍵
      private Set<Student> students = new HashSet<Student>();
  
      public Integer getId() {
          return id;
      }
      public void setId(Integer id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public Set<Student> getStudents() {
          return students;
      }
      public void setStudents(Set<Student> students) {
          this.students = students;
      }
  
  }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

接下來，我就要編寫測試程序測試一下了。 從上面可看出咱們將外鍵的維護權利交由Student類來維護，如今咱們演示保存學生時，將老師也級聯保存，對於這種狀況咱們須要在Student類中配置cascade操做，即配置cascade=」save-update」，以下：

@JoinTable(name="s_t", joinColumns={@JoinColumn(name="c_student_id",referencedColumnName="id")}, inverseJoinColumns={@JoinColumn(name="c_teacher_id")}) 
@Cascade(CascadeType.SAVE_UPDATE)
private Set<Teacher> teachers = new HashSet<Teacher>();

• 1
• 2
• 3

接下來在HibernateAnnotationTest單元測試類中編寫以下方法進行測試：

public class HibernateAnnotationTest {

    // 測試多對多級聯保存(保存學生時同時保存老師)
    @Test
    public void test4() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        // 1.建立兩個老師
        Teacher t1 = new Teacher();
        t1.setName("Tom");

        Teacher t2 = new Teacher();
        t2.setName("Fox");

        // 2.建立兩個學生
        Student s1 = new Student();
        s1.setName("張丹");

        Student s2 = new Student();
        s2.setName("葉紫");

        // 3.學生關聯老師
        s1.getTeachers().add(t1);
        s1.getTeachers().add(t2);

        s2.getTeachers().add(t1);
        s2.getTeachers().add(t2);

        // 保存學生同時保存老師
        session.save(s1);
        session.save(s2);

        session.getTransaction().commit();
        session.close();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38

運行以上方法，一切正常。 
接着咱們測試級聯刪除操做。見下圖： 

可在HibernateAnnotationTest單元測試類中編寫以下方法進行測試：

public class HibernateAnnotationTest {

    // 測試多對多級聯刪除(前提是創建了雙向的級聯)
    @Test
    public void test5() {
        Session session = HibernateUtils.openSession();
        session.beginTransaction();

        Student s = session.get(Student.class, 1);
        session.delete(s);

        session.getTransaction().commit();
        session.close();
    }

}

• 一位阿里 Java 工程師的技術小站。做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！（關注公衆號後回覆」Java「便可領取 Java基礎、進階、項目和架構師等免費學習資料，更有數據庫、分佈式、微服務等熱門技術學習視頻，內容豐富，兼顧原理和實踐，另外也將贈送做者原創的Java學習指南、Java程序員面試指南等乾貨資源）

微信公衆號【黃小斜】大廠程序員，互聯網行業新知，終身學習踐行者。關注後回覆「Java」、「Python」、「C++」、「大數據」、「機器學習」、「算法」、「AI」、「Android」、「前端」、「iOS」、「考研」、「BAT」、「校招」、「筆試」、「面試」、「面經」、「計算機基礎」、「LeetCode」 等關鍵字能夠獲取對應的免費學習資料。

                     ​