Jpa 語法和 demo

轉 http://www.cnblogs.com/jiangxiaoyaoblog/p/5635152.html

參考資料   https://www.w3cschool.cn/java/jpa-query-select-two-properties.html

 

1）若是想用hibernate註解，是否是必定會用到jpa的？

是。若是hibernate認爲jpa的註解夠用，就直接用。不然會弄一個本身的出來做爲補充。

2）jpa和hibernate都提供了Entity，咱們應該用哪一個，仍是說能夠兩個一塊兒用？

Hibernate的Entity是繼承了jpa的，因此若是以爲jpa的不夠用，直接使用hibernate的便可

 

 正文：

1、Hibernate VS Mybatis

一、簡介

    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實現

二、開發對比

    Hibernate的真正掌握要比Mybatis來得難些。Mybatis框架相對簡單很容易上手，但也相對簡陋些。我的以爲要用好Mybatis仍是首先要先理解好Hibernate。針對高級查詢，Mybatis須要手動編寫SQL語句，以及ResultMap。而Hibernate有良好的映射機制，開發者無需關心SQL的生成與結果映射，能夠更專一於業務流程

三、系統調優對比

Hibernate調優方案：

1. 制定合理的緩存策略；
2. 儘可能使用延遲加載特性；
3. 採用合理的Session管理機制；
4. 使用批量抓取，設定合理的批處理參數（batch_size）;
5. 進行合理的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進行日誌記錄。

四、緩存機制對比

Hibernate緩存：

Hibernate一級緩存是Session緩存，利用好一級緩存就須要對Session的生命週期進行管理好。建議在一個Action操做中使用一個Session。一級緩存須要對Session進行嚴格管理。Hibernate二級緩存是SessionFactory級的緩存。 SessionFactory的緩存分爲內置緩存和外置緩存。內置緩存中存放的是SessionFactory對象的一些集合屬性包含的數據(映射元素據及預約SQL語句等),對於應用程序來講,它是隻讀的。外置緩存中存放的是數據庫數據的副本,其做用和一級緩存相似.二級緩存除了之內存做爲存儲介質外,還能夠選用硬盤等外部存儲設備。二級緩存稱爲進程級緩存或SessionFactory級緩存，它能夠被全部session共享，它的生命週期伴隨着SessionFactory的生命週期存在和消亡。

Mybatis緩存：

MyBatis 包含一個很是強大的查詢緩存特性,它能夠很是方便地配置和定製。MyBatis 3 中的緩存實現的不少改進都已經實現了,使得它更增強大並且易於配置。

默認狀況下是沒有開啓緩存的,除了局部的 session 緩存,能夠加強變現並且處理循環 依賴也是必須的。要開啓二級緩存,你須要在你的 SQL 映射文件中添加一行:  <cache/>

字面上看就是這樣。這個簡單語句的效果以下:

1. 映射語句文件中的全部 select 語句將會被緩存。
2. 映射語句文件中的全部 insert,update 和 delete 語句會刷新緩存。
3. 緩存會使用 Least Recently Used(LRU,最近最少使用的)算法來收回。
4. 根據時間表(好比 no Flush Interval,沒有刷新間隔), 緩存不會以任什麼時候間順序 來刷新。
5. 緩存會存儲列表集合或對象(不管查詢方法返回什麼)的 1024 個引用。
6. 緩存會被視爲是 read/write(可讀/可寫)的緩存,意味着對象檢索不是共享的,而 且能夠安全地被調用者修改,而不干擾其餘調用者或線程所作的潛在修改。

全部的這些屬性均可以經過緩存元素的屬性來修改。

五、總結

Mybatis：小巧、方便、高效、簡單、直接、半自動

Hibernate：強大、方便、高效、複雜、繞彎子、全自動

2、Hibernate & JPA

一、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語句緊密耦合。

 二、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。

3、JPA 概要

一、概述

JPA在應用中的位置以下圖所示：

 

JPA維護一個Persistence Context（持久化上下文），在持久化上下文中維護實體的生命週期。主要包含三個方面的內容：

1. ORM元數據。JPA支持annotion或xml兩種形式描述對象-關係映射。
2. 實體操做API。實現對實體對象的CRUD操做。

3. 查詢語言。約定了面向對象的查詢語言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	執行查詢

二、實體生命週期

實體生命週期是JPA中很是重要的概念，描述了實體對象從建立到受控、從刪除到遊離的狀態變換。對實體的操做主要就是改變實體的狀態。

JPA中實體的生命週期以下圖：

1. New，新建立的實體對象，沒有主鍵(identity)值
2. Managed，對象處於Persistence Context(持久化上下文）中，被EntityManager管理
3. Detached，對象已經遊離到Persistence Context以外，進入Application Domain

4. Removed, 實體對象被刪除

三、實體關係映射(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 = "BOOK_AUTHOR", joinColumns = { @JoinColumn(name = "BOOK_ID", referencedColumnName = "id") }, inverseJoinColumns = { @JoinColumn(name = "AUTHOR_ID", 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種操做

四、事件及監聽

經過在實體的方法上標註@PrePersist，@PostPersist等聲明便可在事件發生時觸發這些方法。

4、JPA應用

一、Dependencies

<dependencies>

  <dependency>

    <groupId>org.springframework.data</groupId>

    <artifactId>spring-data-jpa</artifactId>

  </dependency>

<dependencies>

二、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.1 根據名稱判別

And	findByLastnameAndFirstname	… where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Is,Equals	findByFirstname,findByFirstnameIs,findByFirstnameEquals	… where x.firstname = ?1
Between	findByStartDateBetween	… where x.startDate between ?1 and ?2
LessThan	findByAgeLessThan	… where x.age < ?1
LessThanEqual	findByAgeLessThanEqual	… where x.age ⇐ ?1
GreaterThan	findByAgeGreaterThan	… where x.age > ?1
GreaterThanEqual	findByAgeGreaterThanEqual	… where x.age >= ?1
After	findByStartDateAfter	… where x.startDate > ?1
Before	findByStartDateBefore	… where x.startDate < ?1
IsNull	findByAgeIsNull	… where x.age is null
IsNotNull,NotNull	findByAge(Is)NotNull	… where x.age not null
Like	findByFirstnameLike	… where x.firstname like ?1
NotLike	findByFirstnameNotLike	… where x.firstname not like ?1
StartingWith	findByFirstnameStartingWith	… where x.firstname like ?1(parameter bound with appended %)
EndingWith	findByFirstnameEndingWith	… where x.firstname like ?1(parameter bound with prepended %)
Containing	findByFirstnameContaining	… where x.firstname like ?1(parameter bound wrapped in%)
OrderBy	findByAgeOrderByLastnameDesc	… where x.age = ?1 order by x.lastname desc
Not	findByLastnameNot	… where x.lastname <> ?1
In	findByAgeIn(Collection<Age> ages)	… where x.age in ?1
NotIn	findByAgeNotIn(Collection<Age> age)	… where x.age not in ?1
True	findByActiveTrue()	… where x.active = true
False	findByActiveFalse()	… where x.active = false
IgnoreCase	findByFirstnameIgnoreCase	… where UPPER(x.firstame) = UPPER(?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);

 

4、總結

一、Hibernate的DAO層開發比較簡單，對於剛接觸ORM的人來講，可以簡化開發工程，提升開發速度。

二、Hibernate對對象的維護和緩存作的很好，對增刪改查的對象的維護要方便。

三、Hibernate數據庫移植性比較好。

四、Hibernate功能強大，若是對其熟悉，對其進行必定的封裝，那麼項目的整個持久層代碼會比較簡單。

 

要麼有深度，要麼有趣，要麼安靜。