關於Spring data JPA

spring data jpa

JPA(Java Persistence API)是Sun官方提出的Java持久化規范。它為Java開發人員提供了一種對象/關聯映射工具來管理Java應用中的關系數據。他的出現主要是為了簡化現有的持久化開發工作和整合ORM技術，結束現在Hibernate，TopLink，JDO等ORM框架各自為營的局面。值得注意的是，JPA是在充分吸收了現有Hibernate，TopLink，JDO等ORM框架的基礎上發展而來的，具有易於使用，伸縮性強等優點。從目前的開發社區的反應上看，JPA受到了極大的支持和贊揚，其中就包括了Spring與EJB3.0的開發團隊。
注意:JPA是一套規范，不是一套產品，那么像Hibernate,TopLink,JDO他們是一套產品，如果說這些產品實現了這個JPA規范，那么我們就可以叫他們為JPA的實現產品。
spring data jpa
Spring Data JPA 是 Spring 基於 ORM 框架、JPA 規范的基礎上封裝的一套JPA應用框架，可使開發者用極簡的代碼即可實現對數據的訪問和操作。它提供了包括增刪改查等在內的常用功能，且易於擴展！學習並使用 Spring Data JPA 可以極大提高開發效率！
spring data jpa讓我們解脫了DAO層的操作，基本上所有CRUD都可以依賴於它來實現

 

關於spring data jpa查詢

基本查詢

基本查詢也分為兩種，一種是spring data默認已經實現，一種是根據查詢的方法來自動解析成SQL。

預先生成方法

spring data jpa 默認預先生成了一些基本的CURD的方法，例如：增、刪、改等等

1 繼承JpaRepository

public interface UserRepository extends JpaRepository<User, Long> { }

 

2 使用默認方法

@Test
public void testBaseQuery() throws Exception {
    User user=new User();
    userRepository.findAll();
    userRepository.findOne(1l);
    userRepository.save(user);
    userRepository.delete(user);
    userRepository.count();
    userRepository.exists(1l);
    // ...
}

 

就不解釋了根據方法名就看出意思來

自定義簡單查詢

自定義的簡單查詢就是根據方法名來自動生成SQL，主要的語法是findXXBy,readAXXBy,queryXXBy,countXXBy, getXXBy后面跟屬性名稱：

User findByUserName(String userName);

 

也使用一些加一些關鍵字And、 Or

User findByUserNameOrEmail(String username, String email);

 

修改、刪除、統計也是類似語法

Long deleteById(Long id); 
Long countByUserName(String userName)；

 

基本上SQL體系中的關鍵詞都可以使用，例如：LIKE、 IgnoreCase、 OrderBy。

List<User> findByEmailLike(String email); 
User findByUserNameIgnoreCase(String userName); 
List<User> findByUserNameOrderByEmailDesc(String email);

 

具體的關鍵字，使用方法和生產成SQL如下表所示

Keyword	Sample	JPQL snippet
And	findByLastnameAndFirstname	… where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Is,Equals	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 ages)	… where x.age in ?1
NotIn	findByAgeNotIn(Collectionage)	… 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)

 

解析方法名--規則說明

1、規則描述

按照Spring data 定義的規則，查詢方法以find|read|get開頭（比如 find、findBy、read、readBy、get、getBy），涉及條件查詢時，條件的屬性用條件關鍵字連接，要注意的是：條件屬性首字母需大寫。框架在進行方法名解析時，會先把方法名多余的前綴截取掉，然后對剩下部分進行解析。
如果方法的最后一個參數是 Sort 或者 Pageable 類型，也會提取相關的信息，以便按規則進行排序或者分頁查詢。
2、舉例說明
比如 findByUserAddressZip()。框架在解析該方法時，首先剔除 findBy，然后對剩下的屬性進行解析，詳細規則如下（此處假設該方法針對的域對象為 AccountInfo 類型）：
先判斷 userAddressZip （根據 POJO 規范，首字母變為小寫，下同）是否為 AccountInfo 的一個屬性，如果是，則表示根據該屬性進行查詢；如果沒有該屬性，繼續第二步；
從右往左截取第一個大寫字母開頭的字符串（此處為 Zip），然后檢查剩下的字符串是否為 AccountInfo 的一個屬性，如果是，則表示根據該屬性進行查詢；如果沒有該屬性，則重復第二步，繼續從右往左截取；最后假設 user 為 AccountInfo 的一個屬性；
接着處理剩下部分（ AddressZip ），先判斷 user 所對應的類型是否有 addressZip 屬性，如果有，則表示該方法最終是根據 "AccountInfo.user.addressZip" 的取值進行查詢；否則繼續按照步驟 2 的規則從右往左截取，最終表示根據 "AccountInfo.user.address.zip" 的值進行查詢。
可能會存在一種特殊情況，比如 AccountInfo 包含一個 user 的屬性，也有一個 userAddress 屬性，此時會存在混淆。讀者可以明確在屬性之間加上 "_" 以顯式表達意圖，比如 "findByUser_AddressZip()" 或者 "findByUserAddress_Zip()"。（強烈建議：無論是否存在混淆，都要在不同類層級之間加上"_" ，增加代碼可讀性）

分頁查詢

分頁查詢在實際使用中非常普遍了，spring data jpa已經幫我們實現了分頁的功能，在查詢的方法中，需要傳入參數Pageable

,當查詢中有多個參數的時候Pageable建議做為最后一個參數傳入

Page<User> findALL(Pageable pageable);   

Page<User> findByUserName(String userName,Pageable pageable);

 

Pageable 是spring封裝的分頁實現類，使用的時候需要傳入頁數、每頁條數和排序規則

@Test

public void testPageQuery() throws Exception {

    int page=1,size=10;

    Sort sort = new Sort(Direction.DESC, "id");

    Pageable pageable = new PageRequest(page, size, sort);

    userRepository.findALL(pageable);

    userRepository.findByUserName("testName", pageable);

}

 

自定義SQL查詢

其實Spring data 覺大部分的SQL都可以根據方法名定義的方式來實現，但是由於某些原因我們想使用自定義的SQL來查詢，spring data也是完美支持的；在SQL的查詢方法上面使用@Query注解，如涉及到刪除和修改在需要加上@Modifying.也可以根據需要添加 @Transactional 對事物的支持，查詢超時的設置等

@Modifying

@Query("update User u set u.userName = ?1 where c.id = ?2")

int modifyByIdAndUserId(String  userName, Long id);   

@Transactional

@Modifying

@Query("delete from User where id = ?1")

void deleteByUserId(Long id); 

@Transactional(timeout = 10)

@Query("select u from User u where u.emailAddress = ?1")

    User findByEmailAddress(String emailAddress);

 

多表查詢

多表查詢在spring data jpa中有兩種實現方式，第一種是利用hibernate的級聯查詢來實現，第二種是創建一個結果集的接口來接收連表查詢后的結果，這里主要第二種方式。

首先需要定義一個結果集的接口類。

public interface HotelSummary { 

    City getCity(); 

    String getName(); 

    Double getAverageRating(); 

    default Integer getAverageRatingRounded() {

        return getAverageRating() == null ? null : (int) Math.round(getAverageRating());

    } 

}

 

查詢的方法返回類型設置為新創建的接口

@Query("select h.city as city, h.name as name, avg(r.rating) as averageRating "

        - "from Hotel h left outer join h.reviews r where h.city = ?1 group by h")

Page<HotelSummary> findByCity(City city, Pageable pageable);

 

@Query("select h.name as name, avg(r.rating) as averageRating "

        - "from Hotel h left outer join h.reviews r  group by h")

Page<HotelSummary> findByCity(Pageable pageable);

 

使用

Page<HotelSummary> hotels = this.hotelRepository.findByCity(new PageRequest(0, 10, Direction.ASC, "name"));

for(HotelSummary summay:hotels){

        System.out.println("Name" +summay.getName());

    }

 

在運行中Spring會給接口（HotelSummary）自動生產一個代理類來接收返回的結果，代碼匯總使用getXX的形式來獲取

 

使用流程 

創建工程並添加相關依賴 

在Spring Boot中使用JPA，我們在創建工程的時候需要選擇JPA依賴，如下：  

  

這里寫圖片描述  

其他的步驟和我們創建一個普通的Spring Boot項目是一樣的，如果小伙伴不了解如何創建一個Spring Boot項目可以參考這篇文章初識Spring Boot框架。

項目創建成功之后，我這里是使用MySql做演示，因此還需要添加MySql驅動，在pom.xml文件中添加如下依賴：

       

 <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.40</version>

 </dependency>

配置基本屬性

接下來需要我們在application.properties中配置數據源和jpa的基本的相關屬性，如下：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/jpatest

spring.datasource.username=root

spring.datasource.password=123456
 

spring.jpa.hibernate.ddl-auto=update

spring.jpa.show-sql=true

spring.jackson.serialization.indent_output=true

 

關於這里的配置我說如下幾點：

1.第一行表示驅動的名稱，這個和具體的數據庫驅動有關，視情況而定，我這里使用了MySql數據庫，所以驅動名為com.mysql.jdbc.Driver

2.第二行表示數據庫連接地址，當然也是視情況而定

3.第三四行表示數據庫連接的用戶名和密碼

4.第五行則配置了實體類維護數據庫表結構的具體行為，update表示當實體類的屬性發生變化時，表結構跟着更新，這里我們也可以取值create，這個create表示啟動的時候刪除上一次生成的表，並根據實體類重新生成表，這個時候之前表中的數據就會被清空；還可以取值create-drop，這個表示啟動時根據實體類生成表，但是當sessionFactory關閉的時候表會被刪除；validate表示啟動時驗證實體類和數據表是否一致；none表示啥都不做。

5.第六行表示hibernate在操作的時候在控制台打印真實的sql語句

6.第七行表示格式化輸出的json字符串

定義映射實體類

接下來，定義相應的實體類，在Project啟動時，系統會根據實體類創建相應的數據表，我的實體類如下：

@Entity

@NamedQuery(name = "Person.withNameAndAddressNamedQuery",

        query = "select p from Person p where p.name=?1 and p.address=?2")

public class Person {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private Integer age;
    private String address; 

    public Person() {

    }
    public Person(Long id, String name, Integer age, String address) {

        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;

    } 

    public Long getId() {

        return id;

    } 
    public void setId(Long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    } 

    public void setName(String name) {

        this.name = name;

    } 

    public Integer getAge() {

        return age;

    } 

    public void setAge(Integer age) {

        this.age = age;

    } 

    public String getAddress() {

        return address;

    } 

    public void setAddress(String address) {

        this.address = address;

    }

}

 

 

首先在實體類上我們使用了@Entity注解，這個表示這是一個和數據庫表映射的實體類，在屬性id上我們添加了@Id注解，表示該字段是一個id，@GeneratedValue注解則表示該字段自增。@NamedQuery注解表示一個NamedQuery查詢，這里一個名稱代表一個查詢語句，我們一會可以在控制器中直接調用@NamedQuery中的withNameAndAddressNamedQuery方法，該方法代表的查詢語句是select p from Person p where p.name=?1 and p.address=?2。

定義數據訪問接口

OK，做好上面幾個步驟之后，接下來我們就可以定義數據訪問接口了，我們的數據訪問接口需要繼承JpaRepository類，我在數據訪問接口中一共定義了四個方法，如下：

public interface PersonRepository extends JpaRepository<Person, Long> {

    List<Person> findByAddress(String name); 

    Person findByNameAndAddress(String name, String address); 

    @Query("select p from Person p where p.name=:name and p.address=:address")

    Person withNameAndAddressQuery(@Param("name") String name, @Param("address") String address); 

    Person withNameAndAddressNamedQuery(String name, String address); 

}

 

 

關於這個數據訪問接口，我說如下幾點：

1.當我們繼承JpaRepository接口后，我們就自動具備了如下數據訪問方法：

List<T> findAll();

List<T> findAll(Sort var1);

List<T> findAll(Iterable<ID> var1);

<S extends T> List<S> save(Iterable<S> var1);

void flush();

<S extends T> S saveAndFlush(S var1);

void deleteInBatch(Iterable<T> var1);

void deleteAllInBatch();

T getOne(ID var1);

<S extends T> List<S> findAll(Example<S> var1);

<S extends T> List<S> findAll(Example<S> var1, Sort var2);

 

2.我們可以在接口中定義查詢方法，可以按照屬性名來查詢，但是方法的命名方式是固定的，比如第一個方法和第二個方法，第一個方法表示根據一個屬性查詢，第二個方法表示根據多個屬性查詢，findBy、And等可以算作是這里的查詢關鍵字了，如果寫作其他名稱則系統不能識別，類似的關鍵字還有Like、Or、Is、Equals、Between等，而這里的findBy關鍵字又可以被find、read、readBy、query、queryBy、get、getBy等來代替。

3.在查詢的過程中我們也可以限制查詢結果，這里使用的關鍵字是top、first等，比如查詢前10條數據我們可以寫作：

List<Person> findFirst10ByName(String name); 

4.使用NamedQuery來查詢，就是我們直接在實體類上使用@NamedQuery注解來定義查詢方法和方法名，一個名稱對應一個查詢語句，具體可以參考我們上文的實體類

5.我們也可以向第三個方法那樣添加@Query注解，當我調用這個方法的時候使用這個注解中的sql語句進行查詢，方法的參數則是注解中的占位符的值。

編寫測試Controller

數據訪問接口都有了，接下來就是一個Controller了，我們寫一個簡單的Controller，用來測試一下上文中的數據訪問接口是否正確，如下：

@RestController

public class DataController {

    @Autowired

    PersonRepository personRepository; 

    @RequestMapping("/save")

    public Person save(String name,String address,Integer age) {

        Person person = personRepository.save(new Person(null, name, age, address));

        return person;

    } 

    @RequestMapping("/q1")

    public List<Person> q1(String address) {

        List<Person> people = personRepository.findByAddress(address);

        return people;

    } 

    @RequestMapping("/q2")

    public Person q2(String name, String address) {

        Person people = personRepository.findByNameAndAddress(name, address);

        return people;

    } 

    @RequestMapping("/q3")

    public Person q3(String name, String address) {

        Person person = personRepository.withNameAndAddressQuery(name, address);

        return person;

    } 

    @RequestMapping("/q4")

    public Person q4(String name, String address) {

        Person person = personRepository.withNameAndAddressNamedQuery(name, address);

        return person;

    }

    @RequestMapping("/sort")

    public List<Person> sort() {

        List<Person> people = personRepository.findAll(new Sort(Sort.Direction.ASC, "age"));

        return people;

    }

    @RequestMapping("/page")

    public Page<Person> page(int page,int size){

        Page<Person> all = personRepository.findAll(new PageRequest(page, size));

        return all;

    }

    @RequestMapping("/all")

    public List<Person> all(){

        return personRepository.findAll();

    }

} 

這里的代碼都很簡單，我就不再一一進行解釋了，值得說的是第36行代碼表示根據age對查詢結果進行排序然后顯示出來，第40行的方法表示一個分頁查詢，第一個參數表示頁數，從0開始計，第二個參數表示每頁的數據量。最后在瀏覽器中分別測試這幾個接口就可以了。