Spring Data Jpa（3）：動態查詢和多表操作

一、Specifications動態查詢

有時我們在查詢某個實體的時候，給定的條件是不固定的，這時就需要動態構建相應的查詢語句，在Spring Data JPA中可以通過JpaSpecificationExecutor接口查詢。相比JPQL,其優勢是類型安全,更加的面向對象。

import java.util.List;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

/**
 *	JpaSpecificationExecutor中定義的方法
 **/
 public interface JpaSpecificationExecutor<T> {
   	//根據條件查詢一個對象
 	T findOne(Specification<T> spec);	
   	//根據條件查詢集合
 	List<T> findAll(Specification<T> spec);
   	//根據條件分頁查詢
 	Page<T> findAll(Specification<T> spec, Pageable pageable);
   	//排序查詢查詢
 	List<T> findAll(Specification<T> spec, Sort sort);
   	//統計查詢
 	long count(Specification<T> spec);
}

對於JpaSpecificationExecutor，這個接口基本是圍繞着Specification接口來定義的。我們可以簡單的理解爲，Specification構造的就是查詢條件對象。

Specification接口中只定義瞭如下一個方法：

  //構造查詢條件
    /**
    *	root	：Root接口，代表查詢的根對象，可以通過root獲取實體中的屬性
    *	query	：代表一個頂層查詢對象，用來自定義查詢
    *	cb		：用來構建查詢，此對象裏有很多條件方法
    **/
    public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);

1.1 使用Specifications完成條件查詢

//依賴注入customerDao
@Autowired
private CustomerDao customerDao;	
@Test
public void testSpecifications() {
  	//使用匿名內部類的方式，創建一個Specification的實現類，並實現toPredicate方法
	Specification <Customer> spec = new Specification<Customer>() {
		public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
			//cb:構建查詢，添加查詢方式   like：模糊匹配
			//root：從實體Customer對象中按照custName屬性進行查詢
			//精準匹配  cb.equal();
			return cb.like(root.get("custName").as(String.class), "xxx");
		}
	};
	Customer customer = customerDao.findOne(spec);
	System.out.println(customer);
}

1.2 基於Specifications的分頁查詢（分頁操作）

@Test
public void testPage() {
	//構造查詢條件
	Specification<Customer> spec = new Specification<Customer>() {
		public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
			return cb.like(root.get("custName").as(String.class), "傳智%");
		}
	};
	
	/**
	 * 構造分頁參數
	 * 		Pageable : 接口
	 * 			PageRequest實現了Pageable接口，調用構造方法的形式構造
	 * 				第一個參數：頁碼（從0開始）
	 * 				第二個參數：每頁查詢條數
	 */
	Pageable pageable = new PageRequest(0, 5);
	
	/**
	 * 分頁查詢，封裝爲Spring Data Jpa 內部的page bean
	 * 		此重載的findAll方法爲分頁方法需要兩個參數
	 * 			第一個參數：查詢條件Specification
	 * 			第二個參數：分頁參數
	 */
	Page<Customer> page = customerDao.findAll(spec,pageable);
	
}

對於Spring Data JPA中的分頁查詢，是其內部自動實現的封裝過程，返回的是一個Spring Data JPA提供的pageBean對象。其中的方法說明如下：

//獲取總頁數
int getTotalPages();

//獲取總記錄數	
long getTotalElements();

//獲取列表數據
List<T> getContent();

1.3 CriteriaBuilder方法對應關係

二、多表設計

2.1 表之間關係的劃分

數據庫中多表之間存在着三種關係，如圖所示。

從圖可以看出，系統設計的三種實體關係分別爲：多對多、一對多和一對一關係。注意：一對多關係可以看爲兩種： 即一對多，多對一。所以說四種更精確。

明確： 我們今天只涉及實際開發中常用的關聯關係，一對多和多對多。而一對一的情況，在實際開發中幾乎不用。

2.2 在JPA框架中表關係的分析步驟

在實際開發中，我們數據庫的表難免會有相互的關聯關係，在操作表的時候就有可能會涉及到多張表的操作。而在這種實現了ORM思想的框架中（如JPA），可以讓我們通過操作實體類就實現對數據庫表的操作。

所以今天我們的學習重點是：掌握配置實體之間的關聯關係。

• 第一步：首先確定兩張表之間的關係。

  如果關係確定錯了，後面做的所有操作就都不可能正確。

• 第二步：在數據庫中實現兩張表的關係

• 第三步：在實體類中描述出兩個實體的關係

• 第四步：配置出實體類和數據庫表的關係映射（重點）

三、 JPA中的一對多

3.1 示例分析

我們採用的示例爲客戶和聯繫人。

客戶：指的是一家公司，我們記爲A。

聯繫人：指的是A公司中的員工。

在不考慮兼職的情況下，公司和員工的關係即爲一對多。

3.2 表關係建立

在一對多關係中，我們習慣把一的一方稱之爲主表，把多的一方稱之爲從表。在數據庫中建立一對多的關係，需要使用數據庫的外鍵約束。

什麼是外鍵？
指的是從表中有一列，取值參照主表的主鍵，這一列就是外鍵,連接從表的關係的一列。

一對多數據庫關係的建立，如下圖所示 ：

3.3 實體類關係建立以及映射配置

在實體類中，由於客戶是少的一方，它應該包含多個聯繫人，所以實體類要體現出客戶中有多個聯繫人的信息，代碼如下：

/**
 * 客戶的實體類
 * 明確使用的註解都是JPA規範的
 * 所以導包都要導入javax.persistence包下的
 */
@Entity//表示當前類是一個實體類
@Table(name="cst_customer")//建立當前實體類和表之間的對應關係
@Data
public class Customer implements Serializable {
	
	@Id//表明當前私有屬性是主鍵
	@GeneratedValue(strategy=GenerationType.IDENTITY)//指定主鍵的生成策略
	@Column(name="cust_id")//指定和數據庫表中的cust_id列對應
	private Long custId;
	
	@Column(name="cust_name")//指定和數據庫表中的cust_name列對應
	private String custName;
	
	@Column(name="cust_source")//指定和數據庫表中的cust_source列對應
	private String custSource;
	
	@Column(name="cust_industry")//指定和數據庫表中的cust_industry列對應
	private String custIndustry;
	
	@Column(name="cust_level")//指定和數據庫表中的cust_level列對應
	private String custLevel;
	
	@Column(name="cust_address")//指定和數據庫表中的cust_address列對應
	private String custAddress;
	
	@Column(name="cust_phone")//指定和數據庫表中的cust_phone列對應
	private String custPhone;
	
    //配置客戶和聯繫人的一對多關係
  	@OneToMany(targetEntity=LinkMan.class)
	@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
	private Set<LinkMan> linkmans = new HashSet<LinkMan>(0);
	

由於聯繫人是多的一方，在實體類中要體現出，每個聯繫人只能對應一個客戶，代碼如下：

/**
 * 聯繫人的實體類（數據模型）
 */
@Entity
@Table(name="cst_linkman")
public class LinkMan implements Serializable {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="lkm_id")
	private Long lkmId;
	
	@Column(name="lkm_name")
	private String lkmName;
	
	@Column(name="lkm_gender")
	private String lkmGender;
	
	@Column(name="lkm_phone")
	private String lkmPhone;
	
	@Column(name="lkm_mobile")
	private String lkmMobile;
	
	@Column(name="lkm_email")
	private String lkmEmail;
	
	@Column(name="lkm_position")
	private String lkmPosition;
	
	@Column(name="lkm_memo")
	private String lkmMemo;

	//多對一關係映射：多個聯繫人對應客戶
	@ManyToOne(targetEntity=Customer.class)
	@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
	private Customer customer;//用它的主鍵，對應聯繫人表中的外鍵
	
	

3.4 映射的註解說明

@OneToMany:
   	作用：建立一對多的關係映射
    屬性：
    	targetEntityClass：指定多的多方的類的字節碼
    	mappedBy：指定從表實體類中引用主表對象的名稱。
    	cascade：指定要使用的級聯操作
    	fetch：指定是否採用延遲加載
    	orphanRemoval：是否使用孤兒刪除

@ManyToOne
    作用：建立多對一的關係
    屬性：
    	targetEntityClass：指定一的一方實體類字節碼
    	cascade：指定要使用的級聯操作
    	fetch：指定是否採用延遲加載
    	optional：關聯是否可選。如果設置爲false，則必須始終存在非空關係。

@JoinColumn
     作用：用於定義主鍵字段和外鍵字段的對應關係。
     屬性：
    	name：指定外鍵字段的名稱
    	referencedColumnName：指定引用主表的主鍵字段名稱
    	unique：是否唯一。默認值不唯一
    	nullable：是否允許爲空。默認值允許。
    	insertable：是否允許插入。默認值允許。
    	updatable：是否允許更新。默認值允許。
    	columnDefinition：列的定義信息。

3.5 一對多的CRUD操作

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class OneToManyTest {

	@Autowired
	private CustomerDao customerDao;
	
	@Autowired
	private LinkManDao linkManDao;
	
	
	/**
	 * 保存操作
	 * 需求:
	 * 	保存一個客戶和一個聯繫人
	 * 要求：
	 * 	創建一個客戶對象和一個聯繫人對象
	 *  建立客戶和聯繫人之間關聯關係（雙向一對多的關聯關係）
	 *  先保存客戶，再保存聯繫人
	 * 問題：
	 *		當我們建立了雙向的關聯關係之後，先保存主表，再保存從表時：
	 *		會產生2條insert和1條update.
	 * 		而實際開發中我們只需要2條insert。
	 *  
	 */
	@Test
	@Transactional  //開啓事務
	@Rollback(false)//設置爲不回滾
	public void testAdd() {
		Customer c = new Customer();
		c.setCustName("TBD雲集中心");
		c.setCustLevel("VIP客戶");
		c.setCustSource("網絡");
		c.setCustIndustry("商業辦公");
		c.setCustAddress("昌平區北七家鎮");
		c.setCustPhone("010-84389340");
		
		LinkMan l = new LinkMan();
		l.setLkmName("TBD聯繫人");
		l.setLkmGender("male");
		l.setLkmMobile("13811111111");
		l.setLkmPhone("010-34785348");
		l.setLkmEmail("[email protected]");
		l.setLkmPosition("老師");
		l.setLkmMemo("還行吧");

		c.getLinkMans().add(l);
		l.setCustomer(c);
		customerDao.save(c);
		linkManDao.save(l);
	}
}

通過保存的案例，我們可以發現在設置了雙向關係之後，會發送兩條insert語句，一條多餘的update語句，那我們的解決是思路很簡單，就是一的一方放棄維護權

/**
 *放棄外鍵維護權的配置將如下配置改爲
 */
//@OneToMany(targetEntity=LinkMan.class)
//@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")	
//設置爲
@OneToMany(mappedBy="customer")

刪除

@Autowired
	private CustomerDao customerDao;
	
	@Test
	@Transactional
	@Rollback(false)//設置爲不回滾
	public void testDelete() {
		customerDao.delete(1l);
	}

刪除操作的說明如下：

（1）從表數據：可以隨時任意刪除。

（2）主表數據：

• 有從表數據
  1、在默認情況下，它會把外鍵字段置爲null，然後刪除主表數據。如果在數據庫的表 結構上，外鍵字段有非空約束，默認情況就會報錯了。
  2、如果配置了放棄維護關聯關係的權利，則不能刪除（與外鍵字段是否允許爲null， 沒有關係）因爲在刪除時，它根本不會去更新從表的外鍵字段了。
  3、如果還想刪除，使用級聯刪除引用

• 沒有從表數據引用：隨便刪

在實際開發中，級聯刪除請慎用！(在一對多的情況下)

3.6 級聯操作

級聯操作：指操作一個對象同時操作它的關聯對象

使用方法：只需要在操作主體的註解上配置cascade

/**
 * cascade:配置級聯操作
 * 		CascadeType.MERGE	級聯更新
 * 		CascadeType.PERSIST	級聯保存：
 * 		CascadeType.REFRESH 級聯刷新：
 * 		CascadeType.REMOVE	級聯刪除：
 * 		CascadeType.ALL		包含所有
 */
@OneToMany(mappedBy="customer",cascade=CascadeType.ALL)

四、JPA中的多對多

4.1 示例分析

我們採用的示例爲用戶和角色。

用戶：指的是咱們班的每一個同學。

角色：指的是咱們班同學的身份信息。

比如A同學，它是我的學生，其中有個身份就是學生，還是家裏的孩子，那麼他還有個身份是子女。

同時B同學，它也具有學生和子女的身份。

那麼任何一個同學都可能具有多個身份。同時學生這個身份可以被多個同學所具有。

所以我們說，用戶和角色之間的關係是多對多。

4.2 表關係建立

多對多的表關係建立靠的是中間表，其中用戶表和中間表的關係是一對多，角色表和中間表的關係也是一對多，如下圖所示：

4.3 實體類關係建立以及映射配置

一個用戶可以具有多個角色，所以在用戶實體類中應該包含多個角色的信息，代碼如下：

/**
 * 用戶的數據模型
 */
@Entity
@Table(name="sys_user")
public class SysUser implements Serializable {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="user_id")
	private Long userId;
	
	@Column(name="user_code")
	private String userCode;
	
	@Column(name="user_name")
	private String userName;
	
	@Column(name="user_password")
	private String userPassword;
	
	@Column(name="user_state")
	private String userState;
	
	//多對多關係映射
	@ManyToMany(mappedBy="users")
	private Set<SysRole> roles = new HashSet<SysRole>(0);
	
}

一個角色可以賦予多個用戶，所以在角色實體類中應該包含多個用戶的信息，代碼如下：

/**
 * 角色的數據模型
 */
@Entity
@Table(name="sys_role")
public class SysRole implements Serializable {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="role_id")
	private Long roleId;
	
	@Column(name="role_name")
	private String roleName;
	
	@Column(name="role_memo")
	private String roleMemo;
	
	//多對多關係映射
	@ManyToMany
	@JoinTable(name="user_role_rel",//中間表的名稱
			  //中間表user_role_rel字段關聯sys_role表的主鍵字段role_id
			  joinColumns={@JoinColumn(name="role_id",referencedColumnName="role_id")},
			  //中間表user_role_rel的字段關聯sys_user表的主鍵user_id
			  inverseJoinColumns={@JoinColumn(name="user_id",referencedColumnName="user_id")}
	)
	private Set<SysUser> users = new HashSet<SysUser>(0);
}

4.4 映射的註解說明

@ManyToMany
	作用：用於映射多對多關係
	屬性：
		cascade：配置級聯操作。
		fetch：配置是否採用延遲加載。
    	targetEntity：配置目標的實體類。映射多對多的時候不用寫。

@JoinTable
    作用：針對中間表的配置
    屬性：
    	nam：配置中間表的名稱
    	joinColumns：中間表的外鍵字段關聯當前實體類所對應表的主鍵字段			  			
    	inverseJoinColumn：中間表的外鍵字段關聯對方表的主鍵字段
    	
@JoinColumn
    作用：用於定義主鍵字段和外鍵字段的對應關係。
    屬性：
    	name：指定外鍵字段的名稱
    	referencedColumnName：指定引用主表的主鍵字段名稱
    	unique：是否唯一。默認值不唯一
    	nullable：是否允許爲空。默認值允許。
    	insertable：是否允許插入。默認值允許。
    	updatable：是否允許更新。默認值允許。
    	columnDefinition：列的定義信息。

4.5 多對多的操作

保存

 	@Autowired
	private UserDao userDao;
	
	@Autowired
	private RoleDao roleDao;
	/**
	 * 需求：
	 * 	保存用戶和角色
	 * 要求：
	 * 	創建2個用戶和3個角色
	 * 	讓1號用戶具有1號和2號角色(雙向的)
	 * 	讓2號用戶具有2號和3號角色(雙向的)
	 *  保存用戶和角色
	 * 問題：
	 *  在保存時，會出現主鍵重複的錯誤，因爲都是要往中間表中保存數據造成的。
	 * 解決辦法：
	 * 	讓任意一方放棄維護關聯關係的權利
	 */
	@Test
	@Transactional  //開啓事務
	@Rollback(false)//設置爲不回滾
	public void test1(){
		//創建對象
		SysUser u1 = new SysUser();
		u1.setUserName("用戶1");
		SysRole r1 = new SysRole();
		r1.setRoleName("角色1");
		//建立關聯關係
		u1.getRoles().add(r1);
		r1.getUsers().add(u1);
		//保存
		roleDao.save(r1);
		userDao.save(u1);
	}

在多對多（保存）中，如果雙向都設置關係，意味着雙方都維護中間表，都會往中間表插入數據，中間表的2個字段又作爲聯合主鍵，所以報錯，主鍵重複，解決保存失敗的問題：只需要在任意一方放棄對中間表的維護權即可，推薦在被動的一方放棄，配置如下：

//放棄對中間表的維護權，解決保存中主鍵衝突的問題
@ManyToMany(mappedBy="roles")
private Set<SysUser> users = new HashSet<SysUser>(0);

刪除

@Autowired
private UserDao userDao;
/**
 * 刪除操作
 * 	在多對多的刪除時，雙向級聯刪除根本不能配置
 * 禁用
 *	如果配了的話，如果數據之間有相互引用關係，可能會清空所有數據
 */
@Test
@Transactional
@Rollback(false)//設置爲不回滾
public void testDelete() {
	userDao.delete(1l);
}

五、Spring Data JPA中的多表查詢

5.1 對象導航查詢

對象圖導航檢索方式是根據已經加載的對象，導航到他的關聯對象。它利用類與類之間的關係來檢索對象。例如：我們通過ID查詢方式查出一個客戶，可以調用Customer類中的getLinkMans()方法來獲取該客戶的所有聯繫人。對象導航查詢的使用要求是：兩個對象之間必須存在關聯關係。

查詢一個客戶，獲取該客戶下的所有聯繫人

@Autowired
private CustomerDao customerDao;

@Test
//由於是在java代碼中測試，爲了解決no session問題，將操作配置到同一個事務中
@Transactional 
public void testFind() {
	Customer customer = customerDao.findOne(5l);
	Set<LinkMan> linkMans = customer.getLinkMans();//對象導航查詢
	for(LinkMan linkMan : linkMans) {
		System.out.println(linkMan);
	}
}

對象導航查詢的問題分析

問題1：我們查詢客戶時，要不要把聯繫人查詢出來？

分析：如果我們不查的話，在用的時候還要自己寫代碼，調用方法去查詢。如果我們查出來的，不使用時又會白白的浪費了服務器內存。

解決：採用延遲加載的思想。通過配置的方式來設定當我們在需要使用時，發起真正的查詢。

配置方式：

/**
 * 在客戶對象的@OneToMany註解中添加fetch屬性
 * 		FetchType.EAGER	：立即加載
 * 		FetchType.LAZY	：延遲加載
 */
@OneToMany(mappedBy="customer",fetch=FetchType.EAGER)
private Set<LinkMan> linkMans = new HashSet<>(0);

問題2：我們查詢聯繫人時，要不要把客戶查詢出來？

分析：例如：查詢聯繫人詳情時，肯定會看看該聯繫人的所屬客戶。如果我們不查的話，在用的時候還要自己寫代碼，調用方法去查詢。如果我們查出來的話，一個對象不會消耗太多的內存。而且多數情況下我們都是要使用的。

解決： 採用立即加載的思想。通過配置的方式來設定，只要查詢從表實體，就把主表實體對象同時查出來

配置方式

/**
 * 在聯繫人對象的@ManyToOne註解中添加fetch屬性
 * 		FetchType.EAGER	：立即加載
 * 		FetchType.LAZY	：延遲加載
 */
@ManyToOne(targetEntity=Customer.class,fetch=FetchType.EAGER)
@JoinColumn(name="cst_lkm_id",referencedColumnName="cust_id")
private Customer customer;

5.2 使用Specification查詢

/**
 * Specification的多表查詢
 */
@Test
public void testFind() {
	Specification<LinkMan> spec = new Specification<LinkMan>() {
		public Predicate toPredicate(Root<LinkMan> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
			//Join代表鏈接查詢，通過root對象獲取
			//創建的過程中，第一個參數爲關聯對象的屬性名稱，第二個參數爲連接查詢的方式（left，inner，right）
			//JoinType.LEFT : 左外連接,JoinType.INNER：內連接,JoinType.RIGHT：右外連接
			Join<LinkMan, Customer> join = root.join("customer",JoinType.INNER);
			return cb.like(join.get("custName").as(String.class),"xxx");
		}
	};
	List<LinkMan> list = linkManDao.findAll(spec);
	for (LinkMan linkMan : list) {
		System.out.println(linkMan);
	}
}