关于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)

 

解析方法名--规则说明

一、规则描述

按照Spring data 定义的规则，查询方法以find|read|get开头（好比 find、findBy、read、readBy、get、getBy），涉及条件查询时，条件的属性用条件关键字链接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，而后对剩下部分进行解析。
若是方法的最后一个参数是 Sort 或者 Pageable 类型，也会提取相关的信息，以便按规则进行排序或者分页查询。
二、举例说明
好比 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开始计，第二个参数表示每页的数据量。最后在浏览器中分别测试这几个接口就能够了。