Mybatis plus 動態分頁

Mybatis plus 動態分頁（單表） 多表可以聯繫我，我也實現了

你還在爲前端傳一大堆條件查詢寫一大堆where條件嗎？你還在痛苦苦惱一個條件一個if標籤嗎？

<select id="fuzzyQuery" resultType="你的實體類Reference" parameterType="你的實體類Reference">
        SELECT * FROM sz_staff
        <trim prefix="WHERE" prefixOverrides="AND|OR">
            <if test='staff.userName!=null and staff.userName!=" "'>
                AND USER_NAME like CONCAT('%',#{staff.userName},'%')
            </if>
            <if test='staff.phone!=null and staff.phone!=" "'>
                AND PHONE like CONCAT('%',#{staff.phone},'%')
            </if>
            <if test='staff.belongFirm!=null and staff.belongFirm!=" "'>
                AND BELONG_FIRM like CONCAT('%',#{staff.belongFirm},'%')
            </if>
            <if test='staff.positionId!=null and staff.positionId!=" "'>
                AND POSITION_ID=#{staff.positionId}
            </if>
            <if test='staff.superLeader!=null and staff.superLeader!=" "'>
                AND SUPER_LEADER like CONCAT('%',#{staff.superLeader},'%')
            </if>
            <if test='staff.status!=null and staff.status!=" "'>
                AND STATUS=#{staff.status}
            </if>
            <if test='staff.isSupportPeople!=null and staff.isSupportPeople!=" "'>
                AND IS_SUPPORT_PEOPLE=#{staff.isSupportPeople}
            </if>
        </trim>
    </select>

你覺得這種代碼噁心嗎？

基於這種噁心的Page 代碼，我忍無可忍寫了一個工具，就是前端根據我們約定的規範動態傳入條件值來充當條件。

實際效果：

 

實際sql

        SELECT p_id,name,url,context,insurance,problem,serve,notice,details,status,create_time,update_time FROM web_produce WHERE (1 = '1' AND create_time = '2021-01-27 10:33:57') ORDER BY status DESC LIMIT 0,5

下面一步一步帶你寫出來。單表和多表皆可以，生產可用。

一：單表分頁

1.數據格式

/**
    條件格式，必須與前端約定好
*/
public interface ConstantType {

    String desc = "desc";
    String asc = "asc";

    public enum ParamType {
        /**
         * 條件查詢
         */
        filter_,

        /**
         * EQ // 等於
         * <p>
         * NE // 不等於
         * <p>
         * LIKE // 模糊查詢
         * <p>
         * NOTLIKE // 不模糊查詢
         * <p>
         * LIKESTART // 左側模糊查詢
         * <p>
         * LIKEEND // 右側模糊查詢
         * <p>
         * LT // 小於
         * <p>
         * GT // 大於
         * <p>
         * LE  // 小於等於
         * <p>
         * GE // 大於等於
         */
        EQ, NE, LIKE,NOTLIKE, LIKESTART, LIKEEND, LT, GT, LE, GE,
        /**
         * 根據某個字段排序，AES，DESC
         */
        orderBy, orderDir,
        /**
         * 當前頁，個數
         */
        page, size;

        public static ParamType getMsgByType(String type) {
            for (ParamType val : ParamType.values()) {
                if (val.toString().equals(type)) {
                    return val;
                }
            }
            return null;
        }

    }
}

 ParamType 就是一種格式約束

比如：

       

      這種就是 filter_ 是一種條件查詢， EQ 就是等於的意思，說白了就是 where後面的動態條件 where name = '3333'

      filter_LIKEEND_name 就是LIKEEND右模糊   where name like '3333%'

      多個filter 後面就是and

     暫時沒有多個or的形式，因爲涉及到or就比較複雜，所以不考慮or的情況。僅僅是and。

      so easy  !

  mybatis plus 分頁插件，不用不行啊

/**
 * 配置分頁插件
 */
@Configuration
@MapperScan("com.yfh.zhw.mapper.*.mapper*")
public class MybatisPlusConfig {

    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 設置請求的頁面大於最大頁後操作， true調回到首頁，false 繼續請求  默認false
        // paginationInterceptor.setOverflow(false);
        // 設置最大單頁限制數量，默認 500 條，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 開啓 count 的 join 優化,只針對部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }

}

2. 駝峯轉換 一個工具類

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 駝峯與下劃線轉換
 */
public class UnderlineToCamelUtil {

    public static final char UNDERLINE = '_';

    /**
     * 駝峯格式字符串轉換爲下劃線格式字符串
     *
     * @param param
     * @return
     */
    public static String camelToUnderline(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        //如果首字母爲大寫字母就不用轉換
        char indexChars = param.charAt(0);
        if (Character.isUpperCase(indexChars)){
            return param;
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append(UNDERLINE);
                sb.append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 下劃線格式字符串轉換爲駝峯格式字符串
     *
     * @param param
     * @return
     */
    public static String underlineToCamel(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (c == UNDERLINE) {
                if (++i < len) {
                    sb.append(Character.toUpperCase(param.charAt(i)));
                }
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 下劃線格式字符串轉換爲駝峯格式字符串2
     *
     * @param param
     * @return
     */
    public static String underlineToCamel2(String param) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        StringBuilder sb = new StringBuilder(param);
        Matcher mc = Pattern.compile("_").matcher(param);
        int i = 0;
        while (mc.find()) {
            int position = mc.end() - (i++);
            sb.replace(position - 1, position + 1, sb.substring(position, position + 1).toUpperCase());
        }
        return sb.toString();
    }

    public static void main(String[] args) {
//        String aaa = "app_version_fld";
//        System.out.println(underlineToCamel(aaa));
//        System.out.println(underlineToCamel2(aaa));
        String aaa = "tESTID";
        System.out.println(camelToUnderline(aaa));

    }
}

 

3.接受條件參數，一般的可以從controller中顯示接受參數，但是我不採用這種。

 

import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

/**
 * SpringMVC相關操作
    目的是獲取前端傳入的參數
 *
 * @author kong
 */
public class SpringMVCUtil {

    /**
     * 獲取當前會話的 request
     *
     * @return request
     */
    public static HttpServletRequest getRequest() {
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return servletRequestAttributes.getRequest();
    }

    /**
     * 獲取當前會話的 response
     *
     * @return response
     */
    public static HttpServletResponse getResponse() {
        // 大善人SpringMVC提供的封裝
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return servletRequestAttributes.getResponse();
    }

    /**
     * 根據KEY 獲取相應的值 全部從請求頭中獲取
     *
     * @param key          key名
     * @param isFilterflag 是否爲filter查詢  true是
     * @return map key-value 的數值
     */
    public static Map<String, Object> getRequestParam(String key, boolean isFilterflag) {
        HashMap<String, Object> paramsMap = Maps.newHashMap();

        HttpServletRequest request = getRequest();
        if (ObjectUtils.isEmpty(request)){
            return paramsMap;
        }
        //是否爲filter查詢
        if (!isFilterflag) {
            String parameter = request.getParameter(key);
            paramsMap.put(key, parameter);
            return paramsMap;
        }
        //遍歷集合數據取得從status開頭的數據
        Enumeration<String> paraNames = request.getParameterNames();
        for (Enumeration<String> e = paraNames; e.hasMoreElements(); ) {
            String thisName = e.nextElement();
            if (StringUtils.startsWith(thisName, key)) {
                paramsMap.put(thisName, request.getParameter(thisName));
            }
        }
        return paramsMap;
    }

    /**
     * 根據KEY 獲取相應的值 全部從請求頭中獲取
     *
     * @param key key名
     * @return String value 的數值
     */
    public static String getRequestParam(String key) {
        HttpServletRequest request = getRequest();
        if (ObjectUtils.isEmpty(request)){
            return "";
        }
        String parameter = request.getParameter(key);
        return parameter;
    }
}

4.新建一個類實現com.baomidou.mybatisplus.core.metadata.IPage接口， 我需要對裏面的page進行一些數據的初始化。QueryWrapper

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.yfh.zhw.enums.ConstantType;
import org.apache.commons.lang.StringUtils;
import org.springframework.util.ObjectUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.function.Predicate;

public class ZhwPage<T> implements IPage<T> {

    private static final long serialVersionUID = 1545996863226928798L;

    /**
     * 查詢數據列表
     */
    private List<T> records = Collections.emptyList();
    @JsonIgnore
    private QueryWrapper<T> queryWrapper;

    /**
     * 總數
     */
    private long total = 0;
    /**
     * 每頁顯示條數，默認 10
     */
    private long size = 10;

    /**
     * 當前頁
     */
    private long current = 1;

    /**
     * 排序字段信息
     */
    @JsonIgnore
    private List<OrderItem> orders = new ArrayList<>();

    /**
     * 自動優化 COUNT SQL
     */
    private boolean optimizeCountSql = true;
    /**
     * 是否進行 count 查詢
     */
    private boolean isSearchCount = true;


    /**
     * 分頁構造函數
     *
     * @param current 當前頁
     * @param size    每頁顯示條數
     */
    public ZhwPage(long current, long size) {
        this(current, size, 0);
    }

    /**
     * 分頁構造函數
     */
    public ZhwPage() {
        this(StringUtils.isNotEmpty(SpringMVCUtil.getRequestParam(ConstantType.ParamType.page.toString())) ? Long.valueOf(SpringMVCUtil.getRequestParam(ConstantType.ParamType.page.toString())) : 1,
                StringUtils.isNotEmpty(SpringMVCUtil.getRequestParam(ConstantType.ParamType.size.toString())) ? Long.valueOf(SpringMVCUtil.getRequestParam(ConstantType.ParamType.size.toString())) : 10,
                0);
        HttpServletRequest request = SpringMVCUtil.getRequest();
        if (ObjectUtils.isEmpty(request)){
            return; //則不需要條件查詢
        }
        Map<String, Object> requestParam = SpringMVCUtil.getRequestParam(ConstantType.ParamType.filter_.toString(), true);
        this.queryWrapper = parseWhereSql(requestParam);
    }

    public ZhwPage(long current, long size, long total) {
        this(current, size, total, true);
    }

    public ZhwPage(long current, long size, boolean isSearchCount) {
        this(current, size, 0, isSearchCount);
    }

    public ZhwPage(long current, long size, long total, boolean isSearchCount) {
        if (current > 1) {
            this.current = current;
        }
        this.size = size;
        this.total = total;
        this.isSearchCount = isSearchCount;
    }

    public QueryWrapper<T> getQueryWrapper() {
        return queryWrapper;
    }

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

    /**
     * 是否存在上一頁
     *
     * @return true / false
     */
    public boolean hasPrevious() {
        return this.current > 1;
    }

    /**
     * 是否存在下一頁
     *
     * @return true / false
     */
    public boolean hasNext() {
        return this.current < this.getPages();
    }

    @Override
    public List<T> getRecords() {
        return this.records;
    }

    @Override
    public ZhwPage<T> setRecords(List<T> records) {
        this.records = records;
        return this;
    }

    @Override
    public long getTotal() {
        return this.total;
    }

    @Override
    public ZhwPage<T> setTotal(long total) {
        this.total = total;
        return this;
    }

    @Override
    public long getSize() {
        return this.size;
    }

    @Override
    public ZhwPage<T> setSize(long size) {
        this.size = size;
        return this;
    }

    @Override
    public long getCurrent() {
        return this.current;
    }

    @Override
    public ZhwPage<T> setCurrent(long current) {
        this.current = current;
        return this;
    }

    /**
     * 獲取當前正序排列的字段集合
     * <p>
     * 爲了兼容，將在不久後廢棄
     *
     * @return 正序排列的字段集合
     * @see #getOrders()
     * @deprecated 3.2.0
     */
    @Override
    @Deprecated
    public String[] ascs() {
        return CollectionUtils.isNotEmpty(orders) ? mapOrderToArray(OrderItem::isAsc) : null;
    }

    /**
     * 查找 order 中正序排序的字段數組
     *
     * @param filter 過濾器
     * @return 返回正序排列的字段數組
     */
    private String[] mapOrderToArray(Predicate<OrderItem> filter) {
        List<String> columns = new ArrayList<>(orders.size());
        orders.forEach(i -> {
            if (filter.test(i)) {
                columns.add(i.getColumn());
            }
        });
        return columns.toArray(new String[0]);
    }

    /**
     * 移除符合條件的條件
     *
     * @param filter 條件判斷
     */
    private void removeOrder(Predicate<OrderItem> filter) {
        for (int i = orders.size() - 1; i >= 0; i--) {
            if (filter.test(orders.get(i))) {
                orders.remove(i);
            }
        }
    }

    /**
     * 添加新的排序條件，構造條件可以使用工廠：{@link OrderItem#build(String, boolean)}
     *
     * @param items 條件
     * @return 返回分頁參數本身
     */
    public ZhwPage<T> addOrder(OrderItem... items) {
        orders.addAll(Arrays.asList(items));
        return this;
    }

    /**
     * 添加新的排序條件，構造條件可以使用工廠：{@link OrderItem#build(String, boolean)}
     *
     * @param items 條件
     * @return 返回分頁參數本身
     */
    public ZhwPage<T> addOrder(List<OrderItem> items) {
        orders.addAll(items);
        return this;
    }

    /**
     * 設置需要進行正序排序的字段
     * <p>
     * Replaced:{@link #addOrder(OrderItem...)}
     *
     * @param ascs 字段
     * @return 返回自身
     * @deprecated 3.2.0
     */
    @Deprecated
    public ZhwPage<T> setAscs(List<String> ascs) {
        return CollectionUtils.isNotEmpty(ascs) ? setAsc(ascs.toArray(new String[0])) : this;
    }

    /**
     * 升序
     * <p>
     * Replaced:{@link #addOrder(OrderItem...)}
     *
     * @param ascs 多個升序字段
     * @deprecated 3.2.0
     */
    @Deprecated
    public ZhwPage<T> setAsc(String... ascs) {
        // 保證原來方法 set 的語意
        removeOrder(OrderItem::isAsc);
        for (String s : ascs) {
            addOrder(OrderItem.asc(s));
        }
        return this;
    }

    /**
     * 獲取需簡要倒序排列的字段數組
     * <p>
     *
     * @return 倒序排列的字段數組
     * @see #getOrders()
     * @deprecated 3.2.0
     */
    @Override
    @Deprecated
    public String[] descs() {
        return mapOrderToArray(i -> !i.isAsc());
    }

    /**
     * Replaced:{@link #addOrder(OrderItem...)}
     *
     * @param descs 需要倒序排列的字段
     * @return 自身
     * @deprecated 3.2.0
     */
    @Deprecated
    public ZhwPage<T> setDescs(List<String> descs) {
        // 保證原來方法 set 的語意
        if (CollectionUtils.isNotEmpty(descs)) {
            removeOrder(item -> !item.isAsc());
            for (String s : descs) {
                addOrder(OrderItem.desc(s));
            }
        }
        return this;
    }

    /**
     * 降序，這方法名不知道是誰起的
     * <p>
     * Replaced:{@link #addOrder(OrderItem...)}
     *
     * @param descs 多個降序字段
     * @deprecated 3.2.0
     */
    @Deprecated
    public ZhwPage<T> setDesc(String... descs) {
        setDescs(Arrays.asList(descs));
        return this;
    }

    @Override
    public List<OrderItem> orders() {
        return getOrders();
    }

    public List<OrderItem> getOrders() {
        return orders;
    }

    public void setOrders(List<OrderItem> orders) {
        this.orders = orders;
    }

    @Override
    public boolean optimizeCountSql() {
        return optimizeCountSql;
    }

    @Override
    public boolean isSearchCount() {
        if (total < 0) {
            return false;
        }
        return isSearchCount;
    }

    public ZhwPage<T> setSearchCount(boolean isSearchCount) {
        this.isSearchCount = isSearchCount;
        return this;
    }

    public ZhwPage<T> setOptimizeCountSql(boolean optimizeCountSql) {
        this.optimizeCountSql = optimizeCountSql;
        return this;
    }

    /**
     * 組裝條件sql  核心代碼
     * @param requestParam filter_參數集合
     * @return
     */
    public QueryWrapper<T> parseWhereSql(Map<String, Object> requestParam) {

        QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
        //因爲有where語句所以必須要有 1=1防止空where，導致orderBy失效
        queryWrapper.eq("1","1");

        //排序方式 true 是ASC ，false是desc
        String orderDir = SpringMVCUtil.getRequestParam(ConstantType.ParamType.orderDir.toString());
        //排序字段
        String orderBy = SpringMVCUtil.getRequestParam(ConstantType.ParamType.orderBy.toString());

        if (StringUtils.isNotBlank(orderBy) && StringUtils.isNotBlank(orderDir)){
            //駝峯格式字符串轉換爲下劃線格式字符串
            orderBy = UnderlineToCamelUtil.camelToUnderline(orderBy);
            if (StringUtils.equalsIgnoreCase(orderDir, ConstantType.asc)) {
                queryWrapper.orderByAsc(orderBy);
            } else {
                queryWrapper.orderByDesc(orderBy);
            }
        }

        if (!ObjectUtils.isEmpty(requestParam)) {
            Iterator iterator = requestParam.keySet().iterator();
            while (iterator.hasNext()) {

                //參數名 filter_LIKESTART_列名
                String paramName = iterator.next().toString();
                if (StringUtils.isBlank(paramName)){
                    return queryWrapper;
                }
                //key 列名
                String key = paramName.substring(paramName.lastIndexOf("_") + 1);
                //type 類型
                String type = paramName.substring(7, paramName.lastIndexOf("_"));
                if (StringUtils.isBlank(key) || StringUtils.isBlank(type)){
                    return queryWrapper;
                }
                //獲取ParamType
                ConstantType.ParamType paramType = ConstantType.ParamType.getMsgByType(type);
                //駝峯格式字符串轉換爲下劃線格式字符串
                key = UnderlineToCamelUtil.camelToUnderline(key);
                switch (Objects.requireNonNull(paramType)) {
                    case EQ:
                        queryWrapper.eq(key, requestParam.get(paramName));
                        break;
                    case NE:
                        queryWrapper.ne(key, requestParam.get(paramName));
                        break;
                    case LIKE:
                        queryWrapper.like(key, requestParam.get(paramName));
                        break;
                    case LIKESTART:
                        queryWrapper.likeLeft(key, requestParam.get(paramName));
                        break;
                    case LIKEEND:
                        queryWrapper.likeRight(key, requestParam.get(paramName));
                        break;
                    case NOTLIKE:
                        queryWrapper.notLike(key, requestParam.get(paramName));
                        break;
                    case GT:
                        queryWrapper.gt(key, requestParam.get(paramName));
                        break;
                    case LT:
                        queryWrapper.lt(key, requestParam.get(paramName));
                        break;
                    case LE:
                        queryWrapper.le(key, requestParam.get(paramName));
                        break;
                    case GE:
                        queryWrapper.ge(key, requestParam.get(paramName));
                        break;
                    default:
                        break;
                }
            }
        }

        return queryWrapper;
    }
}

5. 可以開始單表操作了

1)controller 實現

    @RequestMapping(value = "singlePage", method = RequestMethod.GET)
    @ApiOperation(value = "singlePage", httpMethod = "GET", response = ListVo.class,notes = "單表查詢")
    public WebResponse singlePage() {
        ZhwPage<User> userPage = new ZhwPage<User>();
        IPage<User> page = userService.singlePage(userPage);
        return DataResponse.success(page);
    }

2)service 和impl實現

public interface IUserService extends IService<User> {


    /**
     * 自定義分頁 單表查詢
     * @param userPage
     * @return
     */
    ZhwPage<User> singlePage(ZhwPage<User> userPage);
}

/**
 * <p>
 *  服務實現類
 * </p>
 *
 * @author cj
 * @since 2021-01-26
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Autowired
    private UserMapper userMapper;


    @Override
    public ZhwPage<User> singlePage(ZhwPage<User> userPage) {
        return userMapper.selectPage(userPage,userPage.getQueryWrapper());
    }
}

 到這就基本可以了

 但是還要注意一點，userMapper.xml文件必須要有 

3)UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yfh.zhw.mapper.UserMapper">

    <!-- 通用查詢映射結果 -->
    <resultMap id="BaseResultMap" type="com.yfh.zhw.entity.User">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <result column="sex" property="sex"/>
    </resultMap>

    <!-- 通用查詢結果列 -->
    <sql id="Base_Column_List">
        id, name, age, sex
    </sql>


</mapper>

4）效果一

因爲這個查詢出來沒有數據，所以mybatis plus 就沒有分頁了。

4）效果二

這個就算是比較完整的功能就算是實現了。

 

到此就可以實現效果了，管你前端傳什麼條件，我自巍然不動，奈我何！！！

轉載，請著名原作！請勿抄襲。我花了1天的時間寫出來的。