pagehelper分页工具类的封装

<!-- pagehelper 分页插件 -->
<dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper-spring-boot-starter</artifactId>
      <version>1.2.5</version>
        </dependency>
        <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper-spring-boot-autoconfigure</artifactId>
      <version>1.2.3</version>
  </dependency>
        
        <!--AOP依赖-->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

# PageHelper分页插件

#  使用的数据库,如果是mysql,这里替换成mysql
pagehelper.helperDialect= oracle

# 当该参数设置为 true 时，pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页
pagehelper.reasonable= true

# 支持通过 Mapper 接口参数来传递分页参数
pagehelper.supportMethodsArguments= true

package com.rems.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @program: rems
 * @description: 分页注解
 * @author: hu.chen
 * @createDate: 2021年05月08日 10:34
 **/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Page {
}

package com.rems.aop;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.rems.pojo.PageFilter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.util.ObjectUtils;

/**
 * @program: rems
 * @description: 分页逻辑织入
 * @author: hu.chen
 * @createDate: 2021年05月08日 10:36
 **/
//声明当前类是配置类
@Configuration
//标注当前类是Aop切面类
@Aspect
@Slf4j
//开启Aop增强
@EnableAspectJAutoProxy
public class PageAop {


    /**
     * 定义切入点
     */
    @Pointcut("@annotation(com.rems.annotation.Page)")
    public void annotation() {
    }

    /**
     * 环绕增强
     */
    @Around("annotation()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
         // 当前页码
      String pageNum="1";
          //每页记录数
       String pageSize="10";
        PageFilter pageFilter=null;
        //获取被增强方法的参数
        Object[] args = proceedingJoinPoint.getArgs();
        for (Object arg : args) {
            if(arg instanceof PageFilter) {
               pageFilter=(PageFilter) arg;
                pageNum=ObjectUtils.isEmpty(pageFilter.getPageNum())? pageNum:pageFilter.getPageNum();
                pageSize=ObjectUtils.isEmpty(pageFilter.getPageSize())? pageSize:pageFilter.getPageSize();
            }
        }
        Object result = null;
        try {
            //调用分页插件传入开始页码和页面容量
            Page<Object> page = PageHelper.startPage(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
            //执行被增强的方法，不写，则被增强方法不执行
            result = proceedingJoinPoint.proceed(args);
            //获取并封装分页后的参数
            pageFilter.setPageNum(String.valueOf(page.getPageNum()));
            pageFilter.setPages(page.getPages());
            pageFilter.setPageSize(String.valueOf(page.getPageSize()));
            pageFilter.setTotal(page.getTotal());


        } catch (Exception e) {
            log.info("查询数据库异常",e);
        }
        return result;
    }
}

package com.rems.pojo;

import lombok.Data;

import java.util.List;


/**
 * @program: rems
 * @description: 分页类
 * @author: hu.chen
 * @createDate: 2021年04月23日 18:26
 **/
@Data
public class PageFilter<T> {

    /**
     * 总条数
     */
    private long total;

    /**
     * 当前页码
     */
    private String pageNum;

    /**
     * 每页记录数
     */
    private String pageSize;

    /**
     * 总页数
     */
    private Integer pages;

    private List<T> data;

    /**
     * @param obj 继承了PageFilter类的子类
     * @param response 从数据库查询出来的参数
     * @return
     */
    public PageFilter getPageFilter(PageFilter obj,List<T> response) {
        PageFilter<T> pages = new PageFilter();
        pages.setPageNum(String.valueOf(obj.getPageNum()));
        pages.setPages(obj.getPages());
        pages.setPageSize(String.valueOf(obj.getPageSize()));
        pages.setTotal(obj.getTotal());
        pages.setData(response);
        return pages;
    }
}

  /**
     * @Description: 根据动态条件查询需求表
     * @Param: [demand]
     * @return: com.rems.pojo.Demand
     * @Author: chenhu
     * @Date: 2021/4/23
     */
    @Page
    List<Demand> getDemandByDynamiCondition(GetDemandDo demand);

/**
* @Description: 查询根据条件动态查询需求列表并分页
* @Param:
* @return:
* @Author: chenhu
*/
    @Override
    public PageFilter<DemandVo> getDemandByDynamiCondition(GetDemandDo demand) {
    
        //分页查询需求
        List<DemandVo> demands = demandMapper.getDemandByDynamiCondition(demand).stream()
                .map(item -> {
                    DemandVo demandVo = new DemandVo();
                    BeanUtils.copyProperties(item, demandVo);
                    return demandVo;
                }).collect(Collectors.toList());
                
        //这个方法调用的是继承自父类：PageFilter的方法，将封装了查询参数的对象放入，
                    //再将数据库查询并处理好的返回对象放入即可
        return demand.getPageFilter(demand, demands);
    }

/**
     * 根据条件动态查询需求
     *
     * @param demand
     * @return
     */
    @GetMapping("/getDemand")
    public AjaxData getDemand(GetDemandDo demand) {
    
        return AjaxData.success(demandService.getDemandByDynamiCondition(demand));
        
    }