java mybatis mysql 分表 mybatisplus分表查询

转载

mob64ca14048514 2023-11-15 17:56:30

一、新建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<T extends BaseEntity,E extends ApiWrapper> extends PageSerializable{private int pageNo = 1;
private int pageSize = 10;
/** 查询条件构造器 */
private QueryWrapper<T> 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<T> 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<T> pageInfo, List<E> 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<T> getQueryWrapper() {
    return queryWrapper;
}

public void setQueryWrapper(QueryWrapper<T> 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<AssetsInfo> queryBuilder = new GenQueryBuilder<>();
    Page<AssetsInfo, AssetsInfoModel> page = new Page<>(pageNo, pageSize);
    QueryWrapper<AssetsInfo> 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<String, String[]> parameterMap;
 /* Entity Clazz /
 private final Class<? extends BaseEntity> entityClazz;
 /* 默认排序字段 /
 private final String defaultOrderField;
 /* 配置类 */
 private WebQueryConf conf;
/**• 构造函数 只是生产 查询器
• @param entityClazz Entity 的 clazz
• @param parameterMap request 参数
 */
 public WebQueryBuilder(Class entityClazz, Map<String, String[]> 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<String, String[]> 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<String, String[]> 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<String, String[]> 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<String, String[]> 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<AssetsInfo, AssetsInfoModel> findPageAssets(Page<AssetsInfo, AssetsInfoModel> page) {
 page.pageHelperBegin();try {
        List<AssetsInfo> list = mapper.queryPageAssets(page.getQueryWrapper());
        PageInfo<AssetsInfo> pageInfo =new PageInfo<>(list);
        List<AssetsInfoModel>  es = WrapperUtil.transformInstance(pageInfo.getList(),AssetsInfoModel.class);
        page.instance(pageInfo,es);
    } finally {
       page.pageHelperEnd();
    }
    return page;

}


<select id="queryPageAssets" parameterType="AssetsInfo" resultType="com.in.modulars.assets.manage.entity.AssetsInfo">
  select a.*,
         <include refid="Base_Result_column"></include>
         <if test ="ew !=null and ew.sqlSelect != null  and ew.sqlSelect !='' ">
             ,${ew.SqlSelect}
         </if>
  from assets_info a left join debtor_info b on a.debtor_id =b.id
    ${ew.customSqlSegment}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。