深刻淺出學Spring Data JPA

第一章：Spring Data JPA入門

 

Spring Data是什麼

Spring Data是一個用於簡化數據庫訪問，並支持雲服務的開源框架。其主要目標是使得對數據的訪問變得方便快捷，並支持map-reduce框架和雲計算數據服務。 Spring Data 包含多個子項目：

Commons - 提供共享的基礎框架，適合各個子項目使用，支持跨數據庫持久化

JPA - 簡化建立 JPA 數據訪問層和跨存儲的持久層功能

Hadoop - 基於 Spring 的 Hadoop 做業配置和一個 POJO 編程模型的 MapReduce 做業

Key-Value  - 集成了 Redis 和 Riak ，提供多個經常使用場景下的簡單封裝

Document - 集成文檔數據庫：CouchDB 和 MongoDB 並提供基本的配置映射和資料庫支持

Graph - 集成 Neo4j 提供強大的基於 POJO 的編程模型

Graph Roo AddOn - Roo support for Neo4j

JDBC Extensions - 支持 Oracle RAD、高級隊列和高級數據類型

Mapping - 基於 Grails 的提供對象映射框架，支持不一樣的數據庫

Examples - 示例程序、文檔和圖數據庫

Guidance - 高級文檔

Spring Data JPA是什麼

由Spring提供的一個用於簡化JPA開發的框架

nSpring Data JPA能幹什麼

能夠極大的簡化JPA的寫法，能夠在幾乎不用寫實現的狀況下，實現對數據的訪問和操做。除了CRUD外，還包括如分頁、排序等一些經常使用的功能。

Spring Data JPA有什麼

主要來看看Spring Data JPA提供的接口，也是Spring Data JPA的核心概念：

1：Repository：最頂層的接口，是一個空的接口，目的是爲了統一全部Repository的類型，且能讓組件掃描的時候自動識別。

2：CrudRepository ：是Repository的子接口，提供CRUD的功能

3：PagingAndSortingRepository：是CrudRepository的子接口，添加分頁和排序的功能

4：JpaRepository：是PagingAndSortingRepository的子接口，增長了一些實用的功能，好比：批量操做等。

5：JpaSpecificationExecutor：用來作負責查詢的接口

6：Specification：是Spring Data JPA提供的一個查詢規範，要作複雜的查詢，只需圍繞這個規範來設置查詢條件便可

HelloWorld

n環境構建

在Eclipse裏面構建一個普通的Java工程，主要就是要加入一堆的jar包。

1：首先去官網下載Spring Data Common 和 Spring Data JPA的包，把裏面dist的jar包加入到工程中，這裏是spring-data-commons-1.5.0.RELEASE.jar和 spring-data-jpa-1.3.2.RELEASE.jar

2：把Spring3.2.3的jar包添加到工程中

3：JPA的實現選用的是Hibernate4.2.0，總共還須要額外加入以下的jar：

antlr-2.7.7.jar、aopalliance-1.0.jar、asm-3.2.jar、aspectjrt-1.7.1.jar、 aspectjweaver-1.7.1.jar、commons-beanutils-1.8.3.jar、commons-codec- 1.7.jar、commons-collections-3.2.1.jar、commons-dbcp-1.4.jar、commons- fileupload-1.2.2.jar、commons-io-2.4.jar、commons-lang3-3.1.jar、commons- logging-1.1.1.jar、commons-pool-1.6.jar、dom4j-1.6.1.jar、hibernate- commons-annotations-4.0.1.Final.jar、hibernate-core-4.2.0.Final.jar、 hibernate-entitymanager-4.2.0.Final.jar、hibernate-jpa-2.0-api- 1.0.1.Final.jar、javassist-3.15.0-GA.jar、jboss-logging-3.1.0.GA.jar、 jboss-transaction-api_1.1_spec-1.0.0.Final.jar、mysql-connector-java- 5.1.9.jar、slf4j-api-1.7.3.jar

n實體對象，就是之前的實現方式

@Entity

@Table(name="tbl_user")

public class UserModel {

@Id

private Integer uuid;

private String name;

private Integer age;

//省略getter/setter

}

nDAO的接口

public interface UserRepository extends JpaRepository<UserModel, Integer>{

//空的，能夠什麼都不用寫

}

無需提供實現，Spring Data JPA會爲咱們搞定一切

n寫個邏輯層的Service，其實就至關於DAO的客戶端，用來測試

@Service

@Transactional

public class Client {

@Autowired

private UserRepository ur;

 

public void testAdd(UserModel um){ ur.save(um); }

 

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

 

Client c = (Client)ctx.getBean("client");

UserModel um = new UserModel();

um.setAge(1);

um.setName("張三");

um.setUuid(1);

 

c.testAdd(um);

} }

 

第二章：JpaRepository基本功能

JpaRepository的基本功能示範

具體的看代碼演示

其中：Pageable接口的實現類是PageRequest，Page接口的實現類是PageImpl。

示例以下：

Page<UserModel> p =  ur.findAll(new PageRequest(0,2,new Sort(new Order(Direction. DESC,"uuid"))));

System. out.println("list="+p.getContent());

 

第三章：JpaRepository的查詢

直接在接口中定義查詢方法，若是是符合規範的，能夠不用寫實現，目前支持的關鍵字寫法以下：

Spring Data JPA框架在進行方法名解析時，會先把方法名多餘的前綴截取掉，好比 find、findBy、read、readBy、get、getBy，而後對剩下部分進行解析。

假如建立以下的查詢：findByUserDepUuid()，框架在解析該方法時，首先剔除 findBy，而後對剩下的屬性進行解析，假設查詢實體爲Doc

1：先判斷 userDepUuid （根據 POJO 規範，首字母變爲小寫）是否爲查詢實體的一個屬性，若是是，則表示根據該屬性進行查詢；若是沒有該屬性，繼續第二步；

2：從右往左截取第一個大寫字母開頭的字符串此處爲Uuid），而後檢查剩下的字符串是否爲查詢實體的一個屬性，若是是，則表示根據該屬性進行查詢；若是沒有該屬性，則重複第二步，繼續從右往左截取；最後假設user爲查詢實體的一個屬性；

3：接着處理剩下部分（DepUuid），先判斷 user 所對應的類型是否有depUuid屬性，若是有，則表示該方法最終是根據 「 Doc.user.depUuid」 的取值進行查詢；不然繼續按照步驟 2 的規則從右往左截取，最終表示根據 「Doc.user.dep.uuid」 的值進行查詢。

4:可能會存在一種特殊狀況，好比 Doc包含一個 user 的屬性，也有一個 userDep 屬性，此時會存在混淆。能夠明確在屬性之間加上 "_" 以顯式表達意圖，好比 "findByUser_DepUuid()" 或者 "findByUserDep_uuid()"

特殊的參數： 還能夠直接在方法的參數上加入分頁或排序的參數，好比：

Page<UserModel> findByName(String name, Pageable pageable);

List<UserModel> findByName(String name, Sort sort);

 

也可使用JPA的NamedQueries，方法以下：

1：在實體類上使用@NamedQuery，示例以下：

@NamedQuery(name = "UserModel.findByAge",query = "select o from UserModel o where o.age >= ?1")

2：在本身實現的DAO的Repository接口裏面定義一個同名的方法，示例以下：

public List<UserModel> findByAge(int age);

3：而後就可使用了，Spring會先找是否有同名的NamedQuery，若是有，那麼就不會按照接口定義的方法來解析。

 

使用@Query

能夠在自定義的查詢方法上使用@Query來指定該方法要執行的查詢語句，好比：

@Query("select o from UserModel o where o.uuid=?1")

public List<UserModel> findByUuidOrAge(int uuid);

注意：

1：方法的參數個數必須和@Query裏面須要的參數個數一致

2：若是是like，後面的參數須要前面或者後面加「%」，好比下面都對：

@Query("select o from UserModel o where o.name like ?1%")

public List<UserModel> findByUuidOrAge(String name);

 

@Query("select o from UserModel o where o.name like %?1")

public List<UserModel> findByUuidOrAge(String name);

 

@Query("select o from UserModel o where o.name like %?1%")

public List<UserModel> findByUuidOrAge(String name);

 

固然，這樣在傳遞參數值的時候就能夠不加‘%’了，固然加了也不會錯

 

n還可使用@Query來指定本地查詢，只要設置nativeQuery爲true，好比：

@Query(value="select * from tbl_user where name like %?1" ,nativeQuery=true)

public List<UserModel> findByUuidOrAge(String name);

注意：當前版本的本地查詢不支持翻頁和動態的排序

 

使用命名化參數，使用@Param便可，好比：

@Query(value="select o from UserModel o where o.name like %:nn")

public List<UserModel> findByUuidOrAge(@Param("nn") String name);

一樣支持更新類的Query語句，添加@Modifying便可，好比：

@Modifying

@Query(value="update UserModel o set o.name=:newName where o.name like %:nn")

public int findByUuidOrAge(@Param("nn") String name,@Param("newName") String newName);

注意：

1：方法的返回值應該是int，表示更新語句所影響的行數

2：在調用的地方必須加事務，沒有事務不能正常執行

 

JpaRepository的查詢功能

建立查詢的順序

Spring Data JPA 在爲接口建立代理對象時，若是發現同時存在多種上述狀況可用，它該優先採用哪一種策略呢？

<jpa:repositories> 提供了 query-lookup-strategy 屬性，用以指定查找的順序。它有以下三個取值：

1：create-if-not-found：若是方法經過@Query指定了查詢語句，則使用該語句實現查詢；若是沒有，則查找是否認義了符合條件的命 名查詢，若是找到，則使用該命名查詢；若是二者都沒有找到，則經過解析方法名字來建立查詢。這是 query-lookup-strategy 屬性的默認值

2：create：經過解析方法名字來建立查詢。即便有符合的命名查詢，或者方法經過 @Query指定的查詢語句，都將會被忽略

3：use-declared-query：若是方法經過@Query指定了查詢語句，則使用該語句實現查詢；若是沒有，則查找是否認義了符合條件的命名查詢，若是找到，則使用該命名查詢；若是二者都沒有找到，則拋出異常

 

第四章：客戶化擴展JpaRepository

若是你不想暴露那麼多的方法，能夠本身訂製本身的Repository，還能夠在本身的Repository裏面添加本身使用的公共方法

固然更靈活的是本身寫一個實現類，來實現本身須要的方法

1：寫一個與接口同名的類，加上後綴爲Impl，這個在前面xml裏面配置過，能夠自動被掃描到。這個類不須要實現任何接口。

2：在接口中加入本身須要的方法，好比：

public Page<Object[]> getByCondition(UserQueryModel u);

3：在實現類中，去實現這個方法就行了，會被自動找到

    public class UserRepositoryImpl {  
        @PersistenceContext  
        private EntityManager em;     
        public Page<Object[]> getByCondition(UserQueryModel u){  
    String hql = "select o.uuid,o.name from UserModel o where 1=1 and o.uuid=:uuid";  
            Query q = em.createQuery(hql);  
            q.setParameter("uuid", u.getUuid());          
            q.setFirstResult(0);  
            q.setMaxResults(1);       
    Page<Object[]> page = new PageImpl<Object[]>(q.getResultList(),new PageRequest(0,1),3);   
            return page;  
    }}  

第五章：Specifications查詢

Spring Data JPA支持JPA2.0的Criteria查詢，相應的接口是JpaSpecificationExecutor。

Criteria 查詢：是一種類型安全和更面向對象的查詢

 

這個接口基本是圍繞着Specification接口來定義的， Specification接口中只定義了以下一個方法：

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);

 

要理解這個方法，以及正確的使用它，就須要對JPA2.0的Criteria查詢有一個足夠的熟悉和理解，由於這個方法的參數和返回值都是JPA標準裏面定義的對象。

 

Criteria查詢基本概念

Criteria 查詢是以元模型的概念爲基礎的，元模型是爲具體持久化單元的受管實體定義的，這些實體能夠是實體類，嵌入類或者映射的父類。

CriteriaQuery接口：表明一個specific的頂層查詢對象，它包含着查詢的各個部分，好比：select 、from、where、group by、order by等

注意：CriteriaQuery對象只對實體類型或嵌入式類型的Criteria查詢起做用

Root接口：表明Criteria查詢的根對象，Criteria查詢的查詢根定義了實體類型，能爲未來導航得到想要的結果，它與SQL查詢中的FROM子句相似

1：Root實例是類型化的，且定義了查詢的FROM子句中可以出現的類型。

2：查詢根實例能經過傳入一個實體類型給 AbstractQuery.from方法得到。

3：Criteria查詢，能夠有多個查詢根。 

4：AbstractQuery是CriteriaQuery 接口的父類，它提供獲得查詢根的方法。

CriteriaBuilder接口：用來構建CritiaQuery的構建器對象

Predicate：一個簡單或複雜的謂詞類型，其實就至關於條件或者是條件組合。

 

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 方法構建。

 

構建簡單的Predicate示例：

Predicate p1=cb.like(root.get(「name」).as(String.class), 「%」+uqm.getName()+「%」);

Predicate p2=cb.equal(root.get("uuid").as(Integer.class), uqm.getUuid());

Predicate p3=cb.gt(root.get("age").as(Integer.class), uqm.getAge());

構建組合的Predicate示例：

Predicate p = cb.and(p3,cb.or(p1,p2));

 

固然也能夠形如前面動態拼接查詢語句的方式，好比：

    Specification<UserModel> spec = new Specification<UserModel>() {  
    public Predicate toPredicate(Root<UserModel> root,  
            CriteriaQuery<?> query, CriteriaBuilder cb) {  
        List<Predicate> list = new ArrayList<Predicate>();  
              
        if(um.getName()!=null && um.getName().trim().length()>0){  
            list.add(cb.like(root.get("name").as(String.class), "%"+um.getName()+"%"));  
        }  
        if(um.getUuid()>0){  
            list.add(cb.equal(root.get("uuid").as(Integer.class), um.getUuid()));  
        }  
        Predicate[] p = new Predicate[list.size()];  
        return cb.and(list.toArray(p));  
    }  
    };  

也可使用CriteriaQuery來獲得最後的Predicate，示例以下：

    Specification<UserModel> spec = new Specification<UserModel>() {  
        public Predicate toPredicate(Root<UserModel> root,  
                CriteriaQuery<?> query, CriteriaBuilder cb) {  
            Predicate p1 = cb.like(root.get("name").as(String.class), "%"+um.getName()+"%");  
            Predicate p2 = cb.equal(root.get("uuid").as(Integer.class), um.getUuid());  
            Predicate p3 = cb.gt(root.get("age").as(Integer.class), um.getAge());  
            //把Predicate應用到CriteriaQuery中去,由於還能夠給CriteriaQuery添加其餘的功能，好比排序、分組啥的  
            query.where(cb.and(p3,cb.or(p1,p2)));  
            //添加排序的功能  
            query.orderBy(cb.desc(root.get("uuid").as(Integer.class)));  
              
            return query.getRestriction();  
        }  
    };  

 

多表聯接

n多表鏈接查詢稍微麻煩一些，下面演示一下常見的1:M，順帶演示一下1:1

n使用Criteria查詢實現1對多的查詢

1：首先要添加一個實體對象DepModel，並設置好UserModel和它的1對多關係，以下：

@Entity

@Table(name="tbl_user")

public class UserModel {

@Id

private Integer uuid;

private String name;

private Integer age;

@OneToMany(mappedBy = "um", fetch = FetchType. LAZY, cascade = {CascadeType. ALL})

private Set<DepModel> setDep;

//省略getter/setter

}

 

@Entity

@Table(name="tbl_dep")

public class DepModel {

@Id

private Integer uuid;

private String name;

@ManyToOne()

  @JoinColumn(name = "user_id", nullable = false)

//表示在tbl_dep裏面有user_id的字段

private UserModel um = new UserModel();

//省略getter/setter

}

 

2：配置好Model及其關係後，就能夠在構建Specification的時候使用了，示例以下：

Specification<UserModel> spec = new Specification<UserModel>() {

public Predicate toPredicate(Root<UserModel> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

Predicate p1 = cb.like(root.get("name").as(String.class), "%"+um.getName()+"%");

Predicate p2 = cb.equal(root.get("uuid").as(Integer.class), um.getUuid());

Predicate p3 = cb.gt(root.get("age").as(Integer.class), um.getAge());

SetJoin<UserModel,DepModel> depJoin = root.join(root.getModel().getSet("setDep",DepModel.class) , JoinType.LEFT);

 

Predicate p4 = cb.equal(depJoin.get("name").as(String.class), "ddd");

//把Predicate應用到CriteriaQuery去,由於還能夠給CriteriaQuery添加其餘的功能，好比排序、分組啥 的

query.where(cb.and(cb.and(p3,cb.or(p1,p2)),p4));

//添加分組的功能

query.orderBy(cb.desc(root.get("uuid").as(Integer.class)));

return query.getRestriction();

}};

n接下來看看使用Criteria查詢實現1:1的查詢

1：在UserModel中去掉setDep的屬性及其配置，而後添加以下的屬性和配置：

@OneToOne()

@JoinColumn(name = "depUuid")

private DepModel dep;

public DepModel getDep() { return dep;}

public void setDep(DepModel dep) {this.dep = dep;  }

2：在DepModel中um屬性上的註解配置去掉，換成以下的配置：

@OneToOne(mappedBy = "dep", fetch = FetchType. EAGER, cascade = {CascadeType. ALL})

3：在Specification實現中，把SetJoin的那句換成以下的語句：

Join<UserModel,DepModel> depJoin =

root.join(root.getModel().getSingularAttribute("dep",DepModel.class),JoinType.LEFT);

//root.join(「dep」,JoinType.LEFT); //這句話和上面一句的功能同樣，更簡單