【SSH進階之路】【十一】hibernate5 註解映射【3】一對多多對一雙向關聯

在上兩篇文章裏，我們詳細地分別講解了一對多和多對一的單向關聯配置的具體屬性含義，在這一篇文章裏，我們完成兩者的的整合建立雙向關聯。

在實際的博客網站中，我們可能需要根據文章讀取作者（用戶）信息，但肯定也要讓用戶能獲取自己的文章信息，針對這種需求，我們可以建立文章（多）對用戶（一）的雙向關聯映射。

下面先看實例映射配置文件：

//一方配置

package com.chenhao.hibernate.model;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;


/**
 * 
 * @author chen_hao
 *
 */

@Entity//聲明當前類爲hibernate映射到數據庫中的實體類
@Table(name = "t_user1")//聲明在數據庫中自動生成的表名爲t_user
public class User {


    @Id//聲明此列爲主鍵,作爲映射對象的標識符
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;


    @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.LAZY,targetEntity = Article.class,orphanRemoval = true)//用戶作爲一方使用OneToMany註解
    @JoinColumn(name = "user_id")
    private Set<Article> articles;//文章作爲多方，我們使用Set集合來存儲，同時還能防止存放相同的文章



    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Set<Article> getArticles() {
        return articles;
    }
    public void setArticles(Set<Article> articles) {
        this.articles = articles;
    }
    //重寫hashcode方法提高比較效率
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //重寫equals比較對象相等
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

//多方配置

package com.chenhao.hibernate.model;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Table(name = "t_article1")
@Entity
public class Article {


    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String content;

    /**
     * @ManyToOne 使用此標籤建立多對一關聯，此屬性在“多”方使用註解在我們的“一”方屬性上
     * @cascade 指定級聯操作，以數組方式指定，如果只有一個，可以省略“{}”
     * @fetch 定義抓取策略
     * @optional 定義是否爲必需屬性，如果爲必需（false），但在持久化時user = null,則會持久化失敗
     * @targetEntity 目標關聯對象，默認爲被註解屬性所在類
     */
    @ManyToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id",unique = false,updatable = true)
    private User user;


    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }






}

映射關係確立好，開始編寫我們的測試文件：

package com.chenhao.hibernate.Hibernate;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.chenhao.hibernate.model.Article;
import com.chenhao.hibernate.model.User;

public class ArticleTest {


        private static ApplicationContext ac;
        private static SessionFactory sessionFactory;
        private Session session;
        private Transaction transaction;


        @BeforeClass//在測試類初始化時調用此方法，完成靜態對象的初始化
        public static void before(){

            ac = new ClassPathXmlApplicationContext("spring-datasource.xml");
            sessionFactory = (SessionFactory) ac.getBean("sessionFactory");

        }

        @Before//每一個被註解Test方法在調用前都會調用此方法一次
        public void setup(){//建立針對我們當前測試方法的的會話和事務
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

        }

        @Test
        public void test3(){
            User user = new User();
            user.setName("oneObject");
            Set<Article> articles = new HashSet<Article>();
            for(int i = 0 ; i < 3;i ++){
                Article article = new Article();
                article.setContent("moreContent" + i) ;
                articles.add(article);
            }
            user.setArticles(articles);//建立關聯關係
            session.save(user);
        }

        @After//每一個被註解Test方法在調用後都會調用此方法一次
        public void teardown(){

            transaction.commit();//提交事務，主要爲了防止在測試中已提交事務，這裏又重複提交
            session.clear();
            session.close();
            sessionFactory.close();//
        }
        @After//在類銷燬時調用一次
        public void after(){

        }

}

然後我們再運行測試方法：會看到：

Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: insert into t_user1 (name, id) values (?, ?)
Hibernate: insert into t_article1 (content, user_id, id) values (?, ?, ?)
Hibernate: insert into t_article1 (content, user_id, id) values (?, ?, ?)
Hibernate: insert into t_article1 (content, user_id, id) values (?, ?, ?)
Hibernate: update t_article1 set user_id=? where id=?
Hibernate: update t_article1 set user_id=? where id=?
Hibernate: update t_article1 set user_id=? where id=?

此外，我們可以通過測試嘗試從user中獲取article對象來進一步驗證：

User user = (User) session.get(User.class, 1);
System.out.println("獲取用戶對應的文章數據："+user.getArticles());

打印結果：獲取用戶對應的文章數據：[]
這是因爲我們的關聯信息是由多方維護的(user_id)，我們想要真正完成兩者，必須從主維護方：article下手
運行以下測試代碼：

User user = new User();
user.setName("oneObject1");
for(int i = 0 ; i < 3;i ++){
    Article article = new Article();
    article.setContent("moreContent1" + i) ;
    article.setUser(user);//有article來建立關聯關係
    session.save(article);//持久化
}

得到打印結果：

Hibernate: insert into t_user1 (name) values (?) 
Hibernate: insert into t_article1 (content, user_id) values (?, ?) 
Hibernate: insert into t_article1 (content, user_id) values (?, ?) 
Hibernate: insert into t_article1 (content, user_id) values (?, ?) 

DEBUG: org.hibernate.internal.util.EntityPrinter - com.zeng.model.Article{content=moreContent10, id=4, user=com.zeng.model.User#2} 
DEBUG: org.hibernate.internal.util.EntityPrinter - com.zeng.model.Article{content=moreContent12, id=6, user=com.zeng.model.User#2} 
DEBUG: org.hibernate.internal.util.EntityPrinter - com.zeng.model.Article{content=moreContent11, id=5, user=com.zeng.model.User#2} 
DEBUG: org.hibernate.internal.util.EntityPrinter - com.zeng.model.User{id=2, articles=null, name=oneObject1} 

再查看數據庫： 
MySQL> select * from t_article1; 
+—-+—————+———+ 
| id | content | user_id | 
+—-+—————+———+ 
| 1 | moreContent2 | NULL |——————上次操作遺留 
| 2 | moreContent1 | NULL |——————上次操作遺留 
| 3 | moreContent0 | NULL |——————上次操作遺留 
| 4 | moreContent10 | 2 | 
| 5 | moreContent11 | 2 | 
| 6 | moreContent12 | 2 | 
+—-+—————+———+ 
6 rows in set (0.00 sec)

從sql語句和藍色DEBUG、數據庫記錄我們能夠看出，這纔是最優雅的添加關聯操作，既沒有多餘的update語句，同時完成了數據庫關聯關係的建立。