SpringDataJPA之復雜查詢

JPA第三天
第1章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 findOne(Specification spec);
  //根據條件查詢集合
  List findAll(Specification spec);
  //根據條件分頁查詢
  Page findAll(Specification spec, Pageable pageable);
  //排序查詢查詢
  List findAll(Specification spec, Sort sort);
  //統計查詢
  long count(Specification 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屬性進行查詢
			return cb.like(root.get("custName").as(String.class), "傳智播客%");
		}
	};
	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 getContent();

1.3方法對應關系
方法名稱 Sql對應關系
equle filed = value
gt（greaterThan ） filed > value
lt（lessThan ） filed < value
ge（greaterThanOrEqualTo ） filed >= value
le（ lessThanOrEqualTo） filed <= value
notEqule filed != value
like filed like value
notLike filed not like value

第2章多表設計

2.1表之間關系的划分

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

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

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

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

在實際開發中，我們數據庫的表難免會有相互的關聯關系，在操作表的時候就有可能會涉及到多張表的操作。而在這種實現了ORM思想的框架中（如JPA），可以讓我們通過操作實體類就實現對數據庫表的操作。所以今天我們的學習重點是：掌握配置實體之間的關聯關系。

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

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

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

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

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

第3章JPA中的一對多

3.1示例分析

我們采用的示例為客戶和聯系人。

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

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

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

3.2表關系建立

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

什么是外鍵？
指的是從表中有一列，取值參照主表的主鍵，這一列就是外鍵。

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

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

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

/**

• 客戶的實體類

• 明確使用的注解都是JPA規范的

• 所以導包都要導入javax.persistence包下的
  */
  @Entity//表示當前類是一個實體類
  @Table(name="cst_customer")//建立當前實體類和表之間的對應關系
  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 linkmans = new HashSet (0);

  public Long getCustId() {
  return custId;
  }
  public void setCustId(Long custId) {
  this.custId = custId;
  }
  public String getCustName() {
  return custName;
  }
  public void setCustName(String custName) {
  this.custName = custName;
  }
  public String getCustSource() {
  return custSource;
  }
  public void setCustSource(String custSource) {
  this.custSource = custSource;
  }
  public String getCustIndustry() {
  return custIndustry;
  }
  public void setCustIndustry(String custIndustry) {
  this.custIndustry = custIndustry;
  }
  public String getCustLevel() {
  return custLevel;
  }
  public void setCustLevel(String custLevel) {
  this.custLevel = custLevel;
  }
  public String getCustAddress() {
  return custAddress;
  }
  public void setCustAddress(String custAddress) {
  this.custAddress = custAddress;
  }
  public String getCustPhone() {
  return custPhone;
  }
  public void setCustPhone(String custPhone) {
  this.custPhone = custPhone;
  }
  public Set getLinkmans() {
  return linkmans;
  }
  public void setLinkmans(Set linkmans) {
  this.linkmans = linkmans;
  }
  @Override
  public String toString() {
  return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource
  + ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress
  + ", custPhone=" + custPhone + "]";
  }
  }

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

/**

• 聯系人的實體類（數據模型）
  */
  @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;//用它的主鍵，對應聯系人表中的外鍵

  public Long getLkmId() {
  return lkmId;
  }
  public void setLkmId(Long lkmId) {
  this.lkmId = lkmId;
  }
  public String getLkmName() {
  return lkmName;
  }
  public void setLkmName(String lkmName) {
  this.lkmName = lkmName;
  }
  public String getLkmGender() {
  return lkmGender;
  }
  public void setLkmGender(String lkmGender) {
  this.lkmGender = lkmGender;
  }
  public String getLkmPhone() {
  return lkmPhone;
  }
  public void setLkmPhone(String lkmPhone) {
  this.lkmPhone = lkmPhone;
  }
  public String getLkmMobile() {
  return lkmMobile;
  }
  public void setLkmMobile(String lkmMobile) {
  this.lkmMobile = lkmMobile;
  }
  public String getLkmEmail() {
  return lkmEmail;
  }
  public void setLkmEmail(String lkmEmail) {
  this.lkmEmail = lkmEmail;
  }
  public String getLkmPosition() {
  return lkmPosition;
  }
  public void setLkmPosition(String lkmPosition) {
  this.lkmPosition = lkmPosition;
  }
  public String getLkmMemo() {
  return lkmMemo;
  }
  public void setLkmMemo(String lkmMemo) {
  this.lkmMemo = lkmMemo;
  }
  public Customer getCustomer() {
  return customer;
  }
  public void setCustomer(Customer customer) {
  this.customer = customer;
  }
  @Override
  public String toString() {
  return "LinkMan [lkmId=" + lkmId + ", lkmName=" + lkmName + ", lkmGender=" + lkmGender + ", lkmPhone="
  + lkmPhone + ", lkmMobile=" + lkmMobile + ", lkmEmail=" + lkmEmail + ", lkmPosition=" + lkmPosition
  + ", lkmMemo=" + lkmMemo + "]";
  }
  }

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

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

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

3.5一對多的操作

3.5.1添加

@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("[e-mail]");
	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")

3.5.2刪除

@Autowired
private CustomerDao customerDao;

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

刪除操作的說明如下：

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

刪除主表數據：

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

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

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

3.5.3級聯操作

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

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

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

第4章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 roles = new HashSet (0);

  public Long getUserId() {
  return userId;
  }
  public void setUserId(Long userId) {
  this.userId = userId;
  }
  public String getUserCode() {
  return userCode;
  }
  public void setUserCode(String userCode) {
  this.userCode = userCode;
  }
  public String getUserName() {
  return userName;
  }
  public void setUserName(String userName) {
  this.userName = userName;
  }
  public String getUserPassword() {
  return userPassword;
  }
  public void setUserPassword(String userPassword) {
  this.userPassword = userPassword;
  }
  public String getUserState() {
  return userState;
  }
  public void setUserState(String userState) {
  this.userState = userState;
  }
  public Set getRoles() {
  return roles;
  }
  public void setRoles(Set roles) {
  this.roles = roles;
  }
  @Override
  public String toString() {
  return "SysUser [userId=" + userId + ", userCode=" + userCode + ", userName=" + userName + ", userPassword="
  + userPassword + ", userState=" + userState + "]";
  }
  }

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

/**

• 角色的數據模型
  */
  @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 users = new HashSet (0);

  public Long getRoleId() {
  return roleId;
  }
  public void setRoleId(Long roleId) {
  this.roleId = roleId;
  }
  public String getRoleName() {
  return roleName;
  }
  public void setRoleName(String roleName) {
  this.roleName = roleName;
  }
  public String getRoleMemo() {
  return roleMemo;
  }
  public void setRoleMemo(String roleMemo) {
  this.roleMemo = roleMemo;
  }
  public Set getUsers() {
  return users;
  }
  public void setUsers(Set users) {
  this.users = users;
  }
  @Override
  public String toString() {
  return "SysRole [roleId=" + roleId + ", roleName=" + roleName + ", roleMemo=" + roleMemo + "]";
  }
  }

4.4映射的注解說明

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

@JoinTable
作用：針對中間表的配置
屬性：
nam：配置中間表的名稱
joinColumns：中間表的外鍵字段關聯當前實體類所對應表的主鍵字段
inverseJoinColumn：中間表的外鍵字段關聯對方表的主鍵字段

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

4.5多對多的操作

4.5.1保存
@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);

4.5.2刪除

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

第5章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);
	}
}

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

@Autowired
private LinkManDao linkManDao;


@Test
public void testFind() {
	LinkMan linkMan = linkManDao.findOne(4l);
	Customer customer = linkMan.getCustomer(); //對象導航查詢
	System.out.println(customer);
}

對象導航查詢的問題分析

問題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),"傳智播客1");
		}
	};
	List<LinkMan> list = linkManDao.findAll(spec);
	for (LinkMan linkMan : list) {
		System.out.println(linkMan);
	}
}