SpringDataJPA之JpaRepository和JpaSpecificationExecutor接口

JpaRepository
  JpaRepository 接口是我们开发时使用的最多的接口。其特点是可以帮助我们将其他接口的方法的返回值做适配处理。可以使得我们在开发时更方便的使用这些方法。

1.创建接口

/**
 * SpringDataJPA 实现JpaRepository
 * 泛型 第一个参数是对应的Pojo类型
 *  第二个参数是注解的包装类型
 */
public interface UserDao extends JpaRepository<Users,Integer> {

}

2.单元测试

/**
 * @program: spring-data-jpa
 * @description: 单元测试
 * @author: 波波烤鸭
 * @create: 2019-05-18 09:48
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestDemo {

    @Autowired
    private UserDao usersDao;


    /**
     * 添加用户
     */
    @Test
    @Transactional// 在测试类对于事务提交方式默认的是回滚。
    @Rollback(false)//取消自动回滚
    public void testInsertUsers(){
        Users users = new Users();
        users.setUserage(20);
        users.setUsername("张三-jpa");
        this.usersDao.save(users);
    }
}

JpaSpecificationExecutor
  完成多条件查询，并且支持分页与排序。

1.创建接口
  JpaSpecificationExecutor接口不能够单独使用，需要和其他接口一块使用，如下

/**
 * JpaSpecificationExecutor 接口讲解
 * @author Administrator
 *注意：JpaSpecificationExecutor<Users>:不能单独使用，需要配合着 jpa 中的其他接口一起使用
 */
public interface UserDao extends JpaRepository<Users, Integer>
					, JpaSpecificationExecutor<Users> {

}

2.具体功能
2.1 单条件查询

/**
*  单条件查询
* 需求：根据用户姓名查询数据
*/
@Test
public void test1(){
   Specification<Users> spec = new Specification<Users>() {
       /**
        * @return Predicate:定义了查询条件
        * @param Root<Users> root:根对象。封装了查询条件的对象
        * @param CriteriaQuery<?> query:定义了一个基本的查询.一般不
       使用
        * @param CriteriaBuilder cb:创建一个查询条件
        */
       @Override
       public Predicate toPredicate(Root<Users> root,
                                    CriteriaQuery<?> query, CriteriaBuilder cb) {
           Predicate pre = cb.equal(root.get("username"), "王五");
           return pre;
       }
   };
   List<Users> list = this.usersDao.findAll(spec);
   for (Users users : list) {
       System.out.println(users);
   }
}

2.2 多条件查询
  多条件查询有两种方式，具体如下

/**
 * 多条件查询 方式一
 * 需求：使用用户姓名以及年龄查询数据
 */
@Test
public void test2() {
    Specification<Users> spec = new Specification<Users>() {
        @Override
        public Predicate toPredicate(Root<Users> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            List<Predicate> list = new ArrayList<>();
            list.add(cb.equal(root.get("username"), "王五"));
            list.add(cb.equal(root.get("userage"), 24));
            //此时条件之间是没有任何关系的。
            Predicate[] arr = new Predicate[list.size()];
            return cb.and(list.toArray(arr));
        }
    };
    List<Users> list = this.usersDao.findAll(spec);
    for (Users users : list) {
        System.out.println(users);
    }
}

/**
 * 多条件查询 方式二
 * 需求：使用用户姓名或者年龄查询数据
 */
@Test
public void test3(){
    Specification<Users> spec = new Specification<Users>() {
        @Override
        public Predicate toPredicate(Root<Users> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {

            return cb.or(cb.equal(root.get("username"),"王五 "),cb.equal(root.get("userage"), 25));
        }
    };
    List<Users> list = this.usersDao.findAll(spec);
    for (Users users : list) {
        System.out.println(users);
    }
}

2.3 分页

/**
 * 需求：查询王姓用户，并且做分页处理
 */
@Test
public void test4(){
    //条件
    Specification<Users> spec = new Specification<Users>() {
        @Override
        public Predicate toPredicate(Root<Users> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            return cb.like(root.get("username").as(String.class), "王%");
        }
    };
    //分页
    Pageable pageable = new PageRequest(2, 2);
    Page<Users> page = this.usersDao.findAll(spec, pageable);
    System.out.println("总条数："+page.getTotalElements());
    System.out.println("总页数："+page.getTotalPages());
    List<Users> list = page.getContent();
    for (Users users : list) {
        System.out.println(users);
    }
}

2.4 排序

/**
 * 需求：查询数据库中王姓的用户，并且根据用户 id 做倒序排序
 */
@Test
public void test5(){
    //条件
    Specification<Users> spec = new Specification<Users>() {
        @Override
        public Predicate toPredicate(Root<Users> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            return cb.like(root.get("username").as(String.class),
                    "王%");
        }
    };
    //排序
    Sort sort = new Sort(Sort.Direction.DESC,"userid");
    List<Users> list = this.usersDao.findAll(spec, sort);
    for (Users users : list) {
        System.out.println(users);
    }
}

2.5 分页排序

/**
 * 需求：查询数据库中王姓的用户，做分页处理，并且根据用户 id 做倒序排序
 */
@Test
public void test6(){
    //排序等定义
    Sort sort = new Sort(Sort.Direction.DESC,"userid");
    //分页的定义
    Pageable pageable = new PageRequest(0,2, sort);
    //查询条件
    Specification<Users> spec = new Specification<Users>() {
        @Override
        public Predicate toPredicate(Root<Users> root,
                                     CriteriaQuery<?> query, CriteriaBuilder cb) {
            return cb.like(root.get("username").as(String.class),
                    "王%");
        }
    };
    Page<Users> page = this.usersDao.findAll(spec, pageable);
    System.out.println("总条数："+page.getTotalElements());
    System.out.println("总页数："+page.getTotalPages());
    List<Users> list = page.getContent();
    for (Users users : list) {
        System.out.println(users);
    }
}

如此我们对于单表的相关操作通过JpaSpecificationExecutor接口和JpaRepository接口就都可以实现了~