Repository:
public interface Repository<T, ID extends Serializable> {
}
这个接口只是一个空的接口，目的是为了统一所有Repository的类型，其接口类型使用了泛型，泛型参数中T代表实体类型，ID则是实体中id的类型。
CrudRepository:
持久层接口定义的比较多,且每个接口都需要声明相似的CURD的方法,直接继承Repository就比较繁琐.这时就可以继承CrudRepository,它会自动为域对象创建CRUD的方法,供业务层直接调用.
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
<S extends T> S save(S entity);
<S extends T> Iterable<S> save(Iterable<S> entities);
T findOne(ID id);
boolean exists(ID id);
Iterable<T> findAll();
Iterable<T> findAll(Iterable<ID> ids);
long count();
void delete(ID id);
void delete(T entity);
void delete(Iterable<? extends T> entities);
void deleteAll();
｝
该接口中的方法大多是访问数据库中常用的方法,如果需要,直接继承这个接口即可.但是CrudRepository也有副作用,它可能暴露不希望暴露给业务层的方法.这种情况下,只能退回继承Repository接口,在接口中显示声明需要暴露给业务层的方法.
PagingAndSortingRepository:
分页查询和排序是持久层常用的功能，Spring Data 为此提供了 PagingAndSortingRepository 接口，它继承自 CrudRepository 接口，在 CrudRepository 基础上新增了两个与分页有关的方法。
public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
Iterable<T> findAll(Sort sort);
Page<T> findAll(Pageable pageable);
}
但是，我们很少会将自定义的持久层接口直接继承自 PagingAndSortingRepository，而是在继承 Repository 或 CrudRepository 的基础上，在自己声明的方法参数列表最后增加一个 Pageable 或 Sort 类型的参数，用于指定分页或排序信息即可，这比直接使用 PagingAndSortingRepository 提供了更大的灵活性.
这些Repository都是spring-data-commons提供给我们的核心接口，spring-data-commons是Spring Data的核心包。这个接口中为我们提供了数据的分页方法，以及排序方法.
针对spring-data-jpa又提供了一系列repository接口，其中有JpaRepository和JpaSpecificationExecutor.
JpaRepository :
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
List<T> findAll();
List<T> findAll(Sort sort);
<S extends T> List<S> save(Iterable<S> entities);
void flush();
T saveAndFlush(T entity);
void deleteInBatch(Iterable<T> entities);
void deleteAllInBatch();
}
这个类继承自PagingAndSortingRepository，看其中的方法，可以看出里面的方法都是一些简单的操作，并未涉及到复杂的逻辑。当你在处理一些简单的数据逻辑时，便可继承此接口.
其实在业务中往往会涉及到多张表的查询，以及查询时需要的各种条件,此时就需要复杂业务查询了.spring data jpa提供了JpaSpecificationExecutor.
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);
}
在这个接口里面出现次数最多的类就是Specification.class，而这个类主要也就是围绕Specification来打造 的，Specification.class是Spring Data JPA提供的一个查询规范，只需围绕这个规范来设置查询条件便可.
Specification接口:
public interface Specification<T> {
/**
* </pre>
* JPA规范中的
* @param root ROOT查询中的条件表达式
* @param query 条件查询设计器
* @param cb 条件查询构造器
* @return
* </pre>
*/
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
}
在使用复杂对象查询时，实现该方法用JPA去构造对象查询便可.
Spring Data JPA 在后台为持久层接口创建代理对象时，会解析方法名字，并实现相应的功能。除了通过方法名字以外，它还可以通过如下两种方式指定查询语句:
- Spring Data JPA 可以访问 JPA 命名查询语句。只需要在定义命名查询语句时，为其指定一个符合给定格式的名字，Spring Data JPA 便会在创建代理对象时，使用该命名查询语句来实现其功能.
- 还可以直接在声明的方法上面使用 @Query 注解，并提供一个查询语句作为参数，Spring Data JPA 在创建代理对象时，便以提供的查询语句来实现其功能.
三种创建查询的方式
1.通过解析方法名创建查询
框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、getBy，然后对剩下部分进行解析。并且如果方法的最后一个参数是 Sort 或者 Pageable 类型，也会提取相关的信息，以便按规则进行排序或者分页查询。
直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，目前支持的关键字写法如下：
| KeyWord |
Sample |
JPQL snippet |
| And |
findByLastnameAndFirstname |
where x.lastname =?1 and x.firstname =?2 |
| Or |
findByLastnameOrFirstname |
where x.lastname = ?1 or x.firstname = ?2 |
| Between |
findByStartDateBetween |
where x.startData between 1? and 2? |
| LessThan |
findByAgeLessThan |
where x.age < ?1 |
| GreaterThan |
findByAgeGreaterThan |
where x.age >?1 |
| After |
findByStartDateAfter |
where x.startDate > ?1 |
| Before |
findByStartDateBefor |
where x.startDate < ?1 |
| IsNull |
findByAgeIsNull |
where x.age is null |
| IsNotNull,NotNull |
findByAge(Is)NotNull |
where x.age is not null |
| Like |
findByFirstnameLike |
where x.firstname like ?1 |
| NotLike |
findByFirstnameNotLike |
where x.firstname not like ?1 |
| StartingWith |
findByFirstnameStartingWith |
where x.firstname like ?1(如%?) |
| EndingWith |
findByFirstnameEndingWith |
where x.firstname like ?1(如?%) |
| Containing |
findByFirstnameContaining |
where x.fistaname like ?1(如%?%) |
| OrderBy |
findByFirstnameOrderByAgeDesc |
where x.firstname =?1 Order by x.age desc |
| Not |
findByLastnameNot |
where x.lastname <>?1 |
| In |
findByAgeIn(collegetion<Age> ages |
where x.age in ?1 |
| NotIn |
findByAgeNotIn(collegetion<Age> ages |
where x.age not in ?1 |
| True |
findByActiveTrue |
where x.active = true |
| false |
findbyActiveFalse |
where x.active =false
|
先去除findBy,剩下UserDepUuid.假设查询实体为Doc.假如创建如下的查询：findByUserDepUuid().
1.POJO规范,首字母小写.userDepUuid是不是Doc的一个属性,是,则根据该属性查询.如果不是,第二步.
2.从右往左截取第一个大写字母(Uuid),剩下userDep.检查userDep是否为Doc的属性,是,则根据该属性查询,如果不是,重复第二步,最后假设user为Doc的一个属性.
3.接着处理剩下(UepUuid),先判断user对应的类型是否有depUuid属性,有,则根据Doc.user.depUuid的取值进行查询. 没有,继续进行第二步,截取掉了Uuid,剩下dep,假设user对于类型有dep属性,最终Doc.user.dep.uuid的值进行查询.
4.可能会有一种特殊情况.比如Doc包含一个user属性,也有一个userDep属性,此时会存在混淆.可以明确在属性之间加上"_"以显示表示.如:findByUser_DepUuid() 或者 findByUserDep_uuid()
特殊的参数:还可以直接在方法的参数上加入分页或排序的参数: 比如:
Page<UserModel> findByName(String name,Pageable pageable);
List<UserModeel> findByName(String name,Sort sort);
也可以使用JPA的NameQueries,方法如下:
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，如果有，那么就不会按照接口定义的方法来解析。
2.使用@Query
@Query 注解的使用非常简单，只需在声明的方法上面标注该注解，同时提供一个 JP QL 查询语句即可，如下所示：
@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);
//当然，这样在传递参数值的时候就可以不加‘%’了，当然加了也不会错 还可以使用@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：在调用的地方必须加事务，没有事务不能正常执行 .
*/
3.JpaRepository的查询功能(创建查询的顺序)
Spring Data JPA 在为接口创建代理对象时，如果发现同时存在多种上述情况可用，它该优先采用哪种策略呢？
<jpa:repositories> 提供了 query-lookup-strategy 属性，用以指定查找的顺序。它有如下三个取值：
- create-if-not-found：如果方法通过@Query指定了查询语句，则使用该语句实现查询；如果没有，则查找是否定义了符合条件的命名查 询，如果找到，则使用该命名查询；如果两者都没有找到，则通过解析方法名字来创建查询。这是 query-lookup-strategy 属性的默认值
- create：通过解析方法名字来创建查询。即使有符合的命名查询，或者方法通过 @Query指定的查询语句，都将会被忽略
- use-declared-query：如果方法通过@Query指定了查询语句，则使用该语句实现查询；如果没有，则查找是否定义了符合条件的命名查询，如果找到，则使用该命名查询；如果两者都没有找到，则抛出异常
