SpringBoot学习之旅(七)---JPA进阶篇之自定义查询、修改、分页

分手后的思念是犯贱 2022-04-23 14:18 488阅读 0赞

### 文章目录 ###

*   *   *   *  前言
             *  源码下载
             *  其他文章
             *  查询关键字
             *  自定义Select和Update
             *  分页及自定义分页
             *   *  自定义分页
                 *  分页查询的业务代码

#### 前言 ####

前一节[SpringBoot学习之旅(六)—JPA操作MySql（基础篇）][SpringBoot_JPA_MySql]讲述了通过默认的Repository方法，实现对数据库的一些基础性的操作，而且灰常的优雅，代码看起来也很简洁；但是实际的开发中，不可能只有简单的基础操作，必然会存在比较复杂的操作，使用默认的一些方法肯定是不能满足我们的需要的，因此，下面我们一起来探讨一下，如何使用Jpa进行复杂的、丰富的数据库操作，从而满足我们日常开发过程中的需要。本文基于[前一节][SpringBoot_JPA_MySql]的进阶，对于基础操作不熟悉的，可以先去看看，如果对Jpa的基础操作已经掌握了，可以直接阅读本章。

--------------------

#### 源码下载 ####

[点击开源中国下载源码][Link 1]

> 由于代码内容比较多多，建议优先下载代码，对着代码读更加快捷

#### 其他文章 ####

[SpringBoot学习之旅(八)—JPA进阶篇之联表操作][SpringBoot_JPA]

--------------------

#### 查询关键字 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">Keyword</th> 
   <th align="left">Sample</th> 
   <th align="left">JPQL snippet</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">And</td> 
   <td align="left">findByLastnameAndFirstname</td> 
   <td align="left">… where x.lastname = ?1 and x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td align="left">Or</td> 
   <td align="left">findByLastnameOrFirstname</td> 
   <td align="left">… where x.lastname = ?1 or x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td align="left">Is,Equals</td> 
   <td align="left">findByFirstname,findByFirstnameIs,findByFirstnameEquals</td> 
   <td align="left">… where x.firstname = ?1</td> 
  </tr> 
  <tr> 
   <td align="left">Between</td> 
   <td align="left">findByStartDateBetween</td> 
   <td align="left">… where x.startDate between ?1 and ?2</td> 
  </tr> 
  <tr> 
   <td align="left">LessThan</td> 
   <td align="left">findByAgeLessThan</td> 
   <td align="left">… where x.age &lt; ?1</td> 
  </tr> 
  <tr> 
   <td align="left">LessThanEqual</td> 
   <td align="left">findByAgeLessThanEqual</td> 
   <td align="left">… where x.age &lt;= ?1</td> 
  </tr> 
  <tr> 
   <td align="left">GreaterThan</td> 
   <td align="left">findByAgeGreaterThan</td> 
   <td align="left">… where x.age &gt; ?1</td> 
  </tr> 
  <tr> 
   <td align="left">GreaterThanEqual</td> 
   <td align="left">findByAgeGreaterThanEqual</td> 
   <td align="left">… where x.age &gt;= ?1</td> 
  </tr> 
  <tr> 
   <td align="left">After</td> 
   <td align="left">findByStartDateAfter</td> 
   <td align="left">… where x.startDate &gt; ?1</td> 
  </tr> 
  <tr> 
   <td align="left">Before</td> 
   <td align="left">findByStartDateBefore</td> 
   <td align="left">… where x.startDate &lt; ?1</td> 
  </tr> 
  <tr> 
   <td align="left">IsNull</td> 
   <td align="left">findByAgeIsNull</td> 
   <td align="left">… where x.age is null</td> 
  </tr> 
  <tr> 
   <td align="left">IsNotNull,NotNull</td> 
   <td align="left">findByAge(Is)NotNull</td> 
   <td align="left">… where x.age not null</td> 
  </tr> 
  <tr> 
   <td align="left">Like</td> 
   <td align="left">findByFirstnameLike</td> 
   <td align="left">… where x.firstname like ?1</td> 
  </tr> 
  <tr> 
   <td align="left">NotLike</td> 
   <td align="left">findByFirstnameNotLike</td> 
   <td align="left">… where x.firstname not like ?1</td> 
  </tr> 
  <tr> 
   <td align="left">StartingWith</td> 
   <td align="left">findByFirstnameStartingWith</td> 
   <td align="left">… where x.firstname like ?1 (parameter bound with appended %)</td> 
  </tr> 
  <tr> 
   <td align="left">EndingWith</td> 
   <td align="left">findByFirstnameEndingWith</td> 
   <td align="left">… where x.firstname like ?1 (parameter bound with prepended %)</td> 
  </tr> 
  <tr> 
   <td align="left">Containing</td> 
   <td align="left">findByFirstnameContaining</td> 
   <td align="left">… where x.firstname like ?1 (parameter bound wrapped in %)</td> 
  </tr> 
  <tr> 
   <td align="left">OrderBy</td> 
   <td align="left">findByAgeOrderByLastnameDesc</td> 
   <td align="left">… where x.age = ?1 order by x.lastname desc</td> 
  </tr> 
  <tr> 
   <td align="left">Not</td> 
   <td align="left">findByLastnameNot</td> 
   <td align="left">… where x.lastname &lt;&gt; ?1</td> 
  </tr> 
  <tr> 
   <td align="left">In</td> 
   <td align="left">findByAgeIn(Collection ages)</td> 
   <td align="left">… where x.age in ?1</td> 
  </tr> 
  <tr> 
   <td align="left">NotIn</td> 
   <td align="left">findByAgeNotIn(Collection ages)</td> 
   <td align="left">… where x.age not in ?1</td> 
  </tr> 
  <tr> 
   <td align="left">True</td> 
   <td align="left">findByActiveTrue()</td> 
   <td align="left">… where x.active = true</td> 
  </tr> 
  <tr> 
   <td align="left">False</td> 
   <td align="left">findByActiveFalse()</td> 
   <td align="left">… where x.active = false</td> 
  </tr> 
  <tr> 
   <td align="left">IgnoreCase</td> 
   <td align="left">findByFirstnameIgnoreCase</td> 
   <td align="left">… where UPPER(x.firstame) = UPPER(?1)</td> 
  </tr> 
 </tbody> 
</table>

#### 自定义Select和Update ####

*  说明  
    开发过程中，我们不可能只会使用到索引进行数据查询，可能还涉及到其他的字段对数据进行筛选，那么我们只要遵循以上的关键字规范，即可进行更对的数据的查询
 *  编码
    
     *  定义Repository
        
            package com.lupf.springbootjpa.repository;
            
            import com.lupf.springbootjpa.dbobject.UserInfo;
            import org.springframework.data.jpa.repository.JpaRepository;
            import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
            import org.springframework.data.jpa.repository.Modifying;
            import org.springframework.data.jpa.repository.Query;
            import org.springframework.stereotype.Repository;
            import org.springframework.transaction.annotation.Transactional;
            
            import java.util.List;
            
            @Repository
            public interface UserAdvRepository extends JpaRepository<UserInfo, Integer>, JpaSpecificationExecutor<UserInfo> {
            
                //根据电话号码查询用户
                UserInfo findUserInfoByTelphone(String telPhone);
            
                //根据用户名或者电话号码查询用户
                UserInfo findUserInfoByNameAndTelphone(String name, String telPhone);
            
                //根据用户id 名称 及电话号码查询用户
                UserInfo findUserInfoByIdAndNameAndTelphone(Integer id, String name, String telPhone);
            
                //根据名称 或者 电话号码查询用户
                List<UserInfo> findUserInfoByNameOrTelphone(String name, String telPhone);
            
                //根据id修改用户的头像
                @Transactional
                @Modifying(clearAutomatically = true)
                @Query(value = "update user_info set avatar =?1 where id = ?2", nativeQuery = true)
                int updateAvatarById(String avatar, Integer id);
            }
     *  定义Service
        
            package com.lupf.springbootjpa.service;
            
            import com.lupf.springbootjpa.service.model.UserInfoModel;
            import org.springframework.transaction.annotation.Transactional;
            
            import java.util.List;
            
            public interface UserAdvService {
                //根据电话号码查询用户
                UserInfoModel findUserInfoByTelphone(String telPhone);
            
                //根据用户名或者电话号码查询用户
                UserInfoModel findUserInfoByNameAndTelphone(String name, String telPhone);
            
                //根据用户id 名称 及电话号码查询用户
                UserInfoModel findUserInfoByIdAndNameAndTelphone(Integer id, String name, String telPhone);
            
                //根据名称 或者 电话号码查询用户
                List<UserInfoModel> findUserInfoByNameOrTelphone(String name, String telPhone);
            
                //根据id修改用户的邮箱
                @Transactional
                UserInfoModel updateEmailById(String email, Integer id);
            
                //根据id修改用户的头像
                int updateAvatarById(String avatar, Integer id);
            }
     *  service实现  
        注：这里并不是实际的业务开发，只是做的demo，因此，很多参数并没有进行详细的校验，实际开发中，请完善校验，增强代码的健壮性
        
            package com.lupf.springbootjpa.service.impl;
            
            import com.lupf.springbootjpa.dbobject.UserInfo;
            import com.lupf.springbootjpa.repository.UserAdvRepository;
            import com.lupf.springbootjpa.service.UserAdvService;
            import com.lupf.springbootjpa.service.model.UserInfoModel;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.stereotype.Service;
            
            import java.util.List;
            import java.util.Optional;
            import java.util.stream.Collectors;
            
            @Service
            public class UserAdvServiceImpl extends UserServiceBase implements UserAdvService {
                @Autowired
                UserAdvRepository userAdvRepository;
            
                @Override
                public UserInfoModel findUserInfoByTelphone(String telPhone) {
                    UserInfo userInfo = userAdvRepository.findUserInfoByTelphone(telPhone);
                    return dbo2model(userInfo);
                }
            
                @Override
                public UserInfoModel findUserInfoByNameAndTelphone(String name, String telPhone) {
                    UserInfo userInfo = userAdvRepository.findUserInfoByNameAndTelphone(name, telPhone);
                    return dbo2model(userInfo);
                }
            
                @Override
                public UserInfoModel findUserInfoByIdAndNameAndTelphone(Integer id, String name, String telPhone) {
                    UserInfo userInfo = userAdvRepository.findUserInfoByIdAndNameAndTelphone(id, name, telPhone);
                    return dbo2model(userInfo);
                }
            
                @Override
                public List<UserInfoModel> findUserInfoByNameOrTelphone(String name, String telPhone) {
                    List<UserInfo> userInfos = userAdvRepository.findUserInfoByNameOrTelphone(name, telPhone);
                    if (null != userInfos) {
                        List<UserInfoModel> userInfoModels = userInfos.stream().map(userInfo -> dbo2model(userInfo)).collect(Collectors.toList());
                        return userInfoModels;
                    }
                    return null;
                }
            
                @Override
                public UserInfoModel updateEmailById(String email, Integer id) {
                    Optional<UserInfo> userInfoOptional = userAdvRepository.findById(id);
                    if (null != userInfoOptional && userInfoOptional.isPresent()) {
                        UserInfo userInfo = userInfoOptional.get();
                        userInfo.setEmail(email);
                        UserInfo updateUserInfo = userAdvRepository.save(userInfo);
                        return dbo2model(updateUserInfo);
                    }
                    return null;
                }
            
                @Override
                public int updateAvatarById(String avatar, Integer id) {
                    int updateNum = userAdvRepository.updateAvatarById(avatar, id);
                    return updateNum;
                }
            }
     *  单元测试
        
            package com.lupf.springbootjpa.service.impl;
            
            import com.alibaba.fastjson.JSON;
            import com.lupf.springbootjpa.service.UserAdvService;
            import com.lupf.springbootjpa.service.model.UserInfoModel;
            import lombok.extern.slf4j.Slf4j;
            import org.junit.Test;
            import org.junit.runner.RunWith;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.boot.test.context.SpringBootTest;
            import org.springframework.stereotype.Repository;
            import org.springframework.test.context.junit4.SpringRunner;
            
            import java.util.List;
            
            import static org.junit.Assert.*;
            
            @RunWith(SpringRunner.class)
            @SpringBootTest
            @Slf4j
            public class UserAdvServiceImplTest {
            
                @Autowired
                UserAdvService userAdvService;
            
                @Test
                public void updateEmailById() {
                    UserInfoModel userInfoModel = userAdvService.updateEmailById("123@qq.com", 18);
                    log.info(JSON.toJSONString(userInfoModel));
                }
            
                @Test
                public void updateAvatarById() {
                    int updateNum = userAdvService.updateAvatarById("http://a123456.com/a.png", 18);
                    log.info(String.valueOf(updateNum));
                }
            
                @Test
                public void findUserInfoByTelphone() {
                    UserInfoModel userInfoModel = userAdvService.findUserInfoByTelphone("13800000000");
                    log.info(JSON.toJSONString(userInfoModel));
                }
            
                @Test
                public void findUserInfoByNameAndTelphone() {
                    UserInfoModel userInfoModel = userAdvService.findUserInfoByNameAndTelphone("张三", "13800000000");
                    log.info(JSON.toJSONString(userInfoModel));
                }
            
                @Test
                public void findUserInfoByIdAndNameAndTelphone() {
                    UserInfoModel userInfoModel = userAdvService.findUserInfoByIdAndNameAndTelphone(18, "张三", "13800000000");
                    log.info(JSON.toJSONString(userInfoModel));
                }
            
                @Test
                public void findUserInfoByNameOrTelphone() {
                    List<UserInfoModel> userInfoModels = userAdvService.findUserInfoByNameOrTelphone("张三", "13612345678");
                    log.info(JSON.toJSONString(userInfoModels));
                }
            }
     *  测试  
        这里为了节省篇幅，就不做一一的截图展示了，需要测试的，可自行下载代码，跑测试用例即可
    
    #### 分页及自定义分页 ####
    
    ##### 自定义分页 #####
    
    默认的分页，在使用起来，会降低代码的可读性和优雅性，为了能更好的满足开发需要，我们对部分分页操作进行自定义，所谓的自定义，更多的就是简化Specification的组装，让其更加的简便；
    
     *  第一种方式：自定义执行操作类型的Specification帮助类
        
            package com.lupf.springbootjpa.repository.custom;
            
            import org.springframework.data.jpa.domain.Specification;
            
            import javax.persistence.EntityManager;
            import javax.persistence.criteria.*;
            import javax.persistence.metamodel.Attribute;
            import javax.persistence.metamodel.EntityType;
            import java.util.*;
            
            /**
             * 根据这个类，定义我们需要操作的字段及操作方式
             */
            public class CustomerOperators {
            
                private Map<String, CustomField> map = new HashMap<>();
            
                public CustomerOperators addOpes(String fieldName, CustomField.Operator operator, Object... value) {
                    CustomField opes = map.get(fieldName);
                    if (null == opes) {
                        opes = new CustomField(fieldName, operator, value);
                        map.put(fieldName, opes);
                    }
                    return this;
                }
            
                /**
                 * 根据addName方法加入进来的对象 这里将其转换为Specification对象，用于参与查询
                 *
                 * @param entityManager
                 * @param example
                 * @param <T>
                 * @return
                 */
                public <T> Specification<T> byAuto(final EntityManager entityManager, final T example) {
                    //获取实体的类型
                    final Class<T> type = (Class<T>) example.getClass();
                    return new Specification<T>() {
            
                        @Override
                        public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
                            //创建一个Predicate用于保存查询条件
                            List<Predicate> predicates = new ArrayList<>();
                            if (null != map && map.size() > 0) {
                                //获取实体类的EntityType 可以从这个EntityType中获取实体中的数据
                                EntityType<T> entity = entityManager.getMetamodel().entity(type);
                                //对实体的数据做循环
                                for (Attribute<T, ?> attr : entity.getDeclaredAttributes()) {
                                    String name = attr.getName();
                                    CustomField customPredicate = map.get(name);
                                    if (null != customPredicate) {
                                        Path p = root.get(name);
                                        Object[] vas = customPredicate.value;
                                        if (null != vas && vas.length > 0) {
                                            switch (customPredicate.operator) {
                                                case EQ:
                                                    predicates.add(cb.equal(p, vas[0]));
                                                    break;
                                                case LIKE:
                                                    //只有String类型的时候才去做模糊匹配
                                                    if (vas[0] instanceof String && attr.getJavaType() == String.class) {
                                                        predicates.add(cb.like(p, "%" + customPredicate.value[0] + "%"));
                                                    }
                                                    break;
                                            }
                                        }
                                    }
                                }
                            }
            
                            // 将所有条件用 and 联合起来
                            if (!predicates.isEmpty()) {
                                return cb.and(predicates.toArray(new Predicate[predicates.size()]));
                            }
            
                            return cb.conjunction();
                        }
                    };
                }
            }
     *  第二种方式：根据传递的对象中属性值作为查询条件的帮助类
        
            package com.lupf.springbootjpa.repository.custom;
            
            import org.springframework.data.jpa.domain.Specification;
            import org.springframework.util.ReflectionUtils;
            import org.springframework.util.StringUtils;
            
            import static com.google.common.collect.Iterables.toArray;
            
            import javax.persistence.EntityManager;
            import javax.persistence.criteria.CriteriaBuilder;
            import javax.persistence.criteria.CriteriaQuery;
            import javax.persistence.criteria.Predicate;
            import javax.persistence.criteria.Root;
            import javax.persistence.metamodel.Attribute;
            import javax.persistence.metamodel.EntityType;
            import javax.persistence.metamodel.SingularAttribute;
            import java.lang.reflect.Field;
            import java.util.ArrayList;
            import java.util.List;
            
            /**
             * 根据传递的T对象中的属性值 组装对应的predicates 用于作为分页的查询条件
             * String类型的是进行迷糊查询 其他类型的均使用equal
             */
            public class CustomerSpecs {
                //这里定义一个返回值为Specification的方法byAuto,由于参数是泛型T,所以这个Specification适合任何数据类型
                //传递的EntityManager和T对象中包含的值作为查询条件
                public static <T> Specification<T> byAuto(final EntityManager entityManager, final T example) {
            
                    //获取实体的类型
                    final Class<T> type = (Class<T>) example.getClass();
            
                    return new Specification<T>() {
                        @Override
                        public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                            //创建一个Predicate用于保存查询条件
                            List<Predicate> predicates = new ArrayList<>();
                            //获取实体类的EntityType 可以从这个EntityType中获取实体中的数据
                            EntityType<T> entity = entityManager.getMetamodel().entity(type);
                            //对实体的数据做循环
                            for (Attribute<T, ?> attr : entity.getDeclaredAttributes()) {
                                //获取属性的属性值
                                Object attrValue = getValue(example, attr);
                                //判断属性值是否为null 是空的话就直接过掉
                                if (attrValue != null) {
                                    //获取属性的的类型为java的String的时候
                                    if (attr.getJavaType() == String.class) {
                                        //判断值是否为null或者空字符串
                                        if (!StringUtils.isEmpty(attrValue)) {
                                            //如果是字符串的话,就在字符串的前后加上%，并将其添加到条件列表中
                                            //构造的属性为like，用于进行模糊查询
                                            predicates.add(cb.like(root.get(attrubute(entity, attr.getName(), String.class)), pattern((String) attrValue)));
                                        }
                                    } else {
                                        //如果是非字符串类型，那么就直接添加到条件列表中
                                        //构造的属性为equal，用于做相等查询
                                        predicates.add(cb.equal(root.get(attrubute(entity, attr.getName(), attr.getJavaType())), attrValue));
                                    }
                                }
                            }
            
                            //将条件列表转换为Predicate
                            return predicates.isEmpty() ? cb.conjunction() : cb.and(toArray(predicates, Predicate.class));
                        }
            
                        //通过反射获取实体对应属性的属性值
                        private <T> Object getValue(T example, Attribute<T, ?> attr) {
                            return ReflectionUtils.getField((Field) attr.getJavaMember(), example);
                        }
            
                        //获取当前属性的SingularAttribute，SingularAttribute包含了实体类中的某个单独的属性
                        private <E, T> SingularAttribute<T, E> attrubute(EntityType<T> entityType, String fieldName, Class<E> fieldClass) {
                            return entityType.getDeclaredSingularAttribute(fieldName, fieldClass);
                        }
                    };
                }
            
                static private String pattern(String str) {
                    return "%" + str + "%";
                }
            }
 *  帮助类
    
     *  第一种方式的辅助工具类
        
            package com.lupf.springbootjpa.repository.custom;
            
            /**
             * 需要进行筛选的属性、属性值、操作类型
             */
            public class CustomField {
            
                /**
                 * 操作类型
                 */
                public enum Operator {
                    EQ,//相等
                    LIKE,//模糊匹配     
                    //...
                    //这里还可以存在更多的操作，可以根据具体的请求添加
                    //添加之后需要在CustomerOperators.byAuto.toPredicate的switch方法中添加枚举对应的动作即可        ;
                }
                
                //属性名称
                public String fieldName;
                //操作类型
                public CustomField.Operator operator;
                //待匹配的值 可能需要传递多个值，因此这里使用数组
                public Object[] value;
            
                /**
                 * @param fieldName
                 * @param operator
                 * @param value
                 */
                public CustomField(String fieldName, CustomField.Operator operator, Object... value) {
                    this.fieldName = fieldName;
                    this.operator = operator;
                    this.value = value;
                }
            }
 *  **自定义Repository**
    
     *  CustomRepository
        
            package com.lupf.springbootjpa.repository.custom;
            
            import org.springframework.data.domain.Page;
            import org.springframework.data.domain.Pageable;
            import org.springframework.data.jpa.repository.JpaRepository;
            import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
            import org.springframework.data.repository.NoRepositoryBean;
            
            import java.io.Serializable;
            
            @NoRepositoryBean//标识当前接口不是领域类的接口
            public interface CustomRepository<T, ID extends Serializable> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T> {
                //查找对象 根据传递的对象中的值查找，如果是String的数据，会进行模糊匹配
                Page<T> findByAuto(T example, Pageable pageable);
            
                Page<T> findByAuto(T example, CustomerOperators ops, Pageable pageable);
            }
     *  CustomRepositoryImpl
        
            package com.lupf.springbootjpa.repository.custom;
            
            import org.springframework.data.domain.Page;
            import org.springframework.data.domain.Pageable;
            import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
            
            import javax.persistence.EntityManager;
            import java.io.Serializable;
            
            import static com.lupf.springbootjpa.repository.custom.CustomerSpecs.*;
            
            public class CustomRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements CustomRepository<T, ID> {
                private final EntityManager entityManager;
            
                /**
                 * 构造方法
                 *
                 * @param domainClass
                 * @param em          EntityManager对象
                 */
                public CustomRepositoryImpl(Class<T> domainClass, EntityManager em) {
                    super(domainClass, em);
                    this.entityManager = em;
                }
            
                /**
                 * 匹配对象值的方法 除了String模糊匹配，其他有值的数据绝对匹配
                 *
                 * @param example  数据对象
                 * @param pageable 分页
                 * @return
                 */
                @Override
                public Page<T> findByAuto(T example, Pageable pageable) {
                    return findAll(byAuto(entityManager, example), pageable);
                }
            
                /**
                 * 根据Operators中添加的要操作的属性进行操作
                 *
                 * @param example  数据对象
                 * @param odu      操作方式及属性值
                 * @param pageable 分页
                 * @return
                 */
                @Override
                public Page<T> findByAuto(T example, CustomerOperators opes, Pageable pageable) {
                    return findAll(odu.byAuto(entityManager, example), pageable);
                }
            
            }
     *  RepositoryFactory工厂类
        
            package com.lupf.springbootjpa.repository.custom;
            
            import org.springframework.data.jpa.repository.JpaRepository;
            import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
            import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
            import org.springframework.data.jpa.repository.support.JpaRepositoryImplementation;
            import org.springframework.data.repository.core.RepositoryInformation;
            import org.springframework.data.repository.core.RepositoryMetadata;
            import org.springframework.data.repository.core.support.RepositoryFactorySupport;
            
            import javax.persistence.EntityManager;
            import java.io.Serializable;
            
            public class CustomRepositoryFactoryBean<T extends JpaRepository<S, ID>, S, ID extends Serializable> extends JpaRepositoryFactoryBean<T, S, ID> {
                public CustomRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
                    super(repositoryInterface);
                }
            
                @Override
                protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
                    return new CustomRepositoryFactory(entityManager);
                }
            
                /**
                 * 自定义CustomRepository工厂类 继承自JpaRepositoryFactory
                 */
                private static class CustomRepositoryFactory extends JpaRepositoryFactory {
                    //构造方法
                    public CustomRepositoryFactory(EntityManager entityManager) {
                        super(entityManager);
                    }
            
                    /**
                     * 获取自定义的Repository
                     *
                     * @param information
                     * @param entityManager
                     * @return
                     */
                    @Override
                    protected JpaRepositoryImplementation<?, ?> getTargetRepository(RepositoryInformation information, EntityManager entityManager) {
                        //实例化返回CustomRepositoryImpl
                        return new CustomRepositoryImpl<>(information.getDomainType(), entityManager);
                    }
            
                    /**
                     * 重写getRepositoryBaseClass 指明当前Repository实现的类型
                     *
                     * @param metadata
                     * @return
                     */
                    @Override
                    protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
                        return CustomRepositoryImpl.class;
                    }
                }
            }
     *  项目入口添加自定义Repository的指向
        
            @EnableJpaRepositories(repositoryFactoryBeanClass = CustomRepositoryFactoryBean.class)
            @SpringBootApplication
            public class SpringBootJpaApplication {
                public static void main(String[] args) {
                    SpringApplication.run(SpringBootJpaApplication.class, args);
                }
            }

##### 分页查询的业务代码 #####

*  UserPageRepository
    
        package com.lupf.springbootjpa.repository;
        
        import com.lupf.springbootjpa.dbobject.UserInfo;
        import com.lupf.springbootjpa.repository.custom.CustomRepository;
        
        public interface UserPageRepository extends CustomRepository<UserInfo, Integer> {
        }
 *  定义Service  
    指定对应的查询操作
    
        package com.lupf.springbootjpa.service;
        
        import com.lupf.springbootjpa.repository.custom.CustomerOperators;
        import com.lupf.springbootjpa.service.model.UserInfoModel;
        import org.springframework.data.domain.Page;
        import org.springframework.data.domain.Pageable;
        
        public interface UserPageService {
            //使用自定义的CustomerSpecs进行对象属性匹配查询
            Page<UserInfoModel> getUserByPage(UserInfoModel userInfoModel, Pageable pageable);
        
            //使用自带的Specification 通过new对象组装查询条件查询
            Page<UserInfoModel> getUserByAge(UserInfoModel userInfoModel, Pageable pageable);
        
            // 使用自定义的CustomerOperators 指定需要查询的参数及动作进行查询
            Page<UserInfoModel> getUserByPage(UserInfoModel userInfoModel, CustomerOperators ops, Pageable pageable);
        }
 *  实现Service接口
    
        package com.lupf.springbootjpa.service.impl;
        
        import com.lupf.springbootjpa.dbobject.UserInfo;
        import com.lupf.springbootjpa.repository.UserPageRepository;
        import com.lupf.springbootjpa.repository.custom.CustomField.Operator;
        import com.lupf.springbootjpa.repository.custom.CustomerOperators;
        import com.lupf.springbootjpa.service.UserPageService;
        import com.lupf.springbootjpa.service.model.UserInfoModel;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.data.domain.Page;
        import org.springframework.data.domain.Pageable;
        import org.springframework.data.jpa.domain.Specification;
        import org.springframework.stereotype.Service;
        
        import javax.persistence.criteria.*;
        
        @Service
        public class UserPageServiceImpl extends UserServiceBase implements UserPageService {
        
            @Autowired
            UserPageRepository userPageRepository;
        
            @Override
            public Page<UserInfoModel> getUserByPage(UserInfoModel userInfoModel, Pageable pageable) {
                UserInfo userInfo = model2dbo(userInfoModel);
                Page<UserInfo> userInfos = userPageRepository.findByAuto(userInfo, pageable);
        
                return pagedbo2model(userInfos);
            }
        
            @Override
            public Page<UserInfoModel> getUserByAge(UserInfoModel userInfoModel, Pageable pageable) {
                Specification<UserInfo> specification = (Specification<UserInfo>) (root, query, cb) -> {
                    Path<Integer> agePath = root.get("age");
                    Predicate agep = cb.gt(agePath, userInfoModel.getAge());
        
                    //这里还可以添加更多的查询条件
                    //....
        
                    Predicate p = cb.and(agep);
                    return p;
                };
                Page<UserInfo> userInfos = userPageRepository.findAll(specification, pageable);
                return pagedbo2model(userInfos);
            }
        
            @Override
            public Page<UserInfoModel> getUserByPage(UserInfoModel userInfoModel, CustomerOperators ops, Pageable pageable) {
                ops.addOpes("name", Operator.LIKE, userInfoModel.getName());
                ops.addOpes("age", Operator.EQ, userInfoModel.getAge());
                UserInfo userInfo = new UserInfo();
                Page<UserInfo> userInfos = userPageRepository.findByAuto(userInfo, ops, pageable);
                return pagedbo2model(userInfos);
            }
        
        }
 *  创建测试用例
    
        package com.lupf.springbootjpa.service.impl;
        
        import com.alibaba.fastjson.JSON;
        import com.lupf.springbootjpa.repository.custom.CustomerOperators;
        import com.lupf.springbootjpa.service.UserPageService;
        import com.lupf.springbootjpa.service.model.UserInfoModel;
        import lombok.extern.slf4j.Slf4j;
        import org.junit.Test;
        import org.junit.runner.RunWith;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.test.context.SpringBootTest;
        import org.springframework.data.domain.Page;
        import org.springframework.data.domain.PageRequest;
        import org.springframework.test.context.junit4.SpringRunner;
        
        @RunWith(SpringRunner.class)
        @SpringBootTest
        @Slf4j
        public class UserPageServiceImplTest {
            @Autowired
            UserPageService userPageService;
        
            @Test
            public void getUserByPage() {
                PageRequest pageRequest = new PageRequest(0, 3);
                UserInfoModel userInfoModel = new UserInfoModel();
        //        userInfoModel.setSex(new Byte("2"));
                userInfoModel.setAge(12);
                userInfoModel.setName("测试添加1");
                Page<UserInfoModel> userInfoModels = userPageService.getUserByPage(userInfoModel, pageRequest);
                log.info(JSON.toJSONString(userInfoModels));
            }
        
            @Test
            public void getUserByAge() {
                PageRequest pageRequest = new PageRequest(0, 3);
                UserInfoModel userInfoModel = new UserInfoModel();
                userInfoModel.setAge(12);
                Page<UserInfoModel> userInfoModels = userPageService.getUserByAge(userInfoModel, pageRequest);
                log.info(JSON.toJSONString(userInfoModels));
            }
        
            @Test
            public void getUserByPage1() {
                PageRequest pageRequest = new PageRequest(0, 3);
                UserInfoModel userInfoModel = new UserInfoModel();
                CustomerOperators opu = new CustomerOperators();
                userInfoModel.setAge(12);
                userInfoModel.setName("测试添加1");
                Page<UserInfoModel> userInfoModels = userPageService.getUserByPage(userInfoModel, opu, pageRequest);
                log.info(JSON.toJSONString(userInfoModels));
            }
        }
 *  测试结果  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70][]  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 1][]  
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 2][]

到此，自定义查询、修改、分页操作完成。  
下一节会讲解JPA进行联表操作。

[SpringBoot_JPA_MySql]: https://blog.csdn.net/lupengfei1009/article/details/88569817
[Link 1]: https://gitee.com/pengfeilu/spring-boot-jpa/tree/master/src/main/java/com/lupf/springbootjpa
[SpringBoot_JPA]: https://blog.csdn.net/lupengfei1009/article/details/88623140
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70]: /images/20220308/277fedc52647489f8d7a52bc69d3cd2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 1]: /images/20220308/065d81d20f1141febe315386cc362645.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1cGVuZ2ZlaTEwMDk_size_16_color_FFFFFF_t_70 2]: /images/20220308/827e3546947d405c8c51ae000d81979b.png