2. 程式人生 > >mybatis plus 查詢方法

mybatis plus 查詢方法

阿新 • • 發佈：2018-11-15

根據主鍵查詢

UserEntity userEntity = ud.selectById(id);

根據實體查詢

UserEntity u = new UserEntity();
        u.setEmail("[email protected]");
        UserEntity u1 = ud.selectOne(u);

這個就比較常用了，根據實體屬性查詢，在junit單元測試，呼叫dao，只能通過實體，如果是通過service，有個也可以使用，當然實體也同樣適用，在service中我經常用這個，

    EntityWrapper<UserEntity> wrapper = new EntityWrapper<UserEntity>();
    wrapper.eq("email", "
 
[email protected]");
    UserEntity u2 = userService.selectOne(wrapper);

EntityWrapper是個很強大的玩意，支援多條件查詢，例如下面:

wrapper.between(column, val1, val2)
        wrapper.groupBy(columns)  //對應sql中分組
        wrapper.eq(column, params) //相當於where條件
        wrapper.in(column, value) //sql中in
        wrapper.notIn(column, value
 
) //sql中 not in
        wrapper.orderBy(columns, isAsc) //排序
        wrapper.exists(value) //相對於sql中exists查詢
        wrapper.notExists(value) //相當於sql中not exists查詢
        wrapper.notBetween(column, val1, val2) //相當於sql中在某個範圍內使用的between
        wrapper.ge(column, params) //大於等於
        wrapper.le(column, params
 
) //小於等於
        wrapper.like(column, value) //模糊查詢
        wrapper.having(sqlHaving, params) //條件過濾

當然還有很多，其中wrapper有一個叫wrapper.setSqlSelect(column)的方法，這個方法主要用於sql優化，指定你需要的查詢欄位。

            List<UserEntity> list = ud.selectByMap(columnMap) //通過map查詢 適用場景是分頁查詢
            List<UserEntity> list2 = ud.selectList(wrapper); //如果為Null，預設查詢所有
            List<UserEntity> list3 = ud.selectCount(wrapper) //通過EntityWrapper根據某個欄位獲取總數
            List<UserEntity> list4 = ud.selectMaps(wrapper) //EntityWrapper查詢
            List<UserEntity> list5 = ud.selectPage(rowBounds, wrapper) //rowBounds裡面封裝了起止和長度，wrapper具體條件

複製程式碼

上面引數中例如columnMap是通過HashMap或者Map使欄位以鍵值對的形式存在，然後進行查詢

分頁查詢更是簡單，因為RowBounds基本封裝好了索引和長度,wrapper就是前面提到的EntityWrapper

下面再貼貼EntityWrapper的原始碼:
複製程式碼


/**
 * Copyright (c) 2011-2014, hubin (jobob@qq.com).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.baomidou.mybatisplus.mapper;

import com.baomidou.mybatisplus.toolkit.StringUtils;

/**
 * <p>
 * Entity 物件封裝操作類，定義T-SQL語法
 * </p>
 *
 * @author hubin , yanghu , Dyang , Caratacus
 * @Date 2016-11-7
 */
@SuppressWarnings("serial")
public class EntityWrapper<T> extends Wrapper<T> {

    /**
     * 資料庫表對映實體類
     */
    protected T entity = null;

    public EntityWrapper() {
        /* 注意，傳入查詢引數 */
    }

    public EntityWrapper(T entity) {
        this.entity = entity;
    }

    public EntityWrapper(T entity, String sqlSelect) {
        this.entity = entity;
        this.sqlSelect = sqlSelect;
    }

    @Override
    public T getEntity() {
        return entity;
    }

    public void setEntity(T entity) {
        this.entity = entity;
    }

    /**
     * SQL 片段
     */
    @Override
    public String getSqlSegment() {
        /*
         * 無條件
         */
        String sqlWhere = sql.toString();
        if (StringUtils.isEmpty(sqlWhere)) {
            return null;
        }

        /*
         * 根據當前實體判斷是否需要將WHERE替換成 AND 增加實體不為空但所有屬性為空的情況
         */
        return isWhere != null ? (isWhere ? sqlWhere : sqlWhere.replaceFirst("WHERE", AND_OR)) : sqlWhere.replaceFirst("WHERE", AND_OR);
    }

}

Wrapper原始碼:
複製程式碼

/**
* Copyright (c) 2011-2014, hubin ([email protected]).
*


* Licensed under the Apache License, Version 2.0 (the “License”); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*


* http://www.apache.org/licenses/LICENSE-2.0
*


* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an “AS IS” BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.baomidou.mybatisplus.mapper;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import com.baomidou.mybatisplus.entity.Column;
import com.baomidou.mybatisplus.entity.Columns;
import com.baomidou.mybatisplus.enums.SqlLike;
import com.baomidou.mybatisplus.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.toolkit.MapUtils;
import com.baomidou.mybatisplus.toolkit.SqlUtils;
import com.baomidou.mybatisplus.toolkit.StringUtils;

/**
*


* 條件構造抽象類，定義T-SQL語法
*


*
* @author hubin , yanghu , Dyang , Caratacus
* @Date 2016-11-7
*/
@SuppressWarnings(“serial”)
public abstract class Wrapper implements Serializable { 
/**
 * 佔位符
 */
private static final String PLACE_HOLDER = "{%s}";

private static final String MYBATIS_PLUS_TOKEN = "#{%s.paramNameValuePairs.%s}";

private static final String MP_GENERAL_PARAMNAME = "MPGENVAL";

private static final String DEFAULT_PARAM_ALIAS = "ew";
/**
 * 實現了TSQL語法的SQL實體
 */
protected final SqlPlus sql = new SqlPlus();
private final Map<String, Object> paramNameValuePairs = new HashMap<>();
private final AtomicInteger paramNameSeq = new AtomicInteger(0);
protected String paramAlias = null;
/**
 * SQL 查詢欄位內容，例如：id,name,age
 */
protected String sqlSelect = null;
/**
 * 自定義是否輸出sql為 WHERE OR AND OR OR
 */
protected Boolean isWhere;
/**
 * 拼接WHERE後應該是AND還是ORnull
 */
protected String AND_OR = "AND";

/**
 * <p>
 * 相容EntityWrapper
 * </p>
 *
 * @return
 */
public T getEntity() {
    return null;
}

/**
 * 檢視where構造是否為空
 *
 * @return
 */
public boolean isEmptyOfWhere() {
    return sql.isEmptyOfWhere();
}

/**
 * 檢視where構造是否不為空
 *
 * @return
 */
public boolean isNotEmptyOfWhere() {
    return !isEmptyOfWhere();
}

public String getSqlSelect() {
    return StringUtils.isEmpty(sqlSelect) ? null : stripSqlInjection(sqlSelect);
}

public Wrapper<T> setSqlSelect(String sqlSelect) {
    if (StringUtils.isNotEmpty(sqlSelect)) {
        this.sqlSelect = sqlSelect;
    }
    return this;
}

/**
 * <p>
 * 使用字串陣列封裝sqlSelect，便於在不需要指定 AS 的情況下通過實體類自動生成的列靜態欄位快速組裝 sqlSelect，<br/>
 * 減少手動錄入的錯誤率
 * </p>
 *
 * @param columns 欄位
 * @return
 */
public Wrapper<T> setSqlSelect(String... columns) {
    StringBuilder builder = new StringBuilder();
    for (String column : columns) {
        if (StringUtils.isNotEmpty(column)) {
            if (builder.length() > 0) {
                builder.append(",");
            }
            builder.append(column);
        }
    }
    this.sqlSelect = builder.toString();
    return this;
}

/**
 * <p>
 * 使用物件封裝的setsqlselect
 * </p>
 *
 * @param column 欄位
 * @return
 */
public Wrapper<T> setSqlSelect(Column... column) {
    if (ArrayUtils.isNotEmpty(column)) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < column.length; i++) {
            if (column[i] != null) {
                String col = column[i].getColumn();
                String as = column[i].getAs();
                if (StringUtils.isEmpty(col)) {
                    continue;
                }
                builder.append(col).append(as);
                if (i < column.length - 1) {
                    builder.append(",");
                }
            }
        }
        this.sqlSelect = builder.toString();
    }
    return this;
}

/**
 * <p>
 * 使用物件封裝的setsqlselect
 * </p>
 *
 * @param columns 欄位
 * @return
 */
public Wrapper<T> setSqlSelect(Columns columns) {
    Column[] columnArray = columns.getColumns();
    if (ArrayUtils.isNotEmpty(columnArray)) {
        setSqlSelect(columnArray);
    }
    return this;
}

/**
 * <p>
 * SQL 片段 (子類實現)
 * </p>
 */
public abstract String getSqlSegment();

@Override
public String toString() {
    StringBuilder sb = new StringBuilder("Wrapper<T>:");
    String sqlSegment = getSqlSegment();
    sb.append(replacePlaceholder(sqlSegment));
    Object entity = getEntity();
    if (entity != null) {
        sb.append("\n");
        sb.append("entity=").append(entity.toString());
    }
    return sb.toString();
}

/**
 * <p>
 * 替換佔位符
 * </p>
 *
 * @param sqlSegment
 * @return
 */
private String replacePlaceholder(String sqlSegment) {
    if (StringUtils.isEmpty(sqlSegment)) {
        return StringUtils.EMPTY;
    }
    return sqlSegment.replaceAll("#\\{" + getParamAlias() + ".paramNameValuePairs.MPGENVAL[0-9]+}", "\\?");
}

/**
 * <p>
 * 原生佔位符sql
 * </p>
 *
 * @return
 */
public String originalSql() {
    return replacePlaceholder(getSqlSegment());
}

/**
 * <p>
 * SQL中WHERE關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").where(id!=null, "id={0}", id);
 * <p>
 * 輸出:<br>
 * 如果id=123:  WHERE (NAME='zhangsan' AND id=123)<br>
 * 如果id=null: WHERE (NAME='zhangsan')
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlWhere  where語句
 * @param params    引數集
 * @return this
 */
public Wrapper<T> where(boolean condition, String sqlWhere, Object... params) {
    if (condition) {
        sql.WHERE(formatSql(sqlWhere, params));
    }
    return this;
}

/**
 * <p>
 * SQL中WHERE關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").where("id={0}","123");
 * <p>
 * 輸出: WHERE (NAME='zhangsan' AND id=123)
 * </p>
 *
 * @param sqlWhere where語句
 * @param params   引數集
 * @return this
 */
public Wrapper<T> where(String sqlWhere, Object... params) {
    return where(true, sqlWhere, params);
}

/**
 * <p>
 * 等同於SQL的"field=value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> eq(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s = {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field=value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> eq(String column, Object params) {
    return eq(true, column, params);
}

/**
 * <p>
 * 等同於SQL的"field <> value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> ne(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s <> {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field <> value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> ne(String column, Object params) {
    return ne(true, column, params);

}

/**
 * <p>
 * 等同於SQL的"field=value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param params
 * @return
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public Wrapper<T> allEq(boolean condition, Map<String, Object> params) {
    if (condition && MapUtils.isNotEmpty(params)) {
        Iterator iterator = params.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iterator.next();
            Object value = entry.getValue();
            if (StringUtils.checkValNotNull(value)) {
                sql.WHERE(formatSql(String.format("%s = {0}", entry.getKey()), entry.getValue()));
            }

        }

    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field=value"表示式
 * </p>
 *
 * @param params
 * @return
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public Wrapper<T> allEq(Map<String, Object> params) {
    return allEq(true, params);
}

/**
 * <p>
 * 等同於SQL的"field>value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> gt(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s > {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field>value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> gt(String column, Object params) {
    return gt(true, column, params);
}

/**
 * <p>
 * 等同於SQL的"field>=value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> ge(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s >= {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field>=value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> ge(String column, Object params) {
    return ge(true, column, params);
}

/**
 * <p>
 * 等同於SQL的"field<value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> lt(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s < {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field<value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> lt(String column, Object params) {
    return lt(true, column, params);
}

/**
 * <p>
 * 等同於SQL的"field<=value"表示式
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> le(boolean condition, String column, Object params) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s <= {0}", column), params));
    }
    return this;
}

/**
 * <p>
 * 等同於SQL的"field<=value"表示式
 * </p>
 *
 * @param column
 * @param params
 * @return
 */
public Wrapper<T> le(String column, Object params) {
    return le(true, column, params);
}

/**
 * <p>
 * AND 連線後續條件
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlAnd    and條件語句
 * @param params    引數集
 * @return this
 */
public Wrapper<T> and(boolean condition, String sqlAnd, Object... params) {
    if (condition) {
        sql.AND().WHERE(formatSql(sqlAnd, params));
    }
    return this;
}

/**
 * <p>
 * AND 連線後續條件
 * </p>
 *
 * @param sqlAnd and條件語句
 * @param params 引數集
 * @return this
 */
public Wrapper<T> and(String sqlAnd, Object... params) {
    return and(true, sqlAnd, params);
}

/**
 * <p>
 * 使用AND連線並換行
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) AND (statu=1)
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlAnd    AND 條件語句
 * @param params    引數值
 * @return this
 */
public Wrapper<T> andNew(boolean condition, String sqlAnd, Object... params) {
    if (condition) {
        sql.AND_NEW().WHERE(formatSql(sqlAnd, params));
    }
    return this;
}

/**
 * <p>
 * 使用AND連線並換行
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) AND (statu=1)
 * </p>
 *
 * @return this
 */
public Wrapper<T> andNew() {
    sql.AND_NEW();
    return this;
}

/**
 * <p>
 * 使用AND連線並換行
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) AND (statu=1)
 * </p>
 *
 * @param sqlAnd AND 條件語句
 * @param params 引數值
 * @return this
 */
public Wrapper<T> andNew(String sqlAnd, Object... params) {
    return andNew(true, sqlAnd, params);
}

/**
 * <p>
 * 使用AND連線並換行
 * </p>
 * <p>
 *
 * @return this
 */
public Wrapper<T> and() {
    sql.AND();
    return this;
}

/**
 * <p>
 * 使用OR連線並換行
 * </p>
 *
 * @return this
 */
public Wrapper<T> or() {
    sql.OR();
    return this;
}

/**
 * <p>
 * 新增OR條件
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlOr     or 條件語句
 * @param params    引數集
 * @return this
 */
public Wrapper<T> or(boolean condition, String sqlOr, Object... params) {
    if (condition) {
        if (StringUtils.isEmpty(sql.toString())) {
            AND_OR = "OR";
        }
        sql.OR().WHERE(formatSql(sqlOr, params));
    }
    return this;
}

/**
 * <p>
 * 新增OR條件
 * </p>
 *
 * @param sqlOr  or 條件語句
 * @param params 引數集
 * @return this
 */
public Wrapper<T> or(String sqlOr, Object... params) {
    return or(true, sqlOr, params);
}

/**
 * <p>
 * 使用OR換行，並新增一個帶()的新的條件
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) OR (statu=1)
 * </p>
 *
 * @return this
 */
public Wrapper<T> orNew() {
    sql.OR_NEW();
    return this;
}

/**
 * <p>
 * 使用OR換行，並新增一個帶()的新的條件
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) OR (statu=1)
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlOr     AND 條件語句
 * @param params    引數值
 * @return this
 */
public Wrapper<T> orNew(boolean condition, String sqlOr, Object... params) {
    if (condition) {
        if (StringUtils.isEmpty(sql.toString())) {
            AND_OR = "OR";
        }
        sql.OR_NEW().WHERE(formatSql(sqlOr, params));
    }
    return this;
}

/**
 * <p>
 * 使用OR換行，並新增一個帶()的新的條件
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 輸出： WHERE
 * (name='zhangsan' AND id=11) OR (statu=1)
 * </p>
 *
 * @param sqlOr  AND 條件語句
 * @param params 引數值
 * @return this
 */
public Wrapper<T> orNew(String sqlOr, Object... params) {
    return orNew(true, sqlOr, params);
}

/**
 * <p>
 * SQL中groupBy關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").groupBy("id,name")
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   SQL 中的 Group by 語句，無需輸入 Group By 關鍵字
 * @return this
 */
public Wrapper<T> groupBy(boolean condition, String columns) {
    if (condition) {
        sql.GROUP_BY(columns);
    }
    return this;
}

/**
 * <p>
 * SQL中groupBy關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.where("name='zhangsan'").groupBy("id,name")
 * </p>
 *
 * @param columns SQL 中的 Group by 語句，無需輸入 Group By 關鍵字
 * @return this
 */
public Wrapper<T> groupBy(String columns) {
    return groupBy(true, columns);
}

/**
 * <p>
 * SQL中having關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param sqlHaving having關鍵字後面跟隨的語句
 * @param params    引數集
 * @return EntityWrapper<T>
 */
public Wrapper<T> having(boolean condition, String sqlHaving, Object... params) {
    if (condition) {
        sql.HAVING(formatSql(sqlHaving, params));
    }
    return this;
}

/**
 * <p>
 * SQL中having關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null")
 * </p>
 *
 * @param sqlHaving having關鍵字後面跟隨的語句
 * @param params    引數集
 * @return EntityWrapper<T>
 */
public Wrapper<T> having(String sqlHaving, Object... params) {
    return having(true, sqlHaving, params);
}

/**
 * <p>
 * SQL中orderby關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null"
 * ).orderBy("id,name")
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   SQL 中的 order by 語句，無需輸入 Order By 關鍵字
 * @return this
 */
public Wrapper<T> orderBy(boolean condition, String columns) {
    if (condition) {
        sql.ORDER_BY(columns);
    }
    return this;
}

/**
 * <p>
 * SQL中orderby關鍵字跟的條件語句
 * </p>
 * <p>
 * eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null"
 * ).orderBy("id,name")
 * </p>
 *
 * @param columns SQL 中的 order by 語句，無需輸入 Order By 關鍵字
 * @return this
 */
public Wrapper<T> orderBy(String columns) {
    return orderBy(true, columns);
}

/**
 * <p>
 * SQL中orderby關鍵字跟的條件語句，可根據變更動態排序
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   SQL 中的 order by 語句，無需輸入 Order By 關鍵字
 * @param isAsc     是否為升序
 * @return this
 */
public Wrapper<T> orderBy(boolean condition, String columns, boolean isAsc) {
    if (condition && StringUtils.isNotEmpty(columns)) {
        sql.ORDER_BY(columns + (isAsc ? " ASC" : " DESC"));
    }
    return this;
}

/**
 * <p>
 * SQL中orderby關鍵字跟的條件語句，可根據變更動態排序
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   SQL 中的 order by 語句，無需輸入 Order By 關鍵字
 * @param isAsc     是否為升序
 * @return this
 */
public Wrapper<T> orderBy(boolean condition, Collection<String> columns, boolean isAsc) {
    if (condition && CollectionUtils.isNotEmpty(columns)) {
        for (String column : columns) {
            orderBy(condition, column, isAsc);
        }
    }
    return this;
}

/**
 * <p>
 * SQL中orderby關鍵字跟的條件語句，可根據變更動態排序
 * </p>
 *
 * @param columns SQL 中的 order by 語句，無需輸入 Order By 關鍵字
 * @param isAsc   是否為升序
 * @return this
 */
public Wrapper<T> orderBy(String columns, boolean isAsc) {
    return orderBy(true, columns, isAsc);
}

/**
 * <p>
 * 批量根據ASC排序
 * </p>
 *
 * @param columns 需要排序的集合
 * @return this
 */
public Wrapper<T> orderAsc(Collection<String> columns) {
    return orderBy(true, columns, true);
}

/**
 * <p>
 * 批量根據DESC排序
 * </p>
 *
 * @param columns 需要排序的集合
 * @return this
 */
public Wrapper<T> orderDesc(Collection<String> columns) {
    return orderBy(true, columns, false);
}

/**
 * <p>
 * LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值
 * @return this
 */
public Wrapper<T> like(boolean condition, String column, String value) {
    if (condition) {
        handerLike(column, value, SqlLike.DEFAULT, false);
    }
    return this;
}

/**
 * <p>
 * LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值
 * @return this
 */
public Wrapper<T> like(String column, String value) {
    return like(true, column, value);
}

/**
 * <p>
 * NOT LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值
 * @return this
 */
public Wrapper<T> notLike(boolean condition, String column, String value) {
    if (condition) {
        handerLike(column, value, SqlLike.DEFAULT, true);
    }
    return this;
}

/**
 * <p>
 * NOT LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值
 * @return this
 */
public Wrapper<T> notLike(String column, String value) {
    return notLike(true, column, value);
}

/**
 * <p>
 * 處理LIKE操作
 * </p>
 *
 * @param column 欄位名稱
 * @param value  like匹配值
 * @param isNot  是否為NOT LIKE操作
 */
private void handerLike(String column, String value, SqlLike type, boolean isNot) {
    if (StringUtils.isNotEmpty(column) && StringUtils.isNotEmpty(value)) {
        StringBuilder inSql = new StringBuilder();
        inSql.append(column);
        if (isNot) {
            inSql.append(" NOT");
        }
        inSql.append(" LIKE {0}");
        sql.WHERE(formatSql(inSql.toString(), SqlUtils.concatLike(value, type)));
    }
}

/**
 * <p>
 * LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值
 * @param type
 * @return this
 */
public Wrapper<T> like(boolean condition, String column, String value, SqlLike type) {
    if (condition) {
        handerLike(column, value, type, false);
    }
    return this;
}

/**
 * <p>
 * LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值
 * @param type
 * @return this
 */
public Wrapper<T> like(String column, String value, SqlLike type) {
    return like(true, column, value, type);
}

/**
 * <p>
 * NOT LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值
 * @param type
 * @return this
 */
public Wrapper<T> notLike(boolean condition, String column, String value, SqlLike type) {
    if (condition) {
        handerLike(column, value, type, true);
    }
    return this;
}

/**
 * <p>
 * NOT LIKE條件語句，value中無需前後%
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值
 * @param type
 * @return this
 */
public Wrapper<T> notLike(String column, String value, SqlLike type) {
    return notLike(true, column, value, type);
}

/**
 * <p>
 * is not null 條件
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   欄位名稱。多個欄位以逗號分隔。
 * @return this
 */
public Wrapper<T> isNotNull(boolean condition, String columns) {
    if (condition) {
        sql.IS_NOT_NULL(columns);
    }
    return this;
}

/**
 * <p>
 * is not null 條件
 * </p>
 *
 * @param columns 欄位名稱。多個欄位以逗號分隔。
 * @return this
 */
public Wrapper<T> isNotNull(String columns) {
    return isNotNull(true, columns);
}

/**
 * <p>
 * is null 條件
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param columns   欄位名稱。多個欄位以逗號分隔。
 * @return this
 */
public Wrapper<T> isNull(boolean condition, String columns) {
    if (condition) {
        sql.IS_NULL(columns);
    }
    return this;
}

/**
 * <p>
 * is null 條件
 * </p>
 *
 * @param columns 欄位名稱。多個欄位以逗號分隔。
 * @return this
 */
public Wrapper<T> isNull(String columns) {
    return isNull(true, columns);
}

/**
 * <p>
 * EXISTS 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param value     匹配值
 * @return this
 */
public Wrapper<T> exists(boolean condition, String value) {
    if (condition) {
        sql.EXISTS(value);
    }
    return this;
}

/**
 * <p>
 * EXISTS 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param value 匹配值
 * @return this
 */
public Wrapper<T> exists(String value) {
    return exists(true, value);
}

/**
 * <p>
 * NOT EXISTS條件語句
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param value     匹配值
 * @return this
 */
public Wrapper<T> notExists(boolean condition, String value) {
    if (condition) {
        sql.NOT_EXISTS(value);
    }
    return this;
}

/**
 * <p>
 * NOT EXISTS條件語句
 * </p>
 *
 * @param value 匹配值
 * @return this
 */
public Wrapper<T> notExists(String value) {
    return notExists(true, value);
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     逗號拼接的字串
 * @return this
 */
public Wrapper<T> in(boolean condition, String column, String value) {
    if (condition && StringUtils.isNotEmpty(value)) {
        in(column, StringUtils.splitWorker(value, ",", -1, false));
    }
    return this;
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param column 欄位名稱
 * @param value  逗號拼接的字串
 * @return this
 */
public Wrapper<T> in(String column, String value) {
    return in(true, column, value);
}

/**
 * <p>
 * NOT IN條件語句
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     逗號拼接的字串
 * @return this
 */
public Wrapper<T> notIn(boolean condition, String column, String value) {
    if (condition && StringUtils.isNotEmpty(value)) {
        notIn(column, StringUtils.splitWorker(value, ",", -1, false));
    }
    return this;
}

/**
 * <p>
 * NOT IN條件語句
 * </p>
 *
 * @param column 欄位名稱
 * @param value  逗號拼接的字串
 * @return this
 */
public Wrapper<T> notIn(String column, String value) {
    return notIn(true, column, value);
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值 集合
 * @return this
 */
public Wrapper<T> in(boolean condition, String column, Collection<?> value) {
    if (condition && CollectionUtils.isNotEmpty(value)) {
        sql.WHERE(formatSql(inExpression(column, value, false), value.toArray()));
    }
    return this;
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值 集合
 * @return this
 */
public Wrapper<T> in(String column, Collection<?> value) {
    return in(true, column, value);
}

/**
 * <p>
 * NOT IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值 集合
 * @return this
 */
public Wrapper<T> notIn(boolean condition, String column, Collection<?> value) {
    if (condition && CollectionUtils.isNotEmpty(value)) {
        sql.WHERE(formatSql(inExpression(column, value, true), value.toArray()));
    }
    return this;
}

/**
 * <p>
 * NOT IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值 集合
 * @return this
 */
public Wrapper<T> notIn(String column, Collection<?> value) {
    return notIn(true, column, value);
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值 object陣列
 * @return this
 */
public Wrapper<T> in(boolean condition, String column, Object[] value) {
    if (condition && ArrayUtils.isNotEmpty(value)) {
        sql.WHERE(formatSql(inExpression(column, Arrays.asList(value), false), value));
    }
    return this;
}

/**
 * <p>
 * IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值 object陣列
 * @return this
 */
public Wrapper<T> in(String column, Object[] value) {
    return in(true, column, value);
}

/**
 * <p>
 * NOT IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param value     匹配值 object陣列
 * @return this
 */
public Wrapper<T> notIn(boolean condition, String column, Object... value) {
    if (condition && ArrayUtils.isNotEmpty(value)) {
        sql.WHERE(formatSql(inExpression(column, Arrays.asList(value), true), value));
    }
    return this;
}

/**
 * <p>
 * NOT IN 條件語句，目前適配mysql及oracle
 * </p>
 *
 * @param column 欄位名稱
 * @param value  匹配值 object陣列
 * @return this
 */
public Wrapper<T> notIn(String column, Object... value) {
    return notIn(true, column, value);
}

/**
 * <p>
 * 獲取in表示式
 * </p>
 *
 * @param column 欄位名稱
 * @param value  集合
 * @param isNot  是否為NOT IN操作
 */
private String inExpression(String column, Collection<?> value, boolean isNot) {
    if (StringUtils.isNotEmpty(column) && CollectionUtils.isNotEmpty(value)) {
        StringBuilder inSql = new StringBuilder();
        inSql.append(column);
        if (isNot) {
            inSql.append(" NOT");
        }
        inSql.append(" IN ");
        inSql.append("(");
        int size = value.size();
        for (int i = 0; i < size; i++) {
            inSql.append(String.format(PLACE_HOLDER, i));
            if (i + 1 < size) {
                inSql.append(",");
            }
        }
        inSql.append(")");
        return inSql.toString();
    }
    return null;
}

/**
 * <p>
 * betwwee 條件語句
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param val1
 * @param val2
 * @return this
 */
public Wrapper<T> between(boolean condition, String column, Object val1, Object val2) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s BETWEEN {0} AND {1}", column), val1, val2));
    }
    return this;
}

/**
 * <p>
 * betwwee 條件語句
 * </p>
 *
 * @param column 欄位名稱
 * @param val1
 * @param val2
 * @return this
 */
public Wrapper<T> between(String column, Object val1, Object val2) {
    return between(true, column, val1, val2);
}

/**
 * <p>
 * NOT betwwee 條件語句
 * </p>
 *
 * @param condition 拼接的前置條件
 * @param column    欄位名稱
 * @param val1
 * @param val2
 * @return this
 */
public Wrapper<T> notBetween(boolean condition, String column, Object val1, Object val2) {
    if (condition) {
        sql.WHERE(formatSql(String.format("%s NOT BETWEEN {0} AND {1}", column), val1, val2));
    }
    return this;
}

/**
 * <p>
 * NOT betwwee 條件語句
 * </p>
 *
 * @param column 欄位名稱
 * @param val1
 * @param val2
 * @return this
 */
public Wrapper<T> notBetween(String column, Object val1, Object val2) {
    return notBetween(true, column, val1, val2);

}

/**
 * <p>
 * 為了相容之前的版本,可使用where()或and()替代
 * </p>
 *
 * @param sqlWhere where sql部分
 * @param params   引數集
 * @return this
 */
public Wrapper<T> addFilter(String sqlWhere, Object... params) {
    return and(sqlWhere, params);
}

/**
 * <p>
 * 根據判斷條件來新增條件語句部分 使用 andIf() 替代
 * </p>
 * <p>
 * eg: ew.filterIfNeed(false,"name='zhangsan'").where("name='zhangsan'")
 * .filterIfNeed(true,"id={0}",22)
 * <p>
 * 輸出: WHERE (name='zhangsan' AND id=22)
 * </p>
 *
 * @param need     是否需要新增該條件
 * @param sqlWhere 條件語句
 * @param params   引數集
 * @return this
 */
public Wrapper<T> addFilterIfNeed(boolean need, String sqlWhere, Object... params) {
    return need ? where(sqlWhere, params) : this;
}

/**
 * <p>
 * SQL注入內容剝離
 * </p>
 *
 * @param value 待處理內容
 * @return this
 */
protected String stripSqlInjection(String value) {
    return value.replaceAll("('.+--)|(--)|(\|)|(%7C)", "");
}

/**
 * <p>
 * 格式化SQL
 * </p>
 *
 * @param sqlStr SQL語句部分
 * @param params 引數集
 * @return this
 */
protected String formatSql(String sqlStr, Object... params) {
    return formatSqlIfNeed(true, sqlStr, params);
}

/**
 * <p>
 * 根據需要格式化SQL<BR>
 * <BR>
 * Format SQL for methods: EntityWrapper<T>.where/and/or...("name={0}", value);
 * ALL the {<b>i</b>} will be replaced with #{MPGENVAL<b>i</b>}<BR>
 * <BR>
 * ew.where("sample_name=<b>{0}</b>", "haha").and("sample_age &gt;<b>{0}</b>
 * and sample_age&lt;<b>{1}</b>", 18, 30) <b>TO</b>
 * sample_name=<b>#{MPGENVAL1}</b> and sample_age&gt;#<b>{MPGENVAL2}</b> and
 * sample_age&lt;<b>#{MPGENVAL3}</b><BR>
 * </p>
 *
 * @param need   是否需要格式化
 * @param sqlStr SQL語句部分
 * @param params 引數集
 * @return this
 */
protected String formatSqlIfNeed(boolean need, String sqlStr, Object... params) {
    if (!need || StringUtils.isEmpty(sqlStr)) {
        return null;
    }
    // #200
    if (ArrayUtils.isNotEmpty(params)) {
        for (int i = 0; i < params.length; ++i) {
            String genParamName = MP_GENERAL_PARAMNAME + paramNameSeq.incrementAndGet();
            sqlStr = sqlStr.replace(String.format(PLACE_HOLDER, i),
                    String.format(MYBATIS_PLUS_TOKEN, getParamAlias(), genParamName));
            paramNameValuePairs.put(genParamName, params[i]);
        }
    }
    return sqlStr;
}

/**
 * <p>
 * 自定義是否輸出sql開頭為 `WHERE` OR `AND` OR `OR`
 * </p>
 *
 * @param bool
 * @return this
 */
public Wrapper<T> isWhere(Boolean bool) {
    this.isWhere = bool;
    return this;
}

/**
 * <p>
 * 手動把sql拼接到最後(有sql注入的風險,請謹慎使用)
 * </p>
 *
 * @param limit
 * @return this
 */
public Wrapper<T> last(String limit) {
    sql.LAST(limit);
    return this;
}

/**
 * Fix issue 200.
 *
 * @return
 * @since 2.0.3
 */
public Map<String, Object> getParamNameValuePairs() {
    return paramNameValuePairs;
}

public String getParamAlias() {
    return StringUtils.isEmpty(paramAlias) ? DEFAULT_PARAM_ALIAS : paramAlias;
}

/**
 * <p>
 * 引數別名設定，初始化時優先設定該值、重複設定異常
 * </p>
 *
 * @param paramAlias 引數別名
 * @return
 */
public Wrapper<T> setParamAlias(String paramAlias) {
    if (StringUtils.isNotEmpty(getSqlSegment())) {
        throw new MybatisPlusException("Error: Please call this method when initializing!");
    }
    if (StringUtils.isNotEmpty(this.paramAlias)) {
        throw new MybatisPlusException("Error: Please do not call the method repeatedly!");
    }
    this.paramAlias = paramAlias;
    return this;
}

}

複製程式碼

通過看原始碼更好的瞭解它

接下來再提提增刪改:
複製程式碼

     ud.insert(entity)  //應用場景是指定你需要的實體增加到對應的表中
     ud.delete(wrapper) //通過EntityWrapper指定欄位刪除資料
     ud.deleteById(id)  //主鍵刪除
     ud.deleteByMap(columnMap) //通過map刪除
     ud.deleteBatchIds(idList) //批量刪除
     ud.insertAllColumn(entity) //預設插入該實體所有欄位
     ud.insertUserEntity(map) //通過map新增資料
     ud.update(entity, wrapper) //通過EntityWrapper更新實體
     ud.updateAllColumnById(entity) //更新所有實體,通過主鍵更新
     ud.updateById(entity) //更新指定實體,通過主鍵更新
     ud.updateUserMap(map) //通過map更新

複製程式碼

如果是在DAO中

例如:

UserEntity u = new UserEntity();
u.setName(“test”)
int lines = ud.insertEntity(u);

後面的用法諸如上述這樣的，如果是map就要以map的形式

通過這篇博文，可以讓你明白這些方法的應用場景

相關推薦

mybatis plus 查詢方法

根據主鍵查詢 UserEntity userEntity = ud.selectById(id); 根據實體查詢 UserEntity u = new UserEntity(); u.setEmail("[email protected]");

spring boot整合mybatis-plus查詢資料庫的例子

1.匯入依賴 我這裡用的是maven專案，先在pom.xml中加入依賴： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"

Mybatis Plus各種查詢方法

package com.xiao.permission_system; impo

mybatis plus 聯合查詢

參數 AI 實現 PE object get href blank brush 在xml中只需要需要寫如下的代碼即可實現分頁： <select id="selectUserList" parameterType="map" resultType="com.test.

Mybatis plus中一個框多條件查詢 SQL拼接

條件查詢 filter array ryu toc suse return 多條 pen 遇到多條件查詢時，只用框架自帶的方法搞不定，只能自己寫方法拼接 EntityWrapper<YcejShopEntity> wrapper = new EntityWra

MyBatis-Plus | 最簡單的查詢操作教程（Lambda）

引言   是對MyBatis-Plus的功能進行簡單介紹，雖然是介紹，也讓我們領略到他的優雅與強大。你是不是已經被吸引了？彆著急，上一節，我們算是參觀了MyBatis的風景，這一節，我將帶你領略他獨特的魅力。 Lambda 官方表示，3.x支援Lambda表示式，那應該怎麼

mybatis-plus呼叫自身的 selectById 方法報錯:org.apache.ibatis.binding.BindingException:

　　mybatis-plus的版本號是 2.0.1,在呼叫自身的insert(T)的時候沒有報錯，但是執行update報錯，呼叫selectById、deleteById的時候也報錯。也就是涉及到需要主鍵識別的都報錯。 語句如下:(介面與實現都是MP自己實現的) User

mybatis-plus調用自身的 selectById 方法報錯:org.apache.ibatis.binding.BindingException:

spring ret 分享 img ceshi nbsp 都是 alua tro 　　mybatis-plus的版本號是 2.0.1,在調用自身的insert(T)的時候沒有報錯，但是執行update報錯，調用selectById、deleteById的時候也報錯。也就是涉

Mybatis-plus之RowBounds實現分頁查詢

物理分頁和邏輯分頁 物理分頁：直接從資料庫中拿出我們需要的資料，例如在Mysql中使用limit。 邏輯分頁：從資料庫中拿出所有符合要求的資料，然後再從這些資料中拿到我們需要的分頁資料。 優缺點 物理分頁每次都要訪問資料庫，邏輯分頁只訪問一次。 物理分頁佔用記憶體少，邏輯分頁相對較多。 物理分頁資

Mybatis-Plus的常用條件方法

mybatis-plus可呼叫的方法: 查詢方式            說明 setSqlSelect    設定 SELECT 查詢欄位 where &nb

MyBatis-Plus多表聯合查詢並且分頁（3表）

這3張表的關係是   模型表Model  ===> 訓練表Training ===》應用表Application（大概的邏輯是：選擇應用，然後訓練，然後成為模型）如有不理解的可加我微信：17625089935 白天問我一般晚上回 首先我們先建立實體Model（我使用的d

Mybatis-plus多表關聯查詢，多表分頁查詢

學習plus真的覺得寫程式碼真的越來越舒服了。昨天開始接觸吧，只要學會了多表關聯查詢。plus就能隨意搭配使用了。 關於怎麼搭建的就自行了去研究了哦。這裡直接進入主題。 我用的是springboot+mybatis-plus。新專案我打算以後都是這樣了。   配置一個分頁外掛！ im

Mybatis-Plus模糊查詢

模糊查詢時,如遇到用一個傳參進行模糊查詢多個欄位的時候,記得用or,之後匹配的查詢條件用and連線 @Override public Page<MqInfo> queryMqPage(Integer currentPage, Integer pageSize, Mq

SpringBoot + MyBatis 動態查詢支援的通用方法

2018國慶, 已經提前預知會陰雨綿綿, 再說大家都能夠想像得到的場景, 還是在家學習吧. 人人人人人人人人人人人人人人人 人人人人人人人人人人人人人人人 人人人人人人人人人人人人人人人 人人人人人人人人人人人人人人人 人人人人人人人人人人人人人人人 人人人人人人人人人人人

資料庫中能查資料，mybatis中查詢為空的原因及解決方法

今日編寫專案時，發現了mybatis查詢操作時部分屬性為空值，部分屬性查詢出來了。    資料庫中存在值，也能查詢出來。 原因：mapper.xml檔案中，查詢屬性時，命名規範：查詢時的屬性必須對應java實體類中的屬性。因為我的工程師mybatis的逆向工程生成，有的

mybatis-plus-方法

/** * Copyright (c) 2011-2016, hubin ([email protected]). * <p> * Licensed under the Apache License, Version 2.0 (the "License"); you

Mybatis中的常用的三個查詢方法

selectList 用於查詢多條資料的情況，返回值是一個list集合。如果沒有查到任何資料，返回沒有元素的集合（空集合，不是null）   selectOne 用於查詢單條資料的情況，返回值是一個物件，如果沒有查到任何資料，返回一個null。 selectMap 用於查詢多條資料的情況

mybatis-plus高階查詢

mybatis-plus的條件構建器對於User類中有而user表中沒有的屬性需要加第二個註解@TableField(exist = false),表示排除User類中的屬性.　　首先看一個條件構建器例項的簡單實用.public void test(){ Ent

Mybatis like 查詢 防止SQL注入方法相關原理和解決方法整理

SQL注入：引自百度百科： 所謂SQL注入，就是通過把SQL命令插入到Web表單提交或輸入域名或頁面請求的查詢字串，最終達到欺騙伺服器執行惡意的SQL命令。具體來說，它是利用現有應用程式，將（惡意）的

Mybatis Plus 分頁多表關聯查詢

接上一篇springCloud的尾。我們這裡講mybatis plus裡的多表關聯。 第一種情況，多表關聯查詢且需要分頁。分頁依然是使用mybatis plus分頁，我們需要做的是去改變Page的結果集。所以我們在service實現類裡改變結果集就可以，至於SQL就自定義就