springdataJPA的使用

春风霓裳

已于 2023-01-13 09:51:12 修改

阅读量686

点赞数

分类专栏：数据库 mybatis 文章标签： java 数据库开发语言

于 2023-01-08 12:23:19 首次发布

本文链接：https://blog.csdn.net/qq_43470725/article/details/128599439

版权

数据库同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

mybatis

12 篇文章 0 订阅

订阅专栏

参考：https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.namespace

https://blog.csdn.net/hbtj_1216/article/details/79773839

介意idea装个jpa buddy插件

CrudRepository<T, ID>提供的方法

/**
 * 保存一个实体。
 */
<S extends T> S save(S entity);

/**
 * 保存提供的所有实体。
 */
<S extends T> Iterable<S> saveAll(Iterable<S> entities);

/**
 * 根据id查询对应的实体。
 */
Optional<T> findById(ID id);

/**
 * 根据id查询对应的实体是否存在。
 */
boolean existsById(ID id);

/**
 * 查询所有的实体。
 */
Iterable<T> findAll();

/**
 * 根据给定的id集合查询所有对应的实体，返回实体集合。
 */
Iterable<T> findAllById(Iterable<ID> ids);

/**
 * 统计现存实体的个数。
 */
long count();

/**
 * 根据id删除对应的实体。
 */
void deleteById(ID id);

/**
 * 删除给定的实体。
 */
void delete(T entity);

/**
 * 删除给定的实体集合。
 */
void deleteAll(Iterable<? extends T> entities);

/**
 * 删除所有的实体。
 */
void deleteAll();

PagingAndSortingRepository<T, ID>提供的方法

具备分页和排序的方法：

/**
 * 返回所有的实体，根据Sort参数提供的规则排序。
 */
Iterable<T> findAll(Sort sort);

/**
 * 返回一页实体，根据Pageable参数提供的规则进行过滤。
 */
Page<T> findAll(Pageable pageable);

JpaRepository<T, ID>提供的方法

/**
 * 将所有未决的更改刷新到数据库。
 */
void flush();

/**
 * 保存一个实体并立即将更改刷新到数据库。
 */
<S extends T> S saveAndFlush(S entity);

/**
 * 在一个批次中删除给定的实体集合，这意味着将产生一条单独的Query。
 */
void deleteInBatch(Iterable<T> entities);

/**
 * 在一个批次中删除所有的实体。
 */
void deleteAllInBatch();

/**
 * 根据给定的id标识符，返回对应实体的引用。
 */
T getOne(ID id);

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.PagingAndSortingRepository;

//public interface UserRepository extends CrudRepository<User,Long> {//增删改查内置方法
public interface UserRepository extends PagingAndSortingRepository<User,Long> {//PagingAndSortingRepository具备分页和排序

}

package com.jpa;

import com.acme.repositories.UserRepository;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.print.attribute.standard.PageRanges;
import java.util.Optional;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringDataJpaPagingAndSortTest {

    @Autowired
    UserRepository repository;

    @Test
    public void test_get(){

        Page<User> all = repository.findAll(PageRequest.of(0,2));
        System.out.println(all);
        System.out.println("total==="+all.getTotalPages());
        System.out.println("ele==="+all.getTotalElements());
        System.out.println("content==="+all.getContent());

    }

    @Test
    public void test_get02(){

        Sort sort = Sort.by("id").descending();

        Page<User> all = repository.findAll(PageRequest.of(0,2,sort));
        System.out.println(all);
        System.out.println("total==="+all.getTotalPages());
        System.out.println("ele==="+all.getTotalElements());
        System.out.println("content==="+all.getContent());

    }

    /*
    * https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.namespace
    * */
    @Test
    public void test_get_sortTypeSafe(){

        Sort.TypedSort<User> user = Sort.sort(User.class);

        Sort sort = user.by(User::getId).ascending();
        Page<User> all = repository.findAll(PageRequest.of(0,2,sort));
        System.out.println(all);
        System.out.println("total==="+all.getTotalPages());
        System.out.println("ele==="+all.getTotalElements());
        System.out.println("content==="+all.getContent());


    }

}

自定义操作–sql

**1、jpql(原生sql)
a.@Query
i.查询如果返回单个实体就用pojo接收，如果是多个需要通过集合
ii.参数设置方式
1.索引：?数字
2.具名： :参数名结合@Param注解指定参数名字
iii.增删改：
1.要加上事务的支持：
2.如果是插入方法：一定只能在hibernate下才支持(inset into …select)
**

        @Modifying//通知springdatajpa 是增删改的操作
		@Transactional//通常会放在业务逻辑层声明

原生sql:

@Query(value = "select * from t_user where username =:userName"
    ,nativeQuery = true)
    List<User> findUserByUserNameBySql(@Param("userName") String userName);

代码：

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

import javax.transaction.Transactional;
import java.util.List;

//public interface UserRepository extends CrudRepository<User,Long> {//增删改查内置方法
public interface UserRepository extends PagingAndSortingRepository<User,Long> {//PagingAndSortingRepository具备分页和排序

//    增删查改

//    查询
//    @Query("from User where username =?1")
//    List<User> findUserByUserName(String userName);

    //    查询---通过具名参数
    @Query("from User where username =:userName")
    List<User> findUserByUserName(@Param("userName") String userName);

//    修改
    @Query("update User u set u.username=:userName where u.id =:id")
    @Modifying//通知springdatajpa 是增删改的操作
    @Transactional
    int updateUserById(@Param("userName")String userName,@Param("id")Long id);

//    删除
    @Modifying//通知springdatajpa 是增删改的操作
    @Transactional
    @Query("delete from User u where u.id =?1")
    int deleteUserById(Long id);

//    新增  jpql(hibernate支持伪新增)
    @Modifying//通知springdatajpa 是增删改的操作
    @Transactional
    @Query("insert into User (username) select u.username from User u where u.id =?1")
    int insertUserBySelect(Long id);

    /*------------原生sql-------------*/
    //    查询---通过具名参数
    @Query(value = "select * from t_user where username =:userName"
    ,nativeQuery = true)
    List<User> findUserByUserNameBySql(@Param("userName") String userName);


}

package com.jpa;

import com.acme.repositories.UserRepository;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.transaction.Transactional;
import java.util.List;
import java.util.Optional;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class JpqlTest {

    @Autowired
    UserRepository repository;

    @Test
    public void test_get(){

        List<User> admin = repository.findUserByUserName("jpa");
        System.out.println(admin);

    }

    @Test
    public void test_update(){

        int res = repository.updateUserById("小小", 5l);
        System.out.println(res);

    }

    @Test
    public void test_delete(){

        int res = repository.deleteUserById(5l);
        System.out.println(res);

    }

    @Test
    public void test_add(){

        int res = repository.insertUserBySelect(2l);
        System.out.println(res);

    }

    @Test
    public void test_sql_select(){

        List<User> userByUserNameBySql = repository.findUserByUserNameBySql("jpa");
        System.out.println(userByUserNameBySql);

    }


}

自定义操作–规范方法名

官网：https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#jpa.query-methods
主题关键字：决定当前方法作用

在这里插入图片描述

谓词关键字和修饰符：决定查询条件

代码演示：

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

import javax.transaction.Transactional;
import java.util.List;

//public interface UserRepository extends CrudRepository<User,Long> {//增删改查内置方法
public interface UserMethodNameRepository extends PagingAndSortingRepository<User,Long> {//PagingAndSortingRepository具备分页和排序

    List<User> findByUsername(String username);

    boolean existsByUsername(String username);

    @Transactional
    @Modifying
    int deleteByUsernameAndId(String username,Long id);

    List<User> findByUsernameLike(String username);

}

package com.jpa;

import com.acme.repositories.UserMethodNameRepository;
import com.acme.repositories.UserRepository;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class MethodNameTest {

    @Autowired
    UserMethodNameRepository repository;

    @Test
    public void test_get(){

        List<User> admin = repository.findByUsername("jpa");
        System.out.println(admin);

    }

    @Test
    public void test_get02(){

        boolean jpa = repository.existsByUsername("jpa");
        System.out.println(jpa);

    }


    @Test
    public void test_get03(){

        int jpa = repository.deleteByUsernameAndId("jpa",8l);
        System.out.println(jpa);

    }

    @Test
    public void test_get04(){

        List<User> byUsernameLike = repository.findByUsernameLike("jp%");
        System.out.println(byUsernameLike);

    }
}

自定义操作–Query by Example(动态条件查询)

Query by Example a.只支持查询
i.不支持嵌套或分组的属性约束，如firstname = ? 0 或(firstname =? 1 and lastname =? 2).
ii.只支持字符串 start/contains/ends/refex匹配和其他属性类型的精确匹配

代码演示：

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

import javax.transaction.Transactional;
import java.util.List;

public interface UserQBEeRepository extends PagingAndSortingRepository<User,Long>
        , QueryByExampleExecutor<User> {//PagingAndSortingRepository具备分页和排序



}

package com.jpa;

import com.acme.repositories.UserQBEeRepository;
import com.acme.repositories.UserRepository;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class QBETest {

    @Autowired
    UserQBEeRepository repository;

    /*
    * 简单实例  客户名称 客户地址动态查询
    * */
    @Test
    public void test_get(){

        User user = new User();
        user.setUsername("jpa");
        user.setRoleName("admin");

//        通过example构建查询条件
        Example<User> of = Example.of(user);

        List<User> admin = (List<User>) repository.findAll(of);
        System.out.println(admin);

    }

    /*
    通过匹配器进行条件的限制:https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#query-by-example.matchers
     * 简单实例  客户名称 客户地址动态查询
     * */
    @Test
    public void test_get02(){

        User user = new User();
        user.setUsername("admin");
        user.setRoleName("in");

//        通过匹配器对条件行为进行设置
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnorePaths("username")//设置忽略属性
//                .withIgnoreCase("roleName")//设置忽略大小写
//                .withStringMatcher(ExampleMatcher.StringMatcher.ENDING);//对所有条件进行模糊匹配
//                .withMatcher("roleName",m -> m.endsWith());//针对单个条件进行匹配,会使withIgnoreCase失效，需要单独设置
                .withMatcher("roleName",ExampleMatcher.GenericPropertyMatchers.endsWith().ignoreCase());

//        通过example构建查询条件
        Example<User> of = Example.of(user,matcher);

        List<User> admin = (List<User>) repository.findAll(of);
        System.out.println(admin);

    }


}

自定义操作–QueryDSL(动态条件查询)推荐

queryDSL是基于ORM框架或sql平台上的一个通用查询框架。借助QueryDSL可以在任何支持的ORM框架或SQL平台上通用的API方式构建查询。
JPA是QueryDSL的主要集成技术，是JPQL和Criteria查询的代替方法。目前QueryDSL支持的平台包括JPA,JDO,SQL,Mongodb等等。。。

官网：http://querydsl.com/
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#core.extensions.querydsl

添加querydsl插件生成q类：

https://github.com/querydsl/querydsl/tree/master/querydsl-jpa

 <build>
        <plugins>
            <plugin>
                <groupId>com.mysema.maven</groupId>
                <artifactId>apt-maven-plugin</artifactId>
                <version>1.1.3</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>process</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>target/generated-sources/queries</outputDirectory>
                            <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
                        </configuration>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>com.querydsl</groupId>
                        <artifactId>querydsl-apt</artifactId>
                        <version>${querydsl.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

添加好meaven插件后，进行生成q类：
target/generated-sources/queries
当编译完后，就会往target/generated-sources/queries这个文件夹中生成q类

在这里插入图片描述

将这个queries设置为idea中的source文件夹（代码文件夹，正常编码文件夹：source）

在这里插入图片描述

代码：

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;

import javax.transaction.Transactional;
import java.util.List;

//https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#core.extensions.querydsl
//public interface UserRepository extends CrudRepository<User,Long> {//增删改查内置方法
public interface UserQueryDSLRepository extends
        PagingAndSortingRepository<User,Long>
        , QuerydslPredicateExecutor<User> {//PagingAndSortingRepository具备分页和排序



}

package com.jpa;

import com.acme.repositories.UserMethodNameRepository;
import com.acme.repositories.UserQueryDSLRepository;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.QUser;
import com.jpa.entity.User;
import com.querydsl.core.Tuple;
import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.StringUtils;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class QueryDSLTest {

    @Autowired
    UserQueryDSLRepository repository;

    @Test
    public void test_get(){

        QUser user = QUser.user;

//        通过id查找
        BooleanExpression eq = user.id.eq(1l);

        System.out.println(repository.findOne(eq));


    }

    /*
    * 查询客户名称范围(in)
    * id  >大于
    * 地址  精确
    *
    * */
    @Test
    public void test_get02(){

        QUser user = QUser.user;

//        通过id查找
        BooleanExpression and = user.username.in("admin", "jpa")
                .and(user.id.gt(0l))
                .and(user.roleName.eq("Admin"));

        System.out.println(repository.findAll(and));


    }


    @Test
    public void test_get03(){

        User user = new User();
        user.setUsername("admin");
        user.setId(0l).setRoleName("admin").setRole(0l);

        QUser qUser = QUser.user;
//      初始条件  类似1==1  永远都成立的条件
        BooleanExpression exp = qUser.isNotNull().or(qUser.isNull());

        exp = user.getId() > -1 ?exp.and(qUser.id.gt(user.getId()))  : exp;

        exp =  !StringUtils.isEmpty(user.getUsername())? exp.and(qUser.username.in(user.getUsername().split(","))) : exp;
        exp =  !StringUtils.isEmpty(user.getRoleName())? exp.and(qUser.roleName.eq(user.getRoleName())) : exp;


        System.out.println(repository.findAll(exp));


    }

//  线程安全问题(@Autowired：单列),解决：@PersistenceContext
    @PersistenceContext
    EntityManager em;

    /*
    * 列查询、分组
    *
    * 原生态
    * */
    @Test
    public void test_get04(){

        JPAQueryFactory factory = new JPAQueryFactory(em);
        QUser qUser = QUser.user;

//        select id,username from
//        构建基于QueryDSL的查询
//        返回值类型是根据你查询的数据自动选择类型的
        JPAQuery<Tuple> tupleJPAQuery = factory.select(qUser.id, qUser.username)
                .from(qUser)
                .where(qUser.id.eq(1l))
                .orderBy(qUser.id.desc());
//      执行查询
        List<Tuple> fetch = tupleJPAQuery.fetch();

//        处理返回数据
        for (Tuple tuple : fetch) {

            System.out.println(tuple.get(qUser.id));
            System.out.println(tuple.get(qUser.username));

        }

/*------------------------------2------------------------------------*/
        //        返回值类型是根据你查询的数据自动选择类型的
        JPAQuery<Long> longJPAQuery = factory.select(qUser.id.sum())
                .from(qUser)
//                .where(qUser.id.eq(1l))
                .orderBy(qUser.id.desc());
//      执行查询
        List<Long> longFetct = longJPAQuery.fetch();

//        处理返回数据
        for (Long tuple : longFetct) {

            System.out.println(tuple);

        }



    }


}

自定义操作–Specifications

限制：不能分组、聚合函数，需要自己通过entityManager玩
在之前使用Query by Example只能针对字符串进行条件设置，那如果希望所有类型支持，可以使用Specifications

代码：

package com.acme.repositories;

import com.jpa.entity.User;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

import javax.transaction.Transactional;
import java.util.List;

//public interface UserRepository extends CrudRepository<User,Long> {//增删改查内置方法
public interface UserSepcificationsRepository extends
        PagingAndSortingRepository<User,Long> ,
        JpaSpecificationExecutor<User> {//PagingAndSortingRepository具备分页和排序




}

package com.jpa;

import com.acme.repositories.UserQueryDSLRepository;
import com.acme.repositories.UserSepcificationsRepository;
import com.alibaba.druid.util.StringUtils;
import com.jpa.config.SpringDataJPAConfig;
import com.jpa.entity.QUser;
import com.jpa.entity.User;
import com.querydsl.core.types.dsl.BooleanExpression;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.EntityManager;
import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;

//基于junit4 spring单元测试
//@ContextConfiguration(locations = "/spring.xml")//xml文件配置
@ContextConfiguration(classes = SpringDataJPAConfig.class)//config类配置
@RunWith(SpringJUnit4ClassRunner.class)
public class SpecificationTest {

    @Autowired
    UserSepcificationsRepository repository;

    @Autowired
    EntityManager entityManager;

    /*
     * 查询客户范围（in）
     * id >大于
     * 地址  精确
     *
     * */
    @Test
    public void test_get(){

        List<User> all = repository.findAll(new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//                root  form User,获取列
//                criteriaBuilder where  设置各种条件  （> < in ..）
//                query 组合（order by,where）
                Path<Long> id = root.get("id");
                Path<String> username = root.get("username");
                Path<String> roleName = root.get("roleName");
//              参数1：为哪个字段设置条件  参数2：值
                Predicate admin = criteriaBuilder.equal(roleName, "admin");
                Predicate id0 = criteriaBuilder.greaterThan(id, 0l);
                CriteriaBuilder.In<String> in = criteriaBuilder.in(roleName);
                in.value("admin").value("ADMIN");

                Predicate and = criteriaBuilder.and(admin, id0,in);

                return and;
            }
        });

        System.out.println(all);
    }

    @Test
    public void test_get02(){

        User user = new User();
        user.setUsername("admin");
        user.setId(0l).setRoleName("admin").setRole(0l);

        List<User> all = repository.findAll(new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//                root  form User,获取列
//                criteriaBuilder where  设置各种条件  （> < in ..）
//                query 组合（order by,where）
                Path<Long> id = root.get("id");
                Path<String> username = root.get("username");
                Path<String> roleName = root.get("roleName");

//              参数1：为哪个字段设置条件  参数2：值
                List<Predicate> list = new ArrayList<>();
                if(!StringUtils.isEmpty(user.getUsername())){
                    list.add(criteriaBuilder.equal(roleName, "admin"));
                }
                if(user.getRole() > -1){
                    list.add(criteriaBuilder.greaterThan(id, 0l));
                }
                if(!StringUtils.isEmpty(user.getRoleName())){
                    CriteriaBuilder.In<String> in = criteriaBuilder.in(roleName);
                    in.value("admin").value("ADMIN");
                    list.add(in);
                }


                Predicate and = criteriaBuilder.and(list.toArray(new Predicate[list.size()]));

                return and;
            }
        });

        System.out.println(all);
    }


    @Test
    public void test_get03(){

        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Object> query = criteriaBuilder.createQuery();
        Root<User> from = query.from(User.class);



        User user = new User();
        user.setUsername("admin");
        user.setId(0l).setRoleName("admin").setRole(0l);

        List<User> all = repository.findAll(new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//                root  form User,获取列
//                criteriaBuilder where  设置各种条件  （> < in ..）
//                query 组合（order by,where）
//                1、通过root拿到需要设置条件的字段
                Path<Long> id = root.get("id");
                Path<String> username = root.get("username");
                Path<String> roleName = root.get("roleName");

//              参数1：为哪个字段设置条件  参数2：值
//                2、设置不同类型的条件
                List<Predicate> list = new ArrayList<>();
                if(!StringUtils.isEmpty(user.getUsername())){
                    list.add(criteriaBuilder.equal(roleName, "admin"));
                }
                if(user.getRole() > -1){
                    list.add(criteriaBuilder.greaterThan(id, 0l));
                }
                if(!StringUtils.isEmpty(user.getRoleName())){
                    CriteriaBuilder.In<String> in = criteriaBuilder.in(roleName);
                    in.value("admin").value("ADMIN");
                    list.add(in);
                }

            //  组合条件
                Predicate and = criteriaBuilder.and(list.toArray(new Predicate[list.size()]));

                Order desc = criteriaBuilder.desc(id);
                return criteriaQuery.where(and).orderBy(desc).getGroupRestriction();
            }
        });

        System.out.println(all);
    }


}