Spring Data 实战入门（1）Repository

Spring Data是SpringSource基金会下的一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。对于拥有海量数据的项目，可以用Spring Data来简化项目的开发。

然而针对不同的数据储存访问使用相对的类库来操作访问。Spring Data中已经为我们提供了很多业务中常用的一些接口和实现类来帮我们快速构建项目，比如分页、排序、DAO一些常用的操作。

下面总结一下使用 Spring Data JPA 进行持久层开发大致需要的三个步骤：

(1)声明持久层的接口，该接口继承 Repository，Repository 是一个标记型接口，它不包含任何方法，当然如果有需要，Spring Data 也提供了若干 Repository 子接口，其中定义了一些常用的增删改查，以及分页相关的方法。

(2)在接口中声明需要的业务方法。Spring Data 将根据给定的策略（具体策略稍后讲解）来为其生成实现代码。

(3)在 Spring 配置文件中增加一行声明，让 Spring 为声明的接口创建代理对象。配置了 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。
此外， 还提供了一些属性和子标签，便于做更细粒度的控制。可以在 内部使用 、 来过滤掉一些不希望被扫描到的接口。具体的使用方法见 Spring参考文档。

应该继承哪个接口？
前面提到，持久层接口继承 Repository 并不是唯一选择。Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法。与继承 Repository 等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定 domainClass 和 idClass 属性。如下两种方式是完全等价的：

public interface UserDao extends Repository<AccountInfo, Long> { …… } 

@RepositoryDefinition(domainClass = AccountInfo.class, idClass = Long.class) 
public interface UserDao { …… }

如果持久层接口较多，且每一个接口都需要声明相似的增删改查方法，直接继承 Repository 就显得有些啰嗦，这时可以继承 CrudRepository，它会自动为域对象创建增删改查方法，供业务层直接使用。开发者只是多写了 “Crud” 四个字母，即刻便为域对象提供了开箱即用的十个增删改查方法。

但是，使用 CrudRepository 也有副作用，它可能暴露了你不希望暴露给业务层的方法。比如某些接口你只希望提供增加的操作而不希望提供删除的方法。针对这种情况，开发者只能退回到 Repository 接口，然后到 CrudRepository 中把希望保留的方法声明复制到自定义的接口中即可。

分页查询和排序是持久层常用的功能，Spring Data 为此提供了 PagingAndSortingRepository 接口，它继承自 CrudRepository 接口，在 CrudRepository 基础上新增了两个与分页有关的方法。但是，我们很少会将自定义的持久层接口直接继承自 PagingAndSortingRepository，而是在继承 Repository 或 CrudRepository 的基础上，在自己声明的方法参数列表最后增加一个 Pageable 或 Sort 类型的参数，用于指定分页或排序信息即可，这比直接使用 PagingAndSortingRepository 提供了更大的灵活性。

JpaRepository 是继承自 PagingAndSortingRepository 的针对 JPA 技术提供的接口，它在父接口的基础上，提供了其他一些方法，比如 flush()，saveAndFlush()，deleteInBatch() 等。如果有这样的需求，则可以继承该接口。

上述四个接口，开发者到底该如何选择？其实依据很简单，根据具体的业务需求，选择其中之一。笔者建议在通常情况下优先选择 Repository 接口。因为 Repository 接口已经能满足日常需求，其他接口能做到的在 Repository 中也能做到，彼此之间并不存在功能强弱的问题。只是 Repository 需要显示声明需要的方法，而其他则可能已经提供了相关的方法，不需要再显式声明，但如果对 Spring Data JPA 不熟悉，别人在检视代码或者接手相关代码时会有疑惑，他们不明白为什么明明在持久层接口中声明了三个方法，而在业务层使用该接口时，却发现有七八个方法可用，从这个角度而言，应该优先考虑使用 Repository 接口。

前面提到，Spring Data JPA 在后台为持久层接口创建代理对象时，会解析方法名字，并实现相应的功能。除了通过方法名字以外，它还可以通过如下两种方式指定查询语句：

Spring Data JPA 可以访问 JPA 命名查询语句。开发者只需要在定义命名查询语句时，为其指定一个符合给定格式的名字，Spring Data JPA 便会在创建代理对象时，使用该命名查询语句来实现其功能。

开发者还可以直接在声明的方法上面使用 @Query 注解，并提供一个查询语句作为参数，Spring Data JPA 在创建代理对象时，便以提供的查询语句来实现其功能。

通过解析方法名创建查询

框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 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 为此提供了一些表达条件查询的关键字，大致如下：

• And — 等价于 SQL 中的 and 关键字，比如 findByUsernameAndPassword(String user, Striang pwd)；
• Or — 等价于 SQL 中的 or 关键字，比如 findByUsernameOrAddress(String user, String addr)；
• Between — 等价于 SQL 中的 between 关键字，比如 findBySalaryBetween(int max, int min)；
• LessThan — 等价于 SQL 中的 “<”，比如 findBySalaryLessThan(int max)；
• GreaterThan — 等价于 SQL 中的”>”，比如 findBySalaryGreaterThan(int min)；
• IsNull — 等价于 SQL 中的 “is null”，比如 findByUsernameIsNull()；
• IsNotNull — 等价于 SQL 中的 “is not null”，比如 findByUsernameIsNotNull()；
• NotNull — 与 IsNotNull 等价；
• Like — 等价于 SQL 中的 “like”，比如 findByUsernameLike(String user)；
• NotLike — 等价于 SQL 中的 “not like”，比如 findByUsernameNotLike(String user)；
• OrderBy — 等价于 SQL 中的 “order by”，比如 findByUsernameOrderBySalaryAsc(String user)；
• Not — 等价于 SQL 中的 “！ =”，比如 findByUsernameNot(String user)；
• In — 等价于 SQL 中的 “in”，比如 findByUsernameIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；
• NotIn — 等价于 SQL 中的 “not in”，比如 findByUsernameNotIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；

下面看一个实例：

package com.szc.dao;

import com.szc.pojo.Employee;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;
import org.springframework.data.repository.query.Param;

import java.util.List;

/**
 * 使用 Repository 接口
 * Created by Administrator on 2018/2/2 0002.
 */
//@RepositoryDefinition(domainClass = Employee.class,idClass = Integer.class)
public interface EmployeeRepository extends Repository<Employee,Integer> {

    //where name=?
    Employee findByName(String name);

    //where name=? and age=?
    List<Employee> findByNameAndAge(String name,Integer age);

    //where name like ?%
    List<Employee> findByNameStartingWith(String start);

    //where name like ?% and age <?
    List<Employee> findByNameStartingWithAndAgeLessThan(String name,Integer age);

    //where name in (?,?..) and age <=?
    List<Employee> findByNameInOrAgeLessThanEqual(List<String> names,Integer age);

    /**
     *  自定义查询 Employee 相当于 table(name="employee") 中定义的表名
     * @return
     */
    @Query("select o  from Employee o where id=(select max(id) from Employee t1)")
    Employee getEmployeeByMaxId();

    /**
     *  使用占位符进行参数绑定
     * */
    @Query("select o from  Employee o where o.name=?1 and o.age=?2 ")
    List<Employee> listEmployeeByNameAndAge(String name,Integer age);

    /**
     *  使用命名参数激进型参数绑定
     * */
    @Query("select o from  Employee o where o.name=:name and o.age=:age ")
    List<Employee> listEmployeeByNameAndAge2(@Param("name") String name1, @Param("age") Integer age);

    /**
     *  like 使用占位符进行参数绑定
     * */
    @Query("select o from  Employee o where name like %?1%")
    List<Employee> likeEmployeeByLikeName(String name);

    /**
     *  like 使用命名参数进行参数绑定
     * */
    @Query("select o from  Employee o where name like :name%")
    List<Employee> likeEmployeeByLikeName2(@Param("name") String name);

    @Query(nativeQuery = true,value = "select count(1) from employee;")
    long getCount();









}

下面是测试类

package com.szc.dao;


import com.szc.pojo.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;

/**
 * Unit test for simple App.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:beans.xml")
public class EmployeeRepositoryTest {

    private ApplicationContext applicationContext=null;

    @Autowired
    private EmployeeRepository employeeRepository;


    @Test
    public void testBean(){
        applicationContext=new ClassPathXmlApplicationContext("beans.xml");
        DataSource dataSource=applicationContext.getBean(DataSource.class);
    }

    @Test
    public void testEmployeeRepository(){
        Employee employee=employeeRepository.findByName("zhangsan");
        System.out.println(employee);
    }

    @Test
    public void testFindByNameAndAge(){
        List<Employee> list=employeeRepository.findByNameAndAge("zhangsan",20);
        System.out.println(list);
    }

    @Test
    public void testFindByNameStartingWith(){
        List<Employee> list=employeeRepository.findByNameStartingWith("z");
        System.out.println(list);
    }

    @Test
    public void testFindByNameStartingWithAndAgeLessThan(){
        List<Employee> list=employeeRepository.findByNameStartingWithAndAgeLessThan("z",16);
        System.out.println(list);
    }

    @Test
    public void testfindByNameInOrAgeLessThanEqual(){
        List<String> list=new ArrayList<>();
        list.add("zhangsan");
        list.add("lishi");
        list.add("zhangwu");
        List<Employee> listEmployees=employeeRepository.findByNameInOrAgeLessThanEqual(list,16);
        System.out.println(listEmployees);
    }

    @Test
    public void testGetEmployeeByMaxId(){
        Employee employee=employeeRepository.getEmployeeByMaxId();
        System.out.println(employee);
    }

    @Test
    public void testListEmployeeByNameAndAge(){
        List<Employee> list=employeeRepository.listEmployeeByNameAndAge("zhangsan",20);
        System.out.println(list);
    }

    @Test
    public void testListEmployeeByNameAndAge2(){
        List<Employee> list=employeeRepository.listEmployeeByNameAndAge2("zhangsan",20);
        System.out.println(list);
    }

    @Test
    public void testLikeEmployeeByLikeName(){
        List<Employee> list=employeeRepository.likeEmployeeByLikeName("w");
        System.out.println(list);
    }

    @Test
    public void testLikeEmployeeByLikeName2(){
        List<Employee> list=employeeRepository.likeEmployeeByLikeName2("w");
        System.out.println(list);
    }

    @Test
    public void testGetCount(){
        long num=employeeRepository.getCount();
        System.out.println(num);
    }
}