1.Spring Data JPA是什么
由Spring提供的一个用于简化JPA开发的框架。可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能
1.Spring Data JPA的核心概念：
1：Repository：最顶层的接口，是一个空的接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。
2：CrudRepository ：是Repository的子接口，提供CRUD的功能
3：PagingAndSortingRepository：是CrudRepository的子接口，添加分页和排序的功能
4：JpaRepository：是PagingAndSortingRepository的子接口，增加了一些实用的功能，比如：批量操作等。
5：JpaSpecificationExecutor：用来做负责查询的接口
6：Specification：是Spring Data JPA提供的一个查询规范，要做复杂的查询，只需围绕这个规范来设置查询条件即可
2.JpaRepository的查询
具体的关键字，使用方法和生产成SQL如下表所示
| 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(Collection age) | … 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) |
And => 等价于 SQL 中的 and 关键字 例如：findByUsernameAndPassword(String user, Striang pwd)； Or => 等价于 SQL 中的 or 关键字，例如：findByUsernameOrAddress(String user, String addr)； Between => 等价于 SQL 中的 between 关键字，例如：SalaryBetween(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<String> userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数； NotIn => 等价于 SQL 中的 "not in"，例如： findByUsernameNotIn(Collection<String> userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；
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指定了查询语句，则使用该语句实现查询；如果没有，则查找是否定义了符合条件的命名查询，如果找到，则使用该命名查询；如果两者都没有找到，则抛出异常
3.Specifications查询
分组条件查询：http://www.cnblogs.com/shaying/p/7344402.html
2.与springboot整合
maven：
<dependency
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
gradle：
dependencies {
compile('org.springframework.boot:spring-boot-starter-data-jpa')
}注：需要配置数据源
jpa可选配置
spring.jpa.database=
spring.jpa.show-sql=
spring.jpa.properties=
spring.jpa.generate-ddl=
spring.jpa.open-in-view=
spring.jpa.database-platform=
spring.jpa.hibernate.ddl-auto=
spring.data.jpa.repositories.enabled=
spring.jpa.hibernate.naming-strategy=
3.项目中部分java代码
@NoRepositoryBean
public interface DAOInterface<T> extends JpaRepository<T, String>, JpaSpecificationExecutor<T> { }
public interface JDCommodityRepository extends DAOInterface<JDCommodityBean> {
/**
* 分页查询商品
*/
Page<JDCommodityBean> findAll(Specification<JDCommodityBean> spec, Pageable pageable);
}@Transactional(rollbackFor = Exception.class)
@Service
public class JDCommodityServiceImpl extends BaseService<JDCommodityBean> implements JDCommodityService { @PersistenceContext
private EntityManager entityManager; @Autowired
private JDCommodityRepository jdCommodityRepository; @Override
public Page<JDCommodityBean> getJDCommodityListByPage(Integer pageNum, String name, String goodsCategory) {
Specification<JDCommodityBean> spec = new Specification<JDCommodityBean>() { /**
* 构造断言
*
* @param root
* 实体对象引用
* @param query
* 规则查询对象
* @param cb
* 规则构建对象
* @return 断言
*/
@Override
public Predicate toPredicate(Root<JDCommodityBean> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
List<Predicate> predicates = new ArrayList<>(); // 所有的断言集合
//默认
predicates.add(cb.equal(root.get("state").as(Integer.class), 1));// 上下架状态 1为上架，0为下架
predicates.add(cb.equal(root.get("saleState").as(Integer.class), 1));// 是否可售，1：是，0：否
predicates.add(cb.equal(root.get("isCanVAT").as(Integer.class), 1));// 是否可开增票，1：支持，0：不支持
predicates.add(cb.le(root.get("price").as(BigDecimal.class), 500));// 价格小于等于500
//自定义
// 商品名称
if(null != name && !"".equals(name) && !"''".equals(name) && name != "") {
predicates.add(cb.like(root.get("name").as(String.class), "%" + name + "%"));
}
// 商品分类
if(goodsCategory != null && !"".equals(goodsCategory) && !"''".equals(goodsCategory)) {
predicates.add(cb.equal(root.get("goodsCategory").as(String.class), goodsCategory));
} return cb.and(predicates.toArray(new Predicate[predicates.size()]));
}
};
Pageable pageable = new PageRequest(pageNum - 1, JDCommonConstant.COMMODITY_PAGE_SIZE);// 页码：前端从1开始，jpa从0开始
Page<JDCommodityBean> page = jdCommodityRepository.findAll(spec, pageable);
return page;
} @Override
protected EntityManager getEntityManager() {
return entityManager;
} @Override
protected DAOInterface<JDCommodityBean> getDAOInterface() {
return jdCommodityRepository;
} }
分页page属性：
"总记录数"+page.getTotalElements()
"当前第几页"+page.getNumber()
"总页数"+page.getTotalPages()
"当前页面的List"+page.getContent()
"当前页面的记录数"+page.getNumberOfElements()
参考：
https://legacy.gitbook.com/book/ityouknow/spring-data-jpa-reference-documentation/details
http://www.ityouknow.com/springboot/2016/08/20/springboot(%E4%BA%94)-spring-data-jpa%E7%9A%84%E4%BD%BF%E7%94%A8.html
续：
1.查询
规则:
find+全局修饰+By+实体的属性名称+限定词+连接词+ …(其它实体属性)+OrderBy+排序属性+排序方向
、查询所有数据 findAll()
、分页查询 findAll(new PageRequest(, ))
、根据id查询 findOne()
、根据实体类属性查询： findByProperty (type Property); 例如：findByAge(int age);
、排序： findAll(sort )
Sort sort = new Sort(Sort.Direction.DESC, "age").and (new Sort(Sort.Direction.DESC, "id"));
、条件查询 and/or/findByAgeLessThan/LessThanEqual 等，
例如： findByUsernameAndPassword(String username , String password)
、总数 查询 count() 或者 根据某个属性的值查询总数countByAge(int age);
、是否存在某个id exists()spring data jpa 利用JpaSpecificationExecutor做复杂查询：https://blog.csdn.net/yingxiake/article/details/51014223
2.增加
增加可以使用JpaRepository接口里面的save方法.查看源码可以发现实际上是使用了em.persist(entity)来使对象进入持久化状态,最后提交事务的时候再一起更新到数据库.
//保存单个
userRepository.save(user);
//保存或更新
userRepository.saveAndFlush(user); List<User> users = new ArrayList<>();
users.add(user);
//保存多个
userRepository.save(users);
3.修改
userRepository.saveAndFlush(user);
批量更新：
首先在service层获取持久化管理器:
@PersistenceContext
private EntityManager em;
批量更新方法,同理插入,删除也都可以如此做.
@Transactional
public void batchUpateCustom(List<User> users) {
// TODO Auto-generated method stub
for(int i = 0; i < users.size(); i++) {
em.merge(users.get(i));
if(i % 30== 0) {
em.flush();
em.clear();
}
}
}
4.删除
/**
* 删除都是根据主键删除
*/
//删除单条,根据主键值
userRepository.delete(20);
//删除全部,先findALL查找出来,再一条一条删除,最后提交事务
userRepository.deleteAll();
//删除全部,一条sql
userRepository.deleteAllInBatch(); List<User> users = new ArrayList<>();
users.add(user);
//删除集合,一条一条删除
userRepository.delete(users);
//删除集合,一条sql,拼接or语句 如 id=1 or id=2
userRepository.deleteInBatch(users);
5.判断
//根据主键判断是否存在
userRepository.exists(1); User user = new User();
user.setName("小红");
//根据条件判断是否存在
userRepository.exists(Example.of(user));
参考：https://blog.csdn.net/u012706811/article/details/53218083