Spring Hibernate JPA 聯表查詢 複雜查詢
正文：
一、Hibernate VS Mybatis
1、簡介
Hibernate對資料庫結構提供了較為完整的封裝，Hibernate的O/R Mapping實現了POJO 和資料庫表之間的對映，以及SQL 的自動生成和執行。程式設計師往往只需定義好了POJO 到資料庫表的對映關係，即可通過Hibernate 提供的方法完成持久層操作。程式設計師甚至不需要對SQL 的熟練掌握， Hibernate/OJB 會根據制定的儲存邏輯，自動生成對應的SQL 並呼叫JDBC 介面加以執行。
iBATIS 的著力點，則在於POJO 與SQL之間的對映關係。然後通過對映配置檔案，將SQL所需的引數，以及返回的結果欄位對映到指定POJO。 相對Hibernate“O/R”而言，iBATIS 是一種“Sql Mapping”的ORM實現
2、開發對比
Hibernate的真正掌握要比Mybatis來得難些。Mybatis框架相對簡單很容易上手，但也相對簡陋些。個人覺得要用好Mybatis還是首先要先理解好Hibernate。針對高階查詢，Mybatis需要手動編寫SQL語句，以及ResultMap。而Hibernate有良好的對映機制，開發者無需關心SQL的生成與結果對映，可以更專注於業務流程
3、系統調優對比
Hibernate調優方案：
- 制定合理的快取策略；
- 儘量使用延遲載入特性；
- 採用合理的Session管理機制；
- 使用批量抓取，設定合理的批處理引數（batch_size）;
- 進行合理的O/R對映設計
Mybatis調優方案：
MyBatis在Session方面和Hibernate的Session生命週期是一致的，同樣需要合理的Session管理機制。MyBatis同樣具有二級快取機制。 MyBatis可以進行詳細的SQL優化設計。
SQL優化方面：
Hibernate的查詢會將表中的所有欄位查詢出來，這一點會有效能消耗。Hibernate也可以自己寫SQL來指定需要查詢的欄位，但這樣就破壞了Hibernate開發的簡潔性。而Mybatis的SQL是手動編寫的，所以可以按需求指定查詢的欄位。
Hibernate HQL語句的調優需要將SQL打印出來，而Hibernate的SQL被很多人嫌棄因為太醜了。MyBatis的SQL是自己手動寫的所以調整方便。但Hibernate具有自己的日誌統計。Mybatis本身不帶日誌統計，使用Log4j進行日誌記錄。
4、快取機制對比
Hibernate快取：
Hibernate一級快取是Session快取，利用好一級快取就需要對Session的生命週期進行管理好。建議在一個Action操作中使用一個Session。一級快取需要對Session進行嚴格管理。Hibernate二級快取是SessionFactory級的快取。 SessionFactory的快取分為內建快取和外接快取。內建快取中存放的是SessionFactory物件的一些集合屬性包含的資料(對映元素據及預定SQL語句等),對於應用程式來說,它是隻讀的。外接快取中存放的是資料庫資料的副本,其作用和一級快取類似.二級快取除了以記憶體作為儲存介質外,還可以選用硬碟等外部儲存裝置。二級快取稱為程序級快取或SessionFactory級快取，它可以被所有session共享，它的生命週期伴隨著SessionFactory的生命週期存在和消亡。
Mybatis快取：
MyBatis 包含一個非常強大的查詢快取特性,它可以非常方便地配置和定製。MyBatis 3 中的快取實現的很多改進都已經實現了,使得它更加強大而且易於配置。
預設情況下是沒有開啟快取的,除了區域性的 session 快取,可以增強變現而且處理迴圈 依賴也是必須的。要開啟二級快取,你需要在你的 SQL 對映檔案中新增一行: <cache/>
字面上看就是這樣。這個簡單語句的效果如下:
- 對映語句檔案中的所有 select 語句將會被快取。
- 對映語句檔案中的所有 insert,update 和 delete 語句會重新整理快取。
- 快取會使用 Least Recently Used(LRU,最近最少使用的)演算法來收回。
- 根據時間表(比如 no Flush Interval,沒有重新整理間隔), 快取不會以任何時間順序 來重新整理。
- 快取會儲存列表集合或物件(無論查詢方法返回什麼)的 1024 個引用。
- 快取會被視為是 read/write(可讀/可寫)的快取,意味著物件檢索不是共享的,而 且可以安全地被呼叫者修改,而不干擾其他呼叫者或執行緒所做的潛在修改。
所有的這些屬性都可以通過快取元素的屬性來修改。
5、總結
Mybatis：小巧、方便、高效、簡單、直接、半自動
Hibernate：強大、方便、高效、複雜、繞彎子、全自動
二、Hibernate & JPA
1、JPA
全稱Java Persistence API，通過JDK 5.0註解或XML描述物件－關係表的對映關係，並將執行期的實體物件持久化到資料庫中。
JPA的出現有兩個原因：
其一，簡化現有Java EE和Java SE應用的物件持久化的開發工作；
其二，Sun希望整合對ORM技術，實現持久化領域的統一。
JPA提供的技術：
1）ORM對映元資料：JPA支援XML和JDK 5.0註解兩種元資料的形式，元資料描述物件和表之間的對映關係，框架據此將實體物件持久化到資料庫表中；
2）JPA 的API：用來操作實體物件，執行CRUD操作，框架在後臺替我們完成所有的事情，開發者從繁瑣的JDBC和SQL程式碼中解脫出來。
3）查詢語言：通過面向物件而非面向資料庫的查詢語言查詢資料，避免程式的SQL語句緊密耦合。
2、JPA & Hibernate 關係
JPA是需要Provider來實現其功能的，Hibernate就是JPA Provider中很強的一個。從功能上來說，JPA現在就是Hibernate功能的一個子集。可以簡單的理解為JPA是標準介面，Hibernate是實現。Hibernate主要是通過三個元件來實現的，及hibernate-annotation、hibernate-entitymanager 和hibernate-core。
1）hibernate-annotation是Hibernate支援annotation方式配置的基礎，它包括了標準的JPA annotation以及 Hibernate自身特殊功能的annotation。
2）hibernate-core是Hibernate的核心實現，提供了Hibernate所有的核心功能。
3）hibernate-entitymanager實現了標準的JPA，可以把它看成hibernate-core和JPA之間的介面卡，它並不直接提供ORM的功能，而是對hibernate-core進行封裝，使得Hibernate符合JPA的規範。
總的來說，JPA是規範，Hibernate是框架，JPA是持久化規範，而Hibernate實現了JPA。
三、JPA 概要
1、概述
JPA在應用中的位置如下圖所示：
JPA維護一個Persistence Context（持久化上下文），在持久化上下文中維護實體的生命週期。主要包含三個方面的內容：
- ORM元資料。JPA支援annotion或xml兩種形式描述物件-關係對映。
- 實體操作API。實現對實體物件的CRUD操作。
-
查詢語言。約定了面向物件的查詢語言JPQL（Java Persistence Query Language。
JPA的主要API都定義在javax.persistence包中。如果你熟悉Hibernate，可以很容易做出對應：
|
org.hibernate |
javax.persistence |
說明 |
|---|---|---|
| cfg.Configuration | Persistence | 讀取配置資訊 |
| SessionFactory | EntityManagerFactory | 用於建立會話/實體管理器的工廠類 |
| Session | EntityManager | 提供實體操作API，管理事務，建立查詢 |
| Transaction | EntityTransaction | 管理事務 |
| Query | Query | 執行查詢 |
2、實體生命週期
實體生命週期是JPA中非常重要的概念，描述了實體物件從建立到受控、從刪除到遊離的狀態變換。對實體的操作主要就是改變實體的狀態。
JPA中實體的生命週期如下圖：
- New，新建立的實體物件，沒有主鍵(identity)值
- Managed，物件處於Persistence Context(持久化上下文）中，被EntityManager管理
- Detached，物件已經遊離到Persistence Context之外，進入Application Domain
-
Removed, 實體物件被刪除
3、實體關係對映(ORM)
1)基本對映
|
物件端 |
資料庫端 |
annotion |
可選annotion |
|---|---|---|---|
| Class | Table | @Entity | @Table(name="tablename") |
| property | column | – | @Column(name = "columnname") |
| property | primary key | @Id | @GeneratedValue 詳見ID生成策略 |
| property | NONE | @Transient |
2)對映關係
JPA定義了one-to-one、one-to-many、many-to-one、many-to-many 4種關係。
對於資料庫來說，通常在一個表中記錄對另一個表的外來鍵關聯；對應到實體物件，持有關聯資料的一方稱為owning-side，另一方稱為inverse-side。
為了程式設計的方便，我們經常會希望在inverse-side也能引用到owning-side的物件，此時就構建了雙向關聯關係。 在雙向關聯中，需要在inverse-side定義mappedBy屬性，以指明在owning-side是哪一個屬性持有的關聯資料。
對關聯關係對映的要點如下：
|
關係型別 |
Owning-Side |
Inverse-Side |
|---|---|---|
| one-to-one | @OneToOne | @OneToOne(mappedBy="othersideName") |
| one-to-many / many-to-one | @ManyToOne | @OneToMany(mappedBy="xxx") |
| many-to-many | @ManyToMany | @ManyToMany(mappedBy ="xxx") |
其中 many-to-many關係的owning-side可以使用@JoinTable宣告自定義關聯表，比如Book和Author之間的關聯表：
@JoinTable(name = "BOOKAUTHOR", joinColumns = { @JoinColumn(name = "BOOKID", referencedColumnName = "id") }, inverseJoinColumns = { @JoinColumn(name = "AUTHORID", referencedColumnName = "id") })
關聯關係還可以定製延遲載入和級聯操作的行為（owning-side和inverse-side可以分別設定）：
通過設定fetch=FetchType.LAZY 或 fetch=FetchType.EAGER來決定關聯物件是延遲載入或立即載入。
通過設定cascade={options}可以設定級聯操作的行為，其中options可以是以下組合：
- CascadeType.MERGE 級聯更新
- CascadeType.PERSIST 級聯儲存
- CascadeType.REFRESH 級聯重新整理
- CascadeType.REMOVE 級聯刪除
-
CascadeType.ALL 級聯上述4種操作
4、事件及監聽
通過在實體的方法上標註@PrePersist，@PostPersist等宣告即可在事件發生時觸發這些方法。
四、JPA應用
1、Dependencies
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
</dependency>
<dependencies>
2、JPA提供的介面
主要來看看Spring Data JPA提供的介面，也是Spring Data JPA的核心概念：
1)：Repository：最頂層的介面，是一個空的介面，目的是為了統一所有Repository的型別，且能讓元件掃描的時候自動識別。
2)：CrudRepository ：是Repository的子介面，提供CRUD的功能
public interface CrudRepository<T, ID extends Serializable>extends Repository<T, ID> {
<S extends T> S save(S entity);
T findOne(ID primaryKey);
Iterable<T> findAll();
Long count();
void delete(T entity);
boolean exists(ID primaryKey);
// … more functionality omitted
}
3)：PagingAndSortingRepository：是CrudRepository的子介面，新增分頁和排序的功能
public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pageable);
}
4)：JpaRepository：是PagingAndSortingRepository的子介面，增加了一些實用的功能，比如：批量操作等。
5)：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);
}
6)：Specification：是Spring Data JPA提供的一個查詢規範，要做複雜的查詢，只需圍繞這個規範來設定查詢條件即可
3、查詢語言
3.1 根據名稱判別
|
Keyword |
Sample |
JPQL snippet |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
3.2 @Query
public interface UserRepository extends JpaRepository<User, Long> {
//Declare query at the query method using @Query
@Query("select u from User u where u.emailAddress = ?1")
User findByEmailAddress(String emailAddress);
//Advanced like-expressions in @Query
@Query("select u from User u where u.firstname like %?1")
List<User> findByFirstnameEndsWith(String firstname);
//Declare a native query at the query method using @Query
@Query(value = "SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1", nativeQuery = true)
User findByEmailAddress(String emailAddress);
//Declare native count queries for pagination at the query method using @Query
@Query(value = "SELECT * FROM USERS WHERE LASTNAME = ?1",countQuery = "SELECT count(*) FROM USERS WHERE LASTNAME = ?1",nativeQuery = true)
Page<User> findByLastname(String lastname, Pageable pageable);
//Declaring manipulating queries
@Modifying
@Query("update User u set u.firstname = ?1 where u.lastname = ?2")
int setFixedFirstnameFor(String firstname, String lastname);
}
3.3 複雜查詢 JpaSpecificationExecutor
Criteria 查詢：是一種型別安全和更面向物件的查詢
這個介面基本是圍繞著Specification介面來定義的， Specification介面中只定義瞭如下一個方法：
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
Criteria查詢
基本物件的構建
1：通過EntityManager的getCriteriaBuilder或EntityManagerFactory的getCriteriaBuilder方法可以得到CriteriaBuilder物件
2：通過呼叫CriteriaBuilder的createQuery或createTupleQuery方法可以獲得CriteriaQuery的例項
3：通過呼叫CriteriaQuery的from方法可以獲得Root例項
過濾條件
1：過濾條件會被應用到SQL語句的FROM子句中。在criteria 查詢中，查詢條件通過Predicate或Expression例項應用到CriteriaQuery物件上。
2：這些條件使用 CriteriaQuery .where 方法應用到CriteriaQuery 物件上
3：CriteriaBuilder也作為Predicate例項的工廠，通過呼叫CriteriaBuilder 的條件方法（ equal，notEqual， gt， ge，lt， le，between，like等）建立Predicate物件。
4：複合的Predicate 語句可以使用CriteriaBuilder的and, or andnot 方法構建
例項：
ImTeacher.java
@Entity
@Table(name = "im_teacher")
public class ImTeacher implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
@Column(name = "id")
private int id;
@Column(name = "teacher_id")
private int teacherId;
@Column(name = "name")
private String name = "";
@Column(name = "age")
private int age;
@Column(name = "sex")
private String sex = "";
...
}
ImTeacherDao.java
public interface ImTeacherDao extends PagingAndSortingRepository<ImTeacher, Integer>,JpaSpecificationExecutor{
...
}
@Service
public class ImTeacherDaoService {
@Autowired
ImTeacherDao imTeacherDao;
/**
* 複雜查詢測試
* @param page
*/
public Page<ImTeacher> findBySepc(int page, int size){
PageRequest pageReq = this.buildPageRequest(page, size);
Page<ImTeacher> imTeachers = this.imTeacherDao.findAll(new MySpec(), pageReq);
return imTeachers;
}
/**
* 建立分頁排序請求
*/
private PageRequest buildPageRequest(int page, int size) {
Sort sort = new Sort(Direction.DESC,"age");
return new PageRequest(page,size, sort);
}
private class MySpec implements Specification<ImTeacher>{
@Override
public Predicate toPredicate(Root<ImTeacher> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//1.混合條件查詢
Path<String> exp1 = root.get("name");
Path<String> exp2 = root.get("age");
query.where(cb.like(exp1, "%王%"),cb.equal(exp2, "45"));
//2.多表查詢
/*Join<ImTeacher,ImStudent> join = root.join("imStudent", JoinType.INNER);
Path<String> exp3 = join.get("name");
return cb.like(exp3, "%jy%");*/
return null;
}
}
}
3.4 分頁
上個例項的發雜查詢已經帶有分頁，若例項的DAO介面有繼承PagingAndSortingRepository介面，則可以直接呼叫
Page<ImTeacher> impeacher = imTeacherDao.findAll(new PageRequest(1,20));
3.5 聯表查詢
方法：
法一：直接用Query語句或者上節複雜的連線查詢，查出兩張或多張表的資料。
法二：對映，接下來將詳細介紹。
1）ImStudent.java
@Entity
@Table(name = "im_student")
public class ImStudent {
@Id
@GeneratedValue
@Column(name = "id")
private int id;
@Column(name = "student_id")
private int studentId;
@Column(name = "name")
private String name = "";
@Column(name = "age")
private int age;
@Column(name = "sex")
private String sex = "";
@Column(name = "teacher_id")
private int teacherId;
@ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH})
@JoinColumn(name="teacher_id", referencedColumnName="id", insertable=false, updatable=false)
private ImTeacher imTeacher;
...
}
2）在ImTeacher.java中新增
@OneToMany(mappedBy="imTeacher",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
private Set<ImStudent> imStudent = new HashSet<ImStudent>();
...
3）根據學生名字查出其老師資訊
@Query("SELECT teacher FROM ImTeacher teacher JOIN teacher.imStudent student WHERE student.name=:name")
ImTeacher findByStuName(@Param("name") String name);
根據老師名字查出其學生列表
@Query("SELECT student FROM ImStudent student JOIN student.imTeacher teacher WHERE teacher.name = :name")
Set<ImStudent> findByStudByTeaName(@Param("name") String name);
四、總結
1、Hibernate的DAO層開發比較簡單，對於剛接觸ORM的人來說，能夠簡化開發工程，提高開發速度。
2、Hibernate對物件的維護和快取做的很好，對增刪改查的物件的維護要方便。
3、Hibernate資料庫移植性比較好。
4、Hibernate功能強大，如果對其熟悉，對其進行一定的封裝，那麼專案的整個持久層程式碼會比較簡單。