leishen_66666

MybatisPlus多表分页查询

一、新建MybatisPlusConfig配置类文件
二、新建分页类
三、根据业务组装查询构造器
四、编写ServeImpl 以及编写mapper.xnl

一、
/**

MyBatis - Plus 配置

/
@Slf4j
@EnableTransactionManagement
@Configuration
public class MyBatisPlusConfig {
/**
* 乐观锁
* @return
*/

@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor(){
	return new OptimisticLockerInterceptor();
}

/**
 * Mybatis 拦截器
 * @param sqlSessionFactory
 * @return
 */
@Bean
public String myInterceptor(SqlSessionFactory sqlSessionFactory) {
	sqlSessionFactory.getConfiguration().addInterceptor(new MybatisAutoFillInterceptor());
	return "interceptor";
}

}

二、

/**

分页类

*/
@Slf4j
public class Page extends PageSerializable{

private int pageNo = 1;
private int pageSize = 10;
/** 查询条件构造器 */
private QueryWrapper queryWrapper;

public Page(){
    super();
}

/**
 * 分页 构造函数
 * @param pageNo 页
 * @param pageSize 分页大小
 */
public Page(int pageNo, int pageSize) {
    super();
    this.pageNo = pageNo;
    this.pageSize = pageSize;
}

/**
 * 分页 构造函数
 * @param pageNo 页
 * @param pageSize 分页大小
 * @param queryWrapper 查询条件
 */
public Page(int pageNo, int pageSize, QueryWrapper queryWrapper) {
    super();
    this.pageNo = pageNo;
    this.pageSize = pageSize;
    this.queryWrapper = queryWrapper;
}

/**
 * 分页函数
 */
public void pageHelperBegin(){
    this.pageHelperBegin(true);
}

/**
 * 分页函数 不统计 count
 */
public void pageHelperBegin(boolean countFlag){
    PageHelper.startPage(this.pageNo,this.pageSize, countFlag);
}

/**
 * 分页函数
 */
public void pageHelperEnd(){
    PageHelper.clearPage();
}


/**
 * 设置数据
 * @param pageInfo
 */
public void instance(PageInfo pageInfo, List list) {
    super.setList(list);
    super.setTotal(pageInfo.getTotal());
}


/**
 * 获取bootstrap data分页数据
 * @return map对象
 */
public Page.PageData getPageData(){
    Page.PageData pageData = new PageData();
    pageData.setRows(this.getList());
    pageData.setTotal(this.getTotal());
    return pageData;
}


// =======================================================

public int getPageNo() {
    return pageNo;
}

public void setPageNo(int pageNo) {
    this.pageNo = pageNo;
}

public int getPageSize() {
    return pageSize;
}

public void setPageSize(int pageSize) {
    this.pageSize = pageSize;
}

public QueryWrapper getQueryWrapper() {
    return queryWrapper;
}

public void setQueryWrapper(QueryWrapper queryWrapper) {
    this.queryWrapper = queryWrapper;
}


//

/**
 * 分页对象
 */
@Data
public static class PageData {

    /** 条数 */
    private Long total;

    /** 行 */
    private List rows;

}

三、

@ApiOperation(value = "获得分页数据", notes = "获得分页数据 - 查询构造器")
// @RequiresPermissions("assets_manage_select")
@EnableLog
@Override
public ResultVo findPage(String assetsStatus, String queryField,
                            BigDecimal minValue,BigDecimal maxValue,Integer pageNo, Integer pageSize, HttpServletRequest request) {
    QueryBuilder queryBuilder = new GenQueryBuilder<>();
    Page page = new Page<>(pageNo, pageSize);
    QueryWrapper queryWrapper = queryBuilder.build();

    if(!StringUtil.isBlank(queryField)){
        queryWrapper.between(queryField, minValue, maxValue);
    }
    if(!StringUtil.isBlank(type)){
        queryWrapper.eq("type", type);
    }
    if(!StringUtil.isBlank(lawsuitStatue)){
        queryWrapper.eq("lawsuit_statue", lawsuitStatue);
    }
    if(!StringUtil.isBlank(assetsStatus)){
        queryWrapper.eq("assets_status", assetsStatus);
    }
    queryWrapper.orderByDesc("a.update_time");

    page.setQueryWrapper(queryWrapper);
    page = IService.findPageAssets(page);

    return ResultVo.success(page.getPageData());
}

这里 QueryBuilder 查询构造器可以通过实现 implements QueryBuilder 给与一些默认updatetime 时间排序，合法验证，其中也可以定义一些构造函数达成自动组装查询条件，处理数据库字段与实体类字段转换关系等。
例子：
package com.in.core.persistence.querybuilder;

import cn.hutool.core.util.ReflectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.lang3.StringUtils;
import com.in.common.constants.MyBatisConstants;
import com.in.common.utils.HumpUtil;
import com.in.core.base.entity.BaseEntity;
import com.in.core.persistence.querybuilder.conf.WebQueryConf;

import java.util.Map;

/**

@Description: Web 条件构造器
*/
public class WebQueryBuilder implements QueryBuilder{

// == 匹配条件 ==
/** 全值匹配 /
private static final String EQ = “EQ”;
/* 模糊匹配 /
private static final String LIKE = “LIKE”;
/* 日期匹配 /
private static final String BEGIN = “BEGIN”;
private static final String END = “END”;
/* 排序方式 */
private static final String ORDER = “ORDER”;
private static final String ORDER_ASC = “ASC”;
private static final String ORDER_DESC = “DESC”;

/** 参数 /
private final Map parameterMap;
/* Entity Clazz /
private final Class entityClazz;
/* 默认排序字段 /
private final String defaultOrderField;
/* 配置类 */
private WebQueryConf conf;

/**
- 构造函数只是生产查询器
- @param entityClazz Entity 的 clazz
- @param parameterMap request 参数
  */
  public WebQueryBuilder(Class entityClazz, Map parameterMap){
  this.parameterMap = parameterMap;
  this.entityClazz = entityClazz;
  this.defaultOrderField = MyBatisConstants.FIELD_UPDATE_TIME;
  }
/**
- 构造函数只是生产查询器
- @param entityClazz Entity 的 clazz
- @param parameterMap request 参数
  */
  public WebQueryBuilder(Class entityClazz, Map parameterMap, WebQueryConf conf){
  this.parameterMap = parameterMap;
  this.entityClazz = entityClazz;
  this.defaultOrderField = MyBatisConstants.FIELD_UPDATE_TIME;
  this.conf = conf;
  }
/**
- 构造函数只是生产查询器
- @param entityClazz Entity 的 clazz
- @param parameterMap request 参数
- @param defaultOrderField 默认排序字段
  */
  public WebQueryBuilder(Class entityClazz, Map parameterMap,
  String defaultOrderField){
  this.parameterMap = parameterMap;
  this.entityClazz = entityClazz;
  this.defaultOrderField = defaultOrderField;
  }
/**
- 构造函数只是生产查询器
- @param entityClazz Entity 的 clazz
- @param parameterMap request 参数
- @param defaultOrderField 默认排序字段
- @param conf 配置
  */
  public WebQueryBuilder(Class entityClazz, Map parameterMap,
  String defaultOrderField, WebQueryConf conf){
  this.parameterMap = parameterMap;
  this.entityClazz = entityClazz;
  this.defaultOrderField = defaultOrderField;
  this.conf = conf;
  }
@Override
public QueryWrapper build() {
QueryWrapper queryWrapper = new QueryWrapper<>();
return this.createQueryWrapper(queryWrapper);
}

/**
- 创建查询条件构造器
- @return QueryWrapper
  */
  private QueryWrapper createQueryWrapper(QueryWrapper queryWrapper){
  if(this.parameterMap == null){
  return queryWrapper;
  }
  // order 排序次数如果为0 则默认按照修改时间来排序
  int orderCount = 0;
  for (Map.Entry stringEntry : this.parameterMap.entrySet()) {
  String keys = stringEntry.getKey();
  String[] values = stringEntry.getValue();
  // 非空检测
  if(StringUtils.isEmpty(keys) || values == null || StringUtils.isEmpty(values[0])){
  continue;
  }
```
 // 键 和 操作
 String[] keyHandle = keys.split("_");
 if(keyHandle.length < 2){
     continue;
 }

 // 键
 String key = keyHandle[0];
 // 操作
 String handle = keyHandle[1];

 // 判断 字段是否合法
 boolean hasField = this.validationField(key);
 if(hasField){
     // 验证操作是否合法
     boolean hasHandle = this.validationHandle(handle);
     if(hasHandle){
         // 处理值
         String value = values[0];
         // 赋值
         this.handlerValue(queryWrapper, handle, key ,value);
         // 如果有排序 就+1
         if(ORDER.equals(handle)){
             orderCount++;
         }
     }
 }
```
  }
  // 如果没有排序默认按照修改时间倒叙排序
  if(orderCount == 0){
  if(StringUtils.isNotEmpty(this.defaultOrderField)){
  String key = this.defaultOrderField;
  String keyStr = null;
  if(conf != null){
  keyStr = conf.get(key);
  }
```
     // 检测 Conf 配置中是否已经指定该配置
     if(StringUtils.isNotEmpty(keyStr)){
         key = keyStr;
     }else{
         // 转换驼峰 为 数据库下划线字段
         key = HumpUtil.humpToUnderline(key);
     }

     queryWrapper.orderByDesc(key);
 }
```
  }
  return queryWrapper;
  }
/**
- 处理值
- @param queryWrapper 查询构造器
- @param handle 操作
- @param key 键
- @param value 值
- @return
  */
  private void handlerValue(QueryWrapper queryWrapper, String handle, String key, String value){
  if(queryWrapper == null || StringUtils.isEmpty(handle)
  || StringUtils.isEmpty(key) || StringUtils.isEmpty(value)
  ){
  return;
  }
  String keyStr = null;
  if(conf != null){
  keyStr = conf.get(key);
  }
  
  // 检测 Conf 配置中是否已经指定该配置
  if(StringUtils.isNotEmpty(keyStr)){
  key = keyStr;
  }else{
  // 转换驼峰为数据库下划线字段
  key = HumpUtil.humpToUnderline(key);
  }
  
  switch (handle) {
  case EQ:
  // 全值匹配
  queryWrapper.eq(key, value);
  break;
  case LIKE:
  // 模糊匹配
  queryWrapper.like(key, value);
  break;
  case BEGIN:
  // 大于等于
  queryWrapper.ge(key, value);
  break;
  case END:
  // 小于等于
  queryWrapper.le(key, value);
  break;
  case ORDER:
  // 排序
  if (ORDER_ASC.equals(value)) {
  queryWrapper.orderByAsc(key);
  } else if (ORDER_DESC.equals(value)) {
  queryWrapper.orderByDesc(key);
  } else {
  queryWrapper.orderByAsc(key);
  }
  break;
  default:
  break;
  }
  }
/**
- 检测字段是否合法
- @param key key值
- @return boolean
  */
  private boolean validationField(String key){
  if(StringUtils.isEmpty(key)){
  return false;
  }
  
  boolean ret;
  // 先判断 conf 文件中是否包含改 key
  if(conf != null){
  ret = conf.hashKey(key);
  if(ret){
  return true;
  }
  }
  
  // entity 对象是否为空
  if(entityClazz == null){
  return false;
  }
  
  // 判断当前传入参数是否是Entity的字段
  return ReflectUtil.hasField(entityClazz, key);
  }
/**
- 检测操作是否合法
- @param handle 操作
- @return boolean
  */
  private boolean validationHandle(String handle){
  if(StringUtils.isEmpty(handle)){
  return false;
  }
  switch (handle) {
  case EQ:
  case END:
  case LIKE:
  case BEGIN:
  return true;
  default:
  return ORDER.equals(handle);
  }
  }
  }
  --------------------------------------------------------可以参考

四、
@Override
public Page findPageAssets(Page page) {
page.pageHelperBegin();

    try {
        List list = mapper.queryPageAssets(page.getQueryWrapper());
        PageInfo pageInfo =new PageInfo<>(list);
        List  es = WrapperUtil.transformInstance(pageInfo.getList(),AssetsInfoModel.class);
        page.instance(pageInfo,es);
    } finally {
       page.pageHelperEnd();
    }
    return page;

}