hibernate-使用data jpa

简介
笔者在前面的文章中提及到过 spring-data-jpa ,什么是 jpa ,什么是 spring-data-jpa 。jpa 是 Java Persistence API的简称，是 javaEE 的 orm 规范，spring-data-jpa 是依照 jap 规范的关于数据持久层的一系列接口，在 spring 中是这样介绍 data-jpa 的：spring-data-jpa 是 spring 数据持久层的一部分，能够更轻松方便实现基于 JPA 的库，更容易构建出 spring 应用。说白了，spring-data-jpa 让我们更方便地操作持久层。

使用
1.使用 data-jpa 主要是要使用 spring 提供的一系列 Repository 接口。

// 接口族Repository<T, ID extends Serializable>    CrudRepository<T, ID extends Serializable>        PagingAndSortingRepository<T, ID extends Serializable>            JpaRepository<T, ID extends Serializable>// 用于动态查询            JpaSpecificationExecutor<T>

2.先来看看这些接口声明了那些方法

空接口

public interface Repository<T, ID extends Serializable> {}

CrudRepository 声明了基本的 CRUD 方法

public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {    // 保存或更新    <S extends T> S save(S var1);    // 批量保存或更新    <S extends T> Iterable<S> save(Iterable<S> var1);    // 根据主键查找    T findOne(ID var1);    // 根据主键判断是否存在    boolean exists(ID var1);    // 查找所有符合条件的    Iterable<T> findAll();    Iterable<T> findAll(Iterable<ID> var1);    // 统计总量    long count();    // 根据主键或其他条件删除    void delete(ID var1);    void delete(T var1);    void delete(Iterable<? extends T> var1);    void deleteAll();}

PagingAndSortingRepository 接口继承 CrudRepository ，主要增加了分页和排序功能

public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {    // 排序查找    Iterable<T> findAll(Sort var1);    // 分页查找    Page<T> findAll(Pageable var1);}

JpaRepository 接口继承 PagingAndSortingRepository 接口，扩展了一些返回参数类型为 List 的方法

public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {    List<T> findAll();    List<T> findAll(Sort var1);    List<T> findAll(Iterable<ID> var1);    <S extends T> List<S> save(Iterable<S> var1);    void flush();    <S extends T> S saveAndFlush(S var1);    void deleteInBatch(Iterable<T> var1);    void deleteAllInBatch();    T getOne(ID var1);    <S extends T> List<S> findAll(Example<S> var1);    <S extends T> List<S> findAll(Example<S> var1, Sort var2);}

JpaSpecificationExecutor 是一个高级动态查询接口，不是 Repository 系列中的子接口

public interface JpaSpecificationExecutor<T> {    T findOne(Specification<T> var1);    List<T> findAll(Specification<T> var1);    Page<T> findAll(Specification<T> var1, Pageable var2);    List<T> findAll(Specification<T> var1, Sort var2);    long count(Specification<T> var1);}

3.如何使用这些接口，你仅需要继承这些接口即可，具体实现由 data-jpa 库帮你实现，和使用 mybatis 差不过。举个栗子：

@Repositorypublic interface UserRepository extends JpaRepository<User,Long> {}

这样就可以通过 spring 自动注入到类中使用了，你可以调用上述接口中声明的任意方法完成持久化操作。一般上述方法就可以满足一般的需求，但是我们可不可以扩展这些接口呢，答案是可以的，不过在扩展接口时的方法命名需要遵循 data-jpa 的规范约束，例如：

@Repositorypublic interface UserRepository extends JpaRepository<User,Long> {    // 根据 userId 查找 user    User findByUserId(String userId);    // 根据 username 查找 user    User findByUsername(String username);    User findByUsernameAndAge(String username,int age);}

基本是使用：findBy,deleteBy,countBy,existsBy,orderBy,between ,distinct,and,or…,实体类属性名 等这些关键字拼接起来。当这些都不满足需求时，就可以通过使用 @Query 注解自己拼 hql 了。例如：

@Repositorypublic interface UserRepository extends JpaRepository<User,Long> {    User findByUserId(String userId);    User findUserByUsername(String username);    @Query("select u from User u join u.department dept where dept.departmentId = :deptId")    Page<User> findByDeptId(@Param("deptId") String deptId, Pageable pageable);    @Query("select u from User u join  u.roles role where role.roleId = :roleId")    Page<User> findByRoleId(@Param("roleId") Long roleId, Pageable pageable);    @Query("select count(u.userId) from User u join u.department dept where dept.departmentId = :deptId")    int countByDeptId(@Param("deptId") String deptId);    /*注意update需要modifying*/    @Modifying    @Query("update User u set u.flag = :flag where u.userId = :userId")    int updateUserFlag(@Param("flag") Integer flag, @Param("userId") String userId);}

一般在做联表查询是就需要使用 hql 了，hql 也是面向对象的，实体类等价于对应的表，通过打点访问类中的关联实体类属性即可做到联表。此外，很多时候我们需要动态查询，以上方案 sql 都是固定的，怎样才能动态拼接 sql 实现动态查询呢，这就要使用到 JpaSpecificationExecutor 了。再来看看这个接口的方法：

 public interface JpaSpecificationExecutor<T> {    T findOne(Specification<T> var1);    List<T> findAll(Specification<T> var1);    Page<T> findAll(Specification<T> var1, Pageable var2);    List<T> findAll(Specification<T> var1, Sort var2);    long count(Specification<T> var1);}

在声明的方法中有三个参数：Sort，Pageable ，Specification ，关键是最后的这个。Specification 就是动态拼接的 sql 的数据结构，在使用动态查询，我们需要做的是如何创建 Specification 对象。

public interface Specification<T> {    Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);}

Specification 也是一个接口，其中仅有一个方法 toPredicate ， 实际上 Predicate 才真正是动态拼接 sql 的数据结构。在组装 sql 时，使用的是 root,criteriaQuery,criteriaBuilder 这三个对象。例如：

@Repositorypublic interface UserRepository extends JpaRepository<User,Long>,JpaSpecificationExecutor<User> {    public static class Specs{        /**         * 根据查询条件构造动态查询sql         * username         * userId         * deptId         * roleId         *         *root : 可以获取实体类中的属性名（等价数据库中的表，列）         *criteriaQuery：构建子查询（等价于使用 orderBy,groupBy 等）         *criteriaBuilder：构建 predicate 对象，构建 sql 片段         *         */        public static Specification<User> newQueryParams(Map<String,String> paramsMap){            return new Specification<User>() {                @Override                public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {                    // 创建 Predicate                    Predicate predicate = criteriaBuilder.conjunction();                    // 组装条件                    if(StringUtils.isNotBlank(paramsMap.get("username"))){                        predicate.getExpressions().add(criteriaBuilder.like(root.<String>get("username")                                ,"%"+ paramsMap.get("username") + "%"));                    }                    if(StringUtils.isNotBlank(paramsMap.get("userId"))){                        predicate.getExpressions().add(criteriaBuilder.equal(root.<String>get("userId"),paramsMap.get("userId")));                    }                    if(StringUtils.isNotBlank(paramsMap.get("deptId"))){                        // 注意联表的问题                        predicate.getExpressions().add(criteriaBuilder.equal(root.get("department").get("departmentId"),paramsMap.get("deptId")));                    }                    if(StringUtils.isNotBlank(paramsMap.get("roleId"))){                        predicate.getExpressions().add(criteriaBuilder.equal(root.join("roles", JoinType.LEFT).get("roleId").as(String.class), paramsMap.get("roleId")));                    }                    return predicate;                }            };        }    }}

PS: 在 hibernate 中的级联注解中，一般使用 CascadeType.ALL，如@OneToMany(cascade={CascadeType.ALL}) , 但是往往不需要级联删除，这是可以使用 hibernate 提供的注解：@Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})

PS : spring-data-example 多看官方栗子，多看官方栗子，多看官方栗子