七springboot整合Spring-data-jpa

Posted 2020-11-02 灬小乙

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如下表所示

Keyword	Sample	JPQL snippet
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)

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查询

Spring Data JPA支持JPA2.0的Criteria查询，相应的接口是JpaSpecificationExecutor。

Criteria 查询：是一种类型安全和更面向对象的查询

 

这个接口基本是围绕着Specification接口来定义的， Specification接口中只定义了如下一个方法：

Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);

 

要理解这个方法，以及正确的使用它，就需要对JPA2.0的Criteria查询有一个足够的熟悉和理解，因为这个方法的参数和返回值都是JPA标准里面定义的对象。

 

Criteria查询基本概念

Criteria 查询是以元模型的概念为基础的，元模型是为具体持久化单元的受管实体定义的，这些实体可以是实体类，嵌入类或者映射的父类。

CriteriaQuery接口：代表一个specific的顶层查询对象，它包含着查询的各个部分，比如：select 、from、where、group by、order by等

注意：CriteriaQuery对象只对实体类型或嵌入式类型的Criteria查询起作用

Root接口：代表Criteria查询的根对象，Criteria查询的查询根定义了实体类型，能为将来导航获得想要的结果，它与SQL查询中的FROM子句类似

1：Root实例是类型化的，且定义了查询的FROM子句中能够出现的类型。

2：查询根实例能通过传入一个实体类型给 AbstractQuery.from方法获得。

3：Criteria查询，可以有多个查询根。 

4：AbstractQuery是CriteriaQuery 接口的父类，它提供得到查询根的方法。

CriteriaBuilder接口：用来构建CritiaQuery的构建器对象

Predicate：一个简单或复杂的谓词类型，其实就相当于条件或者是条件组合。

 

Criteria查询

基本对象的构建

1：通过EntityManager的getCriteriaBuilder或EntityManagerFactory的getCriteriaBuilder方法可以得到CriteriaBuilder对象

2：通过调用CriteriaBuilder的createQuery或createTupleQuery方法可以获得CriteriaQuery的实例

3：通过调用CriteriaQuery的from方法可以获得Root实例

过滤条件

1：过滤条件会被应用到SQL语句的FROM子句中。在criteria 查询中，查询条件通过Predicate或Expression实例应用到CriteriaQuery对象上。

2：这些条件使用 CriteriaQuery .where 方法应用到CriteriaQuery 对象上

3：CriteriaBuilder也作为Predicate实例的工厂，通过调用CriteriaBuilder 的条件方法（ equal，notEqual， gt， ge，lt， le，between，like等）创建Predicate对象。

4：复合的Predicate 语句可以使用CriteriaBuilder的and, or andnot 方法构建。

 

构建简单的Predicate示例：

Predicate p1=cb.like(root.get(“name”).as(String.class), “%”+uqm.getName()+“%”);

Predicate p2=cb.equal(root.get("uuid").as(Integer.class), uqm.getUuid());

Predicate p3=cb.gt(root.get("age").as(Integer.class), uqm.getAge());

构建组合的Predicate示例：

Predicate p = cb.and(p3,cb.or(p1,p2));

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;
    }

}

 

参考：

　　　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