https://blog.csdn.net/liuchuanhong1/article/details/52042477

使用Spring data JPA开发已经有一段时间了,这期间学习了一些东西,也遇到了一些问题,在这里和大家分享一下。

前言:

Spring data简介:

Spring Data是一个用于简化数据库访问,并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷,并支持map-reduce框架和云计算数据服务。 Spring Data 包含多个子项目:

Commons - 提供共享的基础框架,适合各个子项目使用,支持跨数据库持久化

JPA - 简化创建 JPA 数据访问层和跨存储的持久层功能

Hadoop - 基于 Spring 的 Hadoop 作业配置和一个 POJO 编程模型的 MapReduce 作业

Key-Value  - 集成了 Redis 和 Riak ,提供多个常用场景下的简单封装

Document - 集成文档数据库:CouchDB 和 MongoDB 并提供基本的配置映射和资料库支持

Graph - 集成 Neo4j 提供强大的基于 POJO 的编程模型

Graph Roo AddOn - Roo support for Neo4j

JDBC Extensions - 支持 Oracle RAD、高级队列和高级数据类型

Mapping - 基于 Grails 的提供对象映射框架,支持不同的数据库

Examples - 示例程序、文档和图数据库

Guidance - 高级文档

一、Spring data JPA简介

Spring data JPA是Spring在ORM框架,以及JPA规范的基础上,封装的一套JPA应用框架,并提供了一整套的数据访问层解决方案。

二、Spring data JPA的功能

Spring data JPA的功能非常的强大,这里我们先跳过环境搭建这一步,来一睹Spring data JPA的“芳容”。

Spring data JPA提供给用户使用的,主要有以下几个接口:

Repository:仅仅是一个标识,表明任何继承它的均为仓库接口类,方便Spring自动扫描识别 
CrudRepository:继承Repository,实现了一组CRUD相关的方法 
PagingAndSortingRepository:继承CrudRepository,实现了一组分页排序相关的方法 
JpaRepository:继承PagingAndSortingRepository,实现一组JPA规范相关的方法 
JpaSpecificationExecutor:比较特殊,不属于Repository体系,实现一组JPA Criteria查询相关的方法。

三、Spring data JPA的接口

1、CrudRepository接口

建立一个Entity类:

  1. @Entity
  2. @Table(name="USER")
  3. public class User {
  4. @Id
  5. @GeneratedValue
  6. private Integer id;
  7. //账号
  8. private String account;
  9. //姓名
  10. private String name;
  11. //密码
  12. private String password;
  13. // 邮箱
  14. private String email;
  15. }

编写接口,并继承CrudRepository接口:

  1. public interface UserRepository extends CrudRepository<User, Integer> {
  2. }

编写测试类(为了更直观的看到效果,所有测试类都没有使用断言,直接使用的打印语句):

  1. public class UserRepositoryTest {
  2. @Autowired
  3. private UserRepository dao;
  4. @Test//保存
  5. public void testSave(){
  6. User user = new User();
  7. user.setName("chhliu");
  8. user.setAccount("10000");
  9. user.setEmail("chhliu@.com");
  10. user.setPassword("123456");
  11. dao.save(user);
  12. }
  13. @Test//批量保存
  14. public void testSave1(){
  15. List<User> users = new ArrayList<User>();
  16. User user = new User();
  17. user.setName("tanjie");
  18. user.setAccount("10000");
  19. user.setEmail("tanjie@.com");
  20. user.setPassword("123456");
  21. users.add(user);
  22. user = new User();
  23. user.setName("esdong");
  24. user.setAccount("10000");
  25. user.setEmail("esdong@.com");
  26. user.setPassword("123456");
  27. users.add(user);
  28. user = new User();
  29. user.setName("qinhongfei");
  30. user.setAccount("10000");
  31. user.setEmail("qinhongfei@.com");
  32. user.setPassword("123456");
  33. users.add(user);
  34. user = new User();
  35. user.setName("huizhang");
  36. user.setAccount("10000");
  37. user.setEmail("huizhang@.com");
  38. user.setPassword("123456");
  39. users.add(user);
  40. user = new User();
  41. user.setName("caican");
  42. user.setAccount("10000");
  43. user.setEmail("caican@.com");
  44. user.setPassword("123456");
  45. users.add(user);
  46. dao.save(users);
  47. }
  48. @Test//更新
  49. public void testUpdate(){
  50. User user = dao.findOne(1);
  51. user.setPassword("123890");// 要想这样实现更新的功能,需要在service层加上@Transaction事物注解
  52. }
  53. @Test//删除
  54. public void testDelete(){
  55. dao.delete(2);
  56. }
  57. @Test//查询所有
  58. public void testFindAll(){
  59. List<User> users = (List<User>) dao.findAll();
  60. System.out.println(JSON.toJSONString(users));
  61. }
  62. @Test//判断指定的id对象是否存在
  63. public void testIsExist(){
  64. boolean isExist = dao.exists(8);
  65. System.out.println(isExist);
  66. }
  67. @Test//通过id列表来查询
  68. public void testFindUserByIds(){
  69. List<Integer> listIds = new ArrayList<Integer>();
  70. listIds.add(2);
  71. listIds.add(4);
  72. listIds.add(7);
  73. List<User> users = (List<User>) dao.findAll(listIds);
  74. System.out.println(JSON.toJSONString(users));
  75. }
  76. }

大家可以看出,到这里,我就只写了一个接口类,并没有实现这个接口类,就可以完成基本的CRUD操作。因为这个接口会自动为域对象创建增删改查方法,供业务层直接使用。

该接口的定义如下,总共提供了11个方法,基本上可以满足简单的CRUD操作以及批量操作:

  1. @NoRepositoryBean
  2. public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
  3. <S extends T> S save(S entity);//保存
  4. <S extends T> Iterable<S> save(Iterable<S> entities);//批量保存
  5. T findOne(ID id);//根据id查询一个对象
  6. boolean exists(ID id);//判断对象是否存在
  7. Iterable<T> findAll();//查询所有的对象
  8. Iterable<T> findAll(Iterable<ID> ids);//根据id列表查询所有的对象
  9. long count();//计算对象的总个数
  10. void delete(ID id);//根据id删除
  11. void delete(T entity);//删除对象
  12. void delete(Iterable<? extends T> entities);//批量删除
  13. void deleteAll();//删除所有
  14. }

2、PagingAndSortingRepository接口

PagingAndSortingRepository接口继承了CrudRepository接口。

编写接口,并继承PagingAndSortingRepository接口

  1. public interface UserRepositoryWithOrder extends
  2. PagingAndSortingRepository<User, Integer> {
  3. }

编写测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = { "classpath:applicationContext-config.xml" })
  3. @TransactionConfiguration(defaultRollback = false)
  4. @Transactional
  5. public class UserRepositoryWithOrderTest {
  6. @Autowired
  7. private UserRepositoryWithOrder dao;
  8. @Test
  9. public void testOrder(){
  10. Sort sort = new Sort(Direction.DESC, "id");
  11. Pageable pageable = new PageRequest(0, 5, sort);
  12. Page<User> page = dao.findAll(pageable);
  13. System.out.println(JSON.toJSONString(page));
  14. System.out.println(page.getSize());
  15. }
  16. }

只要继承了这个接口,Spring data JPA就已经为你提供了分页和排序的功能了。该接口的定义如下,主要提供了两个方法,供使用,其中T是要操作的实体类,ID是实体类主键的类型

  1. @NoRepositoryBean
  2. public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
  3. Iterable<T> findAll(Sort sort);// 不带分页的排序
  4. Page<T> findAll(Pageable pageable);// 带分页的排序
  5. }

3、JpaRepository接口

如果业务需要即提供CRUD操作,又需要提供分页以及排序功能,那么就可以直接继承这个接口。该接口继承了PagingAndSortingRepository接口。

接口定义如下:

  1. public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
  2. List<T> findAll();//查询所有对象,不排序
  3. List<T> findAll(Sort sort);//查询所有对象,并排序
  4. <S extends T> List<S> save(Iterable<S> entities);//批量保存
  5. void flush();//强制缓存与数据库同步
  6. T saveAndFlush(T entity);//保存并强制同步
  7. void deleteInBatch(Iterable<T> entities);//批量删除
  8. void deleteAllInBatch();//删除所有
  9. }

4、JpaSpecificationExecutor接口

该接口提供了对JPA Criteria查询的支持。注意,这个接口很特殊,不属于Repository体系,而Spring data JPA不会自动扫描识别,所以会报找不到对应的Bean,我们只需要继承任意一个继承了Repository的子接口或直接继承Repository接口,Spring data JPA就会自动扫描识别,进行统一的管理。

编写接口如下:

  1. public interface SpecificationExecutorRepository extends CrudRepository<User, Integer>,
  2. JpaSpecificationExecutor<User> {
  3. }

Service类:

  1. @Service
  2. public class SpecificationExecutorRepositoryManager {
  3. @Autowired
  4. private SpecificationExecutorRepository dao;
  5. /**
  6. * 描述:根据name来查询用户
  7. */
  8. public User findUserByName(final String name){
  9. return dao.findOne(new Specification<User>() {
  10. @Override
  11. public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query,
  12. CriteriaBuilder cb) {
  13. Predicate predicate = cb.equal(root.get("name"), name);
  14. return predicate;
  15. }
  16. });
  17. }
  18. /**
  19. * 描述:根据name和email来查询用户
  20. */
  21. public User findUserByNameAndEmail(final String name, final String email){
  22. return dao.findOne(new Specification<User>() {
  23. @Override
  24. public Predicate toPredicate(Root<User> root,
  25. CriteriaQuery<?> query, CriteriaBuilder cb) {
  26. List<Predicate> list = new ArrayList<Predicate>();
  27. Predicate predicate1 = cb.equal(root.get("name"), name);
  28. Predicate predicate2 = cb.equal(root.get("email"), email);
  29. list.add(predicate1);
  30. list.add(predicate2);
  31. // 注意此处的处理
  32. Predicate[] p = new Predicate[list.size()];
  33. return cb.and(list.toArray(p));
  34. }
  35. });
  36. }
  37. /**
  38. * 描述:组合查询
  39. */
  40. public User findUserByUser(final User userVo){
  41. return dao.findOne(new Specification<User>() {
  42. @Override
  43. public Predicate toPredicate(Root<User> root,
  44. CriteriaQuery<?> query, CriteriaBuilder cb) {
  45. Predicate predicate = cb.equal(root.get("name"), userVo.getName());
  46. cb.and(predicate, cb.equal(root.get("email"), userVo.getEmail()));
  47. cb.and(predicate, cb.equal(root.get("password"), userVo.getPassword()));
  48. return predicate;
  49. }
  50. });
  51. }
  52. /**
  53. * 描述:范围查询in方法,例如查询用户id在[2,10]中的用户
  54. */
  55. public List<User> findUserByIds(final List<Integer> ids){
  56. return dao.findAll(new Specification<User>() {
  57. @Override
  58. public Predicate toPredicate(Root<User> root,
  59. CriteriaQuery<?> query, CriteriaBuilder cb) {
  60. return root.in(ids);
  61. }
  62. });
  63. }
  64. /**
  65. * 描述:范围查询gt方法,例如查询用户id大于9的所有用户
  66. */
  67. public List<User> findUserByGtId(final int id){
  68. return dao.findAll(new Specification<User>() {
  69. @Override
  70. public Predicate toPredicate(Root<User> root,
  71. CriteriaQuery<?> query, CriteriaBuilder cb) {
  72. return cb.gt(root.get("id").as(Integer.class), id);
  73. }
  74. });
  75. }
  76. /**
  77. * 描述:范围查询lt方法,例如查询用户id小于10的用户
  78. */
  79. public List<User> findUserByLtId(final int id){
  80. return dao.findAll(new Specification<User>() {
  81. @Override
  82. public Predicate toPredicate(Root<User> root,
  83. CriteriaQuery<?> query, CriteriaBuilder cb) {
  84. return cb.lt(root.get("id").as(Integer.class), id);
  85. }
  86. });
  87. }
  88. /**
  89. * 描述:范围查询between方法,例如查询id在3和10之间的用户
  90. */
  91. public List<User> findUserBetweenId(final int start, final int end){
  92. return dao.findAll(new Specification<User>() {
  93. @Override
  94. public Predicate toPredicate(Root<User> root,
  95. CriteriaQuery<?> query, CriteriaBuilder cb) {
  96. return cb.between(root.get("id").as(Integer.class), start, end);
  97. }
  98. });
  99. }
  100. /**
  101. * 描述:排序和分页操作
  102. */
  103. public Page<User> findUserAndOrder(final int id){
  104. Sort sort = new Sort(Direction.DESC, "id");
  105. return dao.findAll(new Specification<User>() {
  106. @Override
  107. public Predicate toPredicate(Root<User> root,
  108. CriteriaQuery<?> query, CriteriaBuilder cb) {
  109. return cb.gt(root.get("id").as(Integer.class), id);
  110. }
  111. }, new PageRequest(0, 5, sort));
  112. }
  113. /**
  114. * 描述:只有排序操作
  115. */
  116. public List<User> findUserAndOrderSecondMethod(final int id){
  117. return dao.findAll(new Specification<User>() {
  118. @Override
  119. public Predicate toPredicate(Root<User> root,
  120. CriteriaQuery<?> query, CriteriaBuilder cb) {
  121. cb.gt(root.get("id").as(Integer.class), id);
  122. query.orderBy(cb.desc(root.get("id").as(Integer.class)));
  123. return query.getRestriction();
  124. }
  125. });
  126. }
  127. }

测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = { "classpath:applicationContext-config.xml" })
  3. @TransactionConfiguration(defaultRollback = false)
  4. @Transactional
  5. public class SpecificationExecutorRepositoryManagerTest {
  6. @Autowired
  7. private SpecificationExecutorRepositoryManager manager;
  8. @Test
  9. public void testFindUserByName(){
  10. User user = manager.findUserByName("chhliu");
  11. System.out.println(JSON.toJSONString(user));
  12. }
  13. @Test
  14. public void testFindUserByNameAndEmail(){
  15. User user = manager.findUserByNameAndEmail("chhliu", "chhliu@.com");
  16. System.out.println(JSON.toJSONString(user));
  17. }
  18. @Test
  19. public void testFindUserByUserVo(){
  20. User user = new User();
  21. user.setName("chhliu");
  22. user.setEmail("chhliu@.com");
  23. User u = manager.findUserByUser(user);
  24. System.out.println(JSON.toJSONString(u));
  25. }
  26. @Test
  27. public void testFindUserByIds(){
  28. List<User> users = manager.findUserByIds(new ArrayList<Integer>(Arrays.asList(1,3,5,6)));
  29. System.out.println(JSON.toJSONString(users));
  30. }
  31. @Test
  32. public void testFindUserByGtId(){
  33. List<User> users = manager.findUserByGtId(5);
  34. System.out.println(JSON.toJSONString(users));
  35. }
  36. @Test
  37. public void testFindUserByLtId(){
  38. List<User> users = manager.findUserByLtId(5);
  39. System.out.println(JSON.toJSONString(users));
  40. }
  41. @Test
  42. public void testFindUserBetweenId(){
  43. List<User> users = manager.findUserBetweenId(4, 9);
  44. System.out.println(JSON.toJSONString(users));
  45. }
  46. @Test
  47. public void testFindUserAndOrder(){
  48. Page<User> users = manager.findUserAndOrder(1);
  49. System.out.println(JSON.toJSONString(users));
  50. }
  51. @Test
  52. public void testFindUserAndOrderSecondMethod(){
  53. List<User> users = manager.findUserAndOrderSecondMethod(1);
  54. System.out.println(JSON.toJSONString(users));
  55. }
  56. }

5、Repository接口

这个接口是最基础的接口,只是一个标志性的接口,没有定义任何的方法,那这个接口有什么用了?既然Spring data JPA提供了这个接口,自然是有它的用处,例如,我们有一部分方法是不想对外提供的,比如我们只想提供增加和修改方法,不提供删除方法,那么前面的几个接口都是做不到的,这个时候,我们就可以继承这个接口,然后将CrudRepository接口里面相应的方法拷贝到Repository接口就可以了。

总结:上述五个接口,开发者到底该如何选择?其实依据很简单,根据具体的业务需求,选择其中之一。因为各个接口之间并不存在功能强弱的问题。

四、Spring data JPA的查询

1、使用 @Query 创建查询

@Query 注解的使用非常简单,只需在声明的方法上面标注该注解,同时提供一个 JP QL 查询语句即可。很多开发者在创建 JP QL 时喜欢使用命名参数来代替位置编号,@Query 也对此提供了支持。JP QL 语句中通过": 变量"的格式来指定参数,同时在方法的参数前面使用 @Param 将方法参数与 JP QL 中的命名参数对应。此外,开发者也可以通过使用 @Query 来执行一个更新操作,为此,我们需要在使用 @Query 的同时,用 @Modifying 来将该操作标识为修改查询,这样框架最终会生成一个更新的操作,而非查询操作。

编写接口,如下:

  1. /**
  2. * 描述:自定义查询,当Spring Data JPA无法提供时,需要自定义接口,此时可以使用这种方式
  3. */
  4. public interface UserDefineBySelf extends JpaRepository<User, Integer> {
  5. /**
  6. * 命名参数
  7. * 描述:推荐使用这种方法,可以不用管参数的位置
  8. */
  9. @Query("select u from User u where u.name = :name")
  10. User findUserByName(@Param("name") String name);
  11. /**
  12. * 索引参数
  13. * 描述:使用?占位符
  14. */
  15. @Query("select u from User u where u.email = ?1")// 1表示第一个参数
  16. User findUserByEmail(String email);
  17. /**
  18. * 描述:可以通过@Modifying和@Query来实现更新
  19. * 注意:Modifying queries的返回值只能为void或者是int/Integer
  20. */
  21. @Modifying
  22. @Query("update User u set u.name = :name where u.id = :id")
  23. int updateUserById(@Param("name") String name, @Param("id") int id);
  24. }
注:@Modifying注解里面有一个配置clearAutomatically
它说的是可以清除底层持久化上下文,就是entityManager这个类,我们知道jpa底层实现会有二级缓存,也就是在更新完数据库后,如果后面去用这个对象,你再去查这个对象,这个对象是在一级缓存,但是并没有跟数据库同步,这个时候用clearAutomatically=true,就会刷新hibernate的一级缓存了,
不然你在同一接口中,更新一个对象,接着查询这个对象,那么你查出来的这个对象还是之前的没有更新之前的状态

测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = { "classpath:applicationContext-config.xml" })
  3. @TransactionConfiguration(defaultRollback = false)
  4. @Transactional
  5. public class UserDefineBySelfTest {
  6. @Autowired
  7. private UserDefineBySelf dao;
  8. @Test
  9. public void testFindUserByName(){
  10. User user = dao.findUserByName("chhliu");
  11. Assert.assertEquals("chhliu", user.getName());
  12. System.out.println(user.getName());
  13. }
  14. @Test
  15. public void testFindUserByEmail(){
  16. User user = dao.findUserByEmail("chhliu@.com");
  17. Assert.assertEquals("chhliu", user.getName());
  18. System.out.println(user.getName());
  19. }
  20. @Test
  21. public void testUpdateUserById(){
  22. dao.updateUserById("tanjie", 4);
  23. }
  24. }

从测试代码可以看出,我们同样只定义了接口,没有任何的实现类,但是却实现了我们所需要的功能。

2、使用@NamedQueries创建查询

命名查询是 JPA 提供的一种将查询语句从方法体中独立出来,以供多个方法共用的功能。Spring Data JPA 对命名查询也提供了很好的支持。用户只需要按照 JPA 规范在 orm.xml 文件或者在代码中使用 @NamedQuery(或 @NamedNativeQuery)定义好查询语句,唯一要做的就是为该语句命名时,需要满足”DomainClass.methodName()”的 命名规则。

编写接口:

  1. public interface FindUserByNamedQueryRepository extends JpaRepository<User, Integer> {
  2. User findUserWithName(@Param("name") String name);
  3. }

编写类:

  1. @Entity
  2. @NamedQueries(value={
  3. @NamedQuery(name="User.findUserWithName",query="select u from User u where u.name = :name")
  4. })
  5. // 注意:此处如果是多个方法,那么需要使用@NamedQueries,如果只有一个方法,则可以使用@NamedQuery,写法如下:@NamedQuery(name="User.findUserWithName",query="select u from User u where u.name = :name")
  6. public class FindUserByNamedQuery {
  7. /**
  8. * 注意:此处必须要给这个实体类定义一个唯一标识,否则会报异常
  9. */
  10. @Id
  11. @GeneratedValue
  12. private Integer id;
  13. }

注意:文中标记为红色的部分,需要一一对应,否则不满足JPA 的规范。

测试类:

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = { "classpath:applicationContext-config.xml" })
  3. @TransactionConfiguration(defaultRollback = false)
  4. @Transactional
  5. public class FindUserByNamedQueryRepositoryTest {
  6. @Autowired
  7. private FindUserByNamedQueryRepository dao;
  8. @Test
  9. public void testFindUserByName(){
  10. User user = dao.findUserWithName("caican");
  11. System.out.println(JSON.toJSONString(user));
  12. }
  13. }

3、通过解析方法名创建查询

顾名思义,就是根据方法的名字,就能创建查询,也许初听起来,感觉很不可思议,等测试后才发现,原来一切皆有可能。

编写接口:

  1. public interface SimpleConditionQueryRepository extends JpaRepository<User, Integer> {
  2. /**
  3. * 说明:按照Spring data 定义的规则,查询方法以find|read|get开头
  4. * 涉及条件查询时,条件的属性用条件关键字连接,要注意的是:条件属性首字母需大写
  5. */
  6. /**
  7. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name = :name and u.email = :email
  8. * 参数名大写,条件名首字母大写,并且接口名中参数出现的顺序必须和参数列表中的参数顺序一致
  9. */
  10. User findByNameAndEmail(String name, String email);
  11. /**
  12. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name = ?1 or u.password = ?2
  13. */
  14. List<User> findByNameOrPassword(String name, String password);
  15. /**
  16. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.id between ?1 and ?2
  17. */
  18. List<User> findByIdBetween(Integer start, Integer end);
  19. /**
  20. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.id < ?1
  21. */
  22. List<User> findByIdLessThan(Integer end);
  23. /**
  24. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.id > ?1
  25. */
  26. List<User> findByIdGreaterThan(Integer start);
  27. /**
  28. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name is null
  29. */
  30. List<User> findByNameIsNull();
  31. /**
  32. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name is not null
  33. */
  34. List<User> findByNameIsNotNull();
  35. /**
  36. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name like ?1
  37. */
  38. List<User> findByNameLike(String name);
  39. /**
  40. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name not like ?1
  41. */
  42. List<User> findByNameNotLike(String name);
  43. /**
  44. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.password = ?1 order by u.id desc
  45. */
  46. List<User> findByPasswordOrderByIdDesc(String password);
  47. /**
  48. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.name <> ?1
  49. */
  50. List<User> findByNameNot(String name);
  51. /**
  52. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.id in ?1
  53. */
  54. List<User> findByIdIn(List<Integer> ids);
  55. /**
  56. * 注:此处这个接口相当于发送了一条SQL:select u from User u where u.id not in ?1
  57. */
  58. List<User> findByIdNotIn(List<Integer> ids);
  59. }

测试类(注释部分为实际发送的sql语句):

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = { "classpath:applicationContext-config.xml" })
  3. @TransactionConfiguration(defaultRollback = false)
  4. @Transactional
  5. public class SimpleConditionQueryRepositoryTest {
  6. @Autowired
  7. private SimpleConditionQueryRepository dao;
  8. /**
  9. * select
  10. user0_.id as id0_,
  11. user0_.account as account0_,
  12. user0_.email as email0_,
  13. user0_.name as name0_,
  14. user0_.password as password0_
  15. from
  16. USER user0_
  17. where
  18. user0_.name=?
  19. and user0_.email=? limit ?
  20. */
  21. @Test
  22. public void testFindUserByNameAndEmail(){
  23. User user = dao.findByNameAndEmail("chhliu", "chhliu@.com");
  24. System.out.println(JSON.toJSONString(user));
  25. }
  26. /**
  27. * select
  28. user0_.id as id1_,
  29. user0_.account as account1_,
  30. user0_.email as email1_,
  31. user0_.name as name1_,
  32. user0_.password as password1_
  33. from
  34. USER user0_
  35. where
  36. user0_.name=?
  37. or user0_.password=?
  38. */
  39. @Test
  40. public void testFindUserByNameOrPassword(){
  41. List<User> users = dao.findByNameOrPassword("chhliu", "123456");
  42. System.out.println(JSON.toJSONString(users));
  43. }
  44. /**
  45. * select
  46. user0_.id as id1_,
  47. user0_.account as account1_,
  48. user0_.email as email1_,
  49. user0_.name as name1_,
  50. user0_.password as password1_
  51. from
  52. USER user0_
  53. where
  54. user0_.id between ? and ?
  55. */
  56. @Test
  57. public void testFindByIdBetween(){
  58. List<User> users = dao.findByIdBetween(5, 8);
  59. System.out.println(JSON.toJSONString(users));
  60. }
  61. /**
  62. * select
  63. user0_.id as id1_,
  64. user0_.account as account1_,
  65. user0_.email as email1_,
  66. user0_.name as name1_,
  67. user0_.password as password1_
  68. from
  69. USER user0_
  70. where
  71. user0_.id<?
  72. */
  73. @Test
  74. public void testFindByIdLessThan(){
  75. List<User> users = dao.findByIdLessThan(4);
  76. System.out.println(JSON.toJSONString(users));
  77. }
  78. /**
  79. * select
  80. user0_.id as id0_,
  81. user0_.account as account0_,
  82. user0_.email as email0_,
  83. user0_.name as name0_,
  84. user0_.password as password0_
  85. from
  86. USER user0_
  87. where
  88. user0_.id>?
  89. */
  90. @Test
  91. public void testFindByIdGreaterThan(){
  92. List<User> users = dao.findByIdGreaterThan(6);
  93. System.out.println(JSON.toJSONString(users));
  94. }
  95. /**
  96. * select
  97. user0_.id as id0_,
  98. user0_.account as account0_,
  99. user0_.email as email0_,
  100. user0_.name as name0_,
  101. user0_.password as password0_
  102. from
  103. USER user0_
  104. where
  105. user0_.name is null
  106. */
  107. @Test
  108. public void testFindByNameIsNull(){
  109. List<User> users = dao.findByNameIsNull();
  110. System.out.println(JSON.toJSONString(users));
  111. }
  112. /**
  113. * select
  114. user0_.id as id1_,
  115. user0_.account as account1_,
  116. user0_.email as email1_,
  117. user0_.name as name1_,
  118. user0_.password as password1_
  119. from
  120. USER user0_
  121. where
  122. user0_.name is not null
  123. */
  124. @Test
  125. public void testFindByNameIsNotNull(){
  126. List<User> users = dao.findByNameIsNotNull();
  127. System.out.println(JSON.toJSONString(users));
  128. }
  129. /**
  130. * select
  131. user0_.id as id1_,
  132. user0_.account as account1_,
  133. user0_.email as email1_,
  134. user0_.name as name1_,
  135. user0_.password as password1_
  136. from
  137. USER user0_
  138. where
  139. user0_.name like ?
  140. */
  141. @Test
  142. public void testFindByNameLike(){
  143. List<User> users = dao.findByNameLike("chhliu");
  144. System.out.println(JSON.toJSONString(users));
  145. }
  146. /**
  147. * select
  148. user0_.id as id0_,
  149. user0_.account as account0_,
  150. user0_.email as email0_,
  151. user0_.name as name0_,
  152. user0_.password as password0_
  153. from
  154. USER user0_
  155. where
  156. user0_.name not like ?
  157. */
  158. @Test
  159. public void testFindByNameNotLike(){
  160. List<User> users = dao.findByNameNotLike("chhliu");
  161. System.out.println(JSON.toJSONString(users));
  162. }
  163. /**
  164. * select
  165. user0_.id as id0_,
  166. user0_.account as account0_,
  167. user0_.email as email0_,
  168. user0_.name as name0_,
  169. user0_.password as password0_
  170. from
  171. USER user0_
  172. where
  173. user0_.password=?
  174. order by
  175. user0_.id desc
  176. */
  177. @Test
  178. public void testFindByPasswordOrderByIdDesc(){
  179. List<User> users = dao.findByPasswordOrderByIdDesc("123456");
  180. System.out.println(JSON.toJSONString(users));
  181. }
  182. /**
  183. * select
  184. user0_.id as id1_,
  185. user0_.account as account1_,
  186. user0_.email as email1_,
  187. user0_.name as name1_,
  188. user0_.password as password1_
  189. from
  190. USER user0_
  191. where
  192. user0_.name<>?
  193. */
  194. @Test
  195. public void testFindByNameNot(){
  196. List<User> users = dao.findByNameNot("chhliu");
  197. System.out.println(JSON.toJSONString(users));
  198. }
  199. /**
  200. * select
  201. user0_.id as id1_,
  202. user0_.account as account1_,
  203. user0_.email as email1_,
  204. user0_.name as name1_,
  205. user0_.password as password1_
  206. from
  207. USER user0_
  208. where
  209. user0_.id in (
  210. ? , ? , ? , ?
  211. )
  212. */
  213. @Test
  214. public void testFindByIdIn(){
  215. List<User> users = dao.findByIdIn(new ArrayList<Integer>(Arrays.asList(3,4,6,8)));
  216. System.out.println(JSON.toJSONString(users));
  217. }
  218. /**
  219. * select
  220. user0_.id as id0_,
  221. user0_.account as account0_,
  222. user0_.email as email0_,
  223. user0_.name as name0_,
  224. user0_.password as password0_
  225. from
  226. USER user0_
  227. where
  228. user0_.id not in  (
  229. ? , ? , ? , ?
  230. )
  231. */
  232. @Test
  233. public void testFindByIdNotIn(){
  234. List<User> users = dao.findByIdNotIn(new ArrayList<Integer>(Arrays.asList(3,4,6,8)));
  235. System.out.println(JSON.toJSONString(users));
  236. }
  237. }

这里,我们只定义了一个接口,接口里面只有方法,但是没有任何的实现,却完成了各种操作。

看到这里,估计很多人都会问,Spring data JPA是怎么做到的了?原来,框架在进行方法名解析时,会先把方法名多余的前缀截取掉,比如 find、findBy、read、readBy、get、getBy,然后对剩下部分进行解析。并且如果方法的最后一个参数是 Sort 或者 Pageable 类型,也会提取相关的信息,以便按规则进行排序或者分页查询。在创建查询时,我们通过在方法名中使用属性名称来表达,比如 findByIdIn()。框架在解析该方法时,首先剔除 findBy,然后对剩下的属性进行解析。

在查询时,通常需要同时根据多个属性进行查询,且查询的条件也格式各样(大于某个值、在某个范围等等),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<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数

NotIn --- 等价于 SQL 中的 "not in",比如 findByUsernameNotIn(Collection<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数

五、创建查询的顺序

Spring Data JPA 在为接口创建代理对象时,如果发现同时存在多种上述情况可用,它该优先采用哪种策略呢?为此,<jpa:repositories> 提供了 query-lookup-strategy 属性,用以指定查找的顺序。它有如下三个取值:

create --- 通过解析方法名字来创建查询。即使有符合的命名查询,或者方法通过 @Query 指定的查询语句,都将会被忽略。

create-if-not-found --- 如果方法通过 @Query 指定了查询语句,则使用该语句实现查询;如果没有,则查找是否定义了符合条件的命名查询,如果找到,则使用该命名查询;如果两者都没有找到,则通过解析方 法名字来创建查询。这是 query-lookup-strategy 属性的默认值。

use-declared-query --- 如果方法通过 @Query 指定了查询语句,则使用该语句实现查询;如果没有,则查找是否定义了符合条件的命名查询,如果找到,则使用该命名查询;如果两者都没有找到,则抛出异常。

六、Spring Data JPA 对事务的支持

细心的读者也许从上面的代码中看出了一些端倪,我们在使用Spring data JPA的时候,只是定义了接口,在使用的时候,直接注入就可以了,并没有做与事物相关的任何处理,但实际上,事物已经起到效果了,这又是为什么了?

默认情况下,Spring Data JPA 实现的方法都是使用事务的。针对查询类型的方法,其等价于 @Transactional(readOnly=true);增删改类型的方法,等价于 @Transactional。可以看出,除了将查询的方法设为只读事务外,其他事务属性均采用默认值。

如果用户觉得有必要,可以在接口方法上使用 @Transactional 显式指定事务属性,该值覆盖 Spring Data JPA 提供的默认值。同时,开发者也可以在业务层方法上使用 @Transactional 指定事务属性,这主要针对一个业务层方法多次调用持久层方法的情况。持久层的事务会根据设置的事务传播行为来决定是挂起业务层事务还是加入业务层的事务。

结尾:如果有需要使用示例源码的同事,可以与我联系924580006@qq.com

spring data jpa使用详解的更多相关文章

  1. Spring Data JPA实体详解

    1. Spring Data JPA实体概述 JPA提供了一种简单高效的方式来管理Java对象(POJO)到关系数据库的映射,此类Java对象称为JPA实体或简称实体.实体通常与底层数据库中的单个关系 ...

  2. Spring Data操作Redis详解

    Spring Data操作Redis详解 Redis是一种NOSQL数据库,Key-Value形式对数据进行存储,其中数据可以以内存形式存在,也可以持久化到文件系统.Spring data对Redis ...

  3. spring+springMVC+JPA配置详解(使用缓存框架ehcache)

    SpringMVC是越来越火,自己也弄一个Spring+SpringMVC+JPA的简单框架. 1.搭建环境. 1)下载Spring3.1.2的发布包:Hibernate4.1.7的发布包(没有使用h ...

  4. SpringBoot学习笔记:Spring Data Jpa的使用

    更多请关注公众号 Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API,是Sun官方在JDK5.0后提出的Java持久化规范(JSR ...

  5. 【ORM框架】Spring Data JPA(一)-- 入门

    本文参考:spring Data JPA入门   [原创]纯干货,Spring-data-jpa详解,全方位介绍  Spring Data JPA系列教程--入门 一.Spring Data JPA介 ...

  6. Spring Data JPA在Spring Boot中的应用

    1.JPA JPA(Java Persistence API)是Sun官方提出的Java持久化规范.它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据.他的出现主要是为了简 ...

  7. SpringBoot入门:Spring Data JPA 和 JPA(理论)

    参考链接: Spring Data JPA - Reference Documentation Spring Data JPA--参考文档 中文版 纯洁的微笑:http://www.ityouknow ...

  8. 展开被 SpringBoot 玩的日子 《 五 》 spring data jpa 的使用

    在上篇文章< 展开被 SpringBoot 玩的日子 < 二 >WEB >中简单介绍了一下spring data jpa的基础性使用,这篇文章将更加全面的介绍spring da ...

  9. spring-boot (三) spring data jpa

    学习文章来自:http://www.ityouknow.com/spring-boot.html spring data jpa介绍 首先了解JPA是什么? JPA(Java Persistence ...

随机推荐

  1. python处理JSON 序列化与反序列化

    #序列化 >>> import json>>> d={"key":"value"}>>> d{'key': ...

  2. day6_面向对象的概念

    #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2019/7/11 16:20 # @Author : 大坏男孩 # @File : d ...

  3. 莫烦TensorFlow_04 placeholder

    import tensorflow as tf input1 = tf.placeholder(tf.float32) input2 = tf.placeholder(tf.float32) outp ...

  4. httpHandlers path="*.sky"

    <httpHandlers> <add verb="*" path="*.sky" type="WebAppHttpHandlerT ...

  5. Golang调用Python

    https://yq.aliyun.com/articles/117329 Python是时髦的机器学习御用开发语言,Golang是大红大紫的新时代后端开发语言.Python很适合让搞算法的写写模型, ...

  6. 【oracle】ORA-12638 : 身份证明检索失败

    sqlnet.ora 1.删了 2.#注释了 背后缘由:待写

  7. 4.Vue双向绑定

    1.什么是双向数据绑定 Vue.js 是一个 MVVM 框架,即数据双向绑定,即当数据发生变化的时候,视图也就发生变化,当视图发生变化的时候,数据也会跟着同步变化.这也算是 Vue.js 的精髓之处了 ...

  8. [LeetCode] 364. Nested List Weight Sum II 嵌套链表权重和之二

    Given a nested list of integers, return the sum of all integers in the list weighted by their depth. ...

  9. [LeetCode] 5. Longest Palindromic Substring 最长回文子串

    Given a string s, find the longest palindromic substring in s. You may assume that the maximum lengt ...

  10. App.vue 不触发 beforeRouteEnter

    因为要在 router 对应一个路由的组件才可以触发 如果没有将 App.vue 作为某个路由组件(一般不会吧) 就不会触发该导航守卫 应该是想在每次进入应用时加载一些数据 所以放在 App.vue ...