今天刷網，才發現：
1）如果想用hibernate注解，是不是一定會用到jpa的？
是。如果hibernate認為jpa的注解夠用，就直接用。否則會弄一個自己的出來作為補充。
2）jpa和hibernate都提供了Entity，我們應該用哪個，還是說可以兩個一起用？
Hibernate的Entity是繼承了jpa的，所以如果覺得jpa的不夠用，直接使用hibernate的即可
正文：
一、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。
|
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)基本映射
| Class | Table | @Entity | @Table(name="tablename") |
| property | column | – | @Column(name = "columnname") |
| property | primary key | @Id | @GeneratedValue 詳見ID生成策略 |
| property | NONE | @Transient | |
|
對象端
|
數據庫端
|
annotion
|
可選annotion
|
|---|
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
2、JPA提供的接口
主要來看看Spring Data JPA提供的接口，也是Spring Data JPA的核心概念：
public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pageable);
}
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);
}
3、查詢語言
3.1 根據名稱判別
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Keyword
|
Sample
|
JPQL snippet
|
|---|
3.2 @Query
3.3 復雜查詢 JpaSpecificationExecutor
Criteria 查詢：是一種類型安全和更面向對象的查詢
這個接口基本是圍繞着Specification接口來定義的， Specification接口中只定義了如下一個方法：
Criteria查詢
實例：
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 聯表查詢
@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功能強大，如果對其熟悉，對其進行一定的封裝，那么項目的整個持久層代碼會比較簡單。