mybatis plus 查询方法

根据主键查询

UserEntity userEntity = ud.selectById(id);

根据实体查询

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

这个就比较常用了,根据实体属性查询,在junit单元测试,调用dao,只能通过实体,如果是通过service,有个也可以使用,当然实体也同样适用,在service中我经常用这个,

    EntityWrapper wrapper = new EntityWrapper();
    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 list = ud.selectByMap(columnMap) //通过map查询 适用场景是分页查询
            List list2 = ud.selectList(wrapper); //如果为Null,默认查询所有
            List list3 = ud.selectCount(wrapper) //通过EntityWrapper根据某个字段获取总数
            List list4 = ud.selectMaps(wrapper) //EntityWrapper查询
            List list5 = ud.selectPage(rowBounds, wrapper) //rowBounds里面封装了起止和长度,wrapper具体条件

复制代码

上面参数中例如columnMap是通过HashMap或者Map使字段以键值对的形式存在,然后进行查询

分页查询更是简单,因为RowBounds基本封装好了索引和长度,wrapper就是前面提到的EntityWrapper

下面再贴贴EntityWrapper的源码:
复制代码


/**
 * Copyright (c) 2011-2014, hubin (jobob@qq.com).
 * 

* 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 com.baomidou.mybatisplus.toolkit.StringUtils; /** *

* Entity 对象封装操作类,定义T-SQL语法 *

* * @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 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";

/**
 * 

* 兼容EntityWrapper *

* * @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 setSqlSelect(String sqlSelect) { if (StringUtils.isNotEmpty(sqlSelect)) { this.sqlSelect = sqlSelect; } return this; } /** *

* 使用字符串数组封装sqlSelect,便于在不需要指定 AS 的情况下通过实体类自动生成的列静态字段快速组装 sqlSelect,
* 减少手动录入的错误率 *

* * @param columns 字段 * @return */ public Wrapper 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; } /** *

* 使用对象封装的setsqlselect *

* * @param column 字段 * @return */ public Wrapper 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; } /** *

* 使用对象封装的setsqlselect *

* * @param columns 字段 * @return */ public Wrapper setSqlSelect(Columns columns) { Column[] columnArray = columns.getColumns(); if (ArrayUtils.isNotEmpty(columnArray)) { setSqlSelect(columnArray); } return this; } /** *

* SQL 片段 (子类实现) *

*/ public abstract String getSqlSegment(); @Override public String toString() { StringBuilder sb = new StringBuilder("Wrapper:"); 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(); } /** *

* 替换占位符 *

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

* 原生占位符sql *

* * @return */ public String originalSql() { return replacePlaceholder(getSqlSegment()); } /** *

* SQL中WHERE关键字跟的条件语句 *

*

* eg: ew.where("name='zhangsan'").where(id!=null, "id={0}", id); *

* 输出:
* 如果id=123: WHERE (NAME='zhangsan' AND id=123)
* 如果id=null: WHERE (NAME='zhangsan') *

* * @param condition 拼接的前置条件 * @param sqlWhere where语句 * @param params 参数集 * @return this */ public Wrapper where(boolean condition, String sqlWhere, Object... params) { if (condition) { sql.WHERE(formatSql(sqlWhere, params)); } return this; } /** *

* SQL中WHERE关键字跟的条件语句 *

*

* eg: ew.where("name='zhangsan'").where("id={0}","123"); *

* 输出: WHERE (NAME='zhangsan' AND id=123) *

* * @param sqlWhere where语句 * @param params 参数集 * @return this */ public Wrapper where(String sqlWhere, Object... params) { return where(true, sqlWhere, params); } /** *

* 等同于SQL的"field=value"表达式 *

* * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper eq(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s = {0}", column), params)); } return this; } /** *

* 等同于SQL的"field=value"表达式 *

* * @param column * @param params * @return */ public Wrapper eq(String column, Object params) { return eq(true, column, params); } /** *

* 等同于SQL的"field <> value"表达式 *

* * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper ne(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s <> {0}", column), params)); } return this; } /** *

* 等同于SQL的"field <> value"表达式 *

* * @param column * @param params * @return */ public Wrapper ne(String column, Object params) { return ne(true, column, params); } /** *

* 等同于SQL的"field=value"表达式 *

* * @param condition 拼接的前置条件 * @param params * @return */ @SuppressWarnings({"rawtypes", "unchecked"}) public Wrapper allEq(boolean condition, Map params) { if (condition && MapUtils.isNotEmpty(params)) { Iterator iterator = params.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry entry = (Map.Entry) iterator.next(); Object value = entry.getValue(); if (StringUtils.checkValNotNull(value)) { sql.WHERE(formatSql(String.format("%s = {0}", entry.getKey()), entry.getValue())); } } } return this; } /** *

* 等同于SQL的"field=value"表达式 *

* * @param params * @return */ @SuppressWarnings({"rawtypes", "unchecked"}) public Wrapper allEq(Map params) { return allEq(true, params); } /** *

* 等同于SQL的"field>value"表达式 *

* * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper gt(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s > {0}", column), params)); } return this; } /** *

* 等同于SQL的"field>value"表达式 *

* * @param column * @param params * @return */ public Wrapper gt(String column, Object params) { return gt(true, column, params); } /** *

* 等同于SQL的"field>=value"表达式 *

* * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper ge(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s >= {0}", column), params)); } return this; } /** *

* 等同于SQL的"field>=value"表达式 *

* * @param column * @param params * @return */ public Wrapper ge(String column, Object params) { return ge(true, column, params); } /** *

* 等同于SQL的"field * * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper lt(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s < {0}", column), params)); } return this; } /** *

* 等同于SQL的"field * * @param column * @param params * @return */ public Wrapper lt(String column, Object params) { return lt(true, column, params); } /** *

* 等同于SQL的"field<=value"表达式 *

* * @param condition 拼接的前置条件 * @param column * @param params * @return */ public Wrapper le(boolean condition, String column, Object params) { if (condition) { sql.WHERE(formatSql(String.format("%s <= {0}", column), params)); } return this; } /** *

* 等同于SQL的"field<=value"表达式 *

* * @param column * @param params * @return */ public Wrapper le(String column, Object params) { return le(true, column, params); } /** *

* AND 连接后续条件 *

* * @param condition 拼接的前置条件 * @param sqlAnd and条件语句 * @param params 参数集 * @return this */ public Wrapper and(boolean condition, String sqlAnd, Object... params) { if (condition) { sql.AND().WHERE(formatSql(sqlAnd, params)); } return this; } /** *

* AND 连接后续条件 *

* * @param sqlAnd and条件语句 * @param params 参数集 * @return this */ public Wrapper and(String sqlAnd, Object... params) { return and(true, sqlAnd, params); } /** *

* 使用AND连接并换行 *

*

* eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) AND (statu=1) *

* * @param condition 拼接的前置条件 * @param sqlAnd AND 条件语句 * @param params 参数值 * @return this */ public Wrapper andNew(boolean condition, String sqlAnd, Object... params) { if (condition) { sql.AND_NEW().WHERE(formatSql(sqlAnd, params)); } return this; } /** *

* 使用AND连接并换行 *

*

* eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) AND (statu=1) *

* * @return this */ public Wrapper andNew() { sql.AND_NEW(); return this; } /** *

* 使用AND连接并换行 *

*

* eg: ew.where("name='zhangsan'").and("id=11").andNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) AND (statu=1) *

* * @param sqlAnd AND 条件语句 * @param params 参数值 * @return this */ public Wrapper andNew(String sqlAnd, Object... params) { return andNew(true, sqlAnd, params); } /** *

* 使用AND连接并换行 *

*

* * @return this */ public Wrapper and() { sql.AND(); return this; } /** *

* 使用OR连接并换行 *

* * @return this */ public Wrapper or() { sql.OR(); return this; } /** *

* 添加OR条件 *

* * @param condition 拼接的前置条件 * @param sqlOr or 条件语句 * @param params 参数集 * @return this */ public Wrapper 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; } /** *

* 添加OR条件 *

* * @param sqlOr or 条件语句 * @param params 参数集 * @return this */ public Wrapper or(String sqlOr, Object... params) { return or(true, sqlOr, params); } /** *

* 使用OR换行,并添加一个带()的新的条件 *

*

* eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) OR (statu=1) *

* * @return this */ public Wrapper orNew() { sql.OR_NEW(); return this; } /** *

* 使用OR换行,并添加一个带()的新的条件 *

*

* eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) OR (statu=1) *

* * @param condition 拼接的前置条件 * @param sqlOr AND 条件语句 * @param params 参数值 * @return this */ public Wrapper 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; } /** *

* 使用OR换行,并添加一个带()的新的条件 *

*

* eg: ew.where("name='zhangsan'").and("id=11").orNew("statu=1"); 输出: WHERE * (name='zhangsan' AND id=11) OR (statu=1) *

* * @param sqlOr AND 条件语句 * @param params 参数值 * @return this */ public Wrapper orNew(String sqlOr, Object... params) { return orNew(true, sqlOr, params); } /** *

* SQL中groupBy关键字跟的条件语句 *

*

* eg: ew.where("name='zhangsan'").groupBy("id,name") *

* * @param condition 拼接的前置条件 * @param columns SQL 中的 Group by 语句,无需输入 Group By 关键字 * @return this */ public Wrapper groupBy(boolean condition, String columns) { if (condition) { sql.GROUP_BY(columns); } return this; } /** *

* SQL中groupBy关键字跟的条件语句 *

*

* eg: ew.where("name='zhangsan'").groupBy("id,name") *

* * @param columns SQL 中的 Group by 语句,无需输入 Group By 关键字 * @return this */ public Wrapper groupBy(String columns) { return groupBy(true, columns); } /** *

* SQL中having关键字跟的条件语句 *

*

* eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null") *

* * @param condition 拼接的前置条件 * @param sqlHaving having关键字后面跟随的语句 * @param params 参数集 * @return EntityWrapper */ public Wrapper having(boolean condition, String sqlHaving, Object... params) { if (condition) { sql.HAVING(formatSql(sqlHaving, params)); } return this; } /** *

* SQL中having关键字跟的条件语句 *

*

* eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null") *

* * @param sqlHaving having关键字后面跟随的语句 * @param params 参数集 * @return EntityWrapper */ public Wrapper having(String sqlHaving, Object... params) { return having(true, sqlHaving, params); } /** *

* SQL中orderby关键字跟的条件语句 *

*

* eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" * ).orderBy("id,name") *

* * @param condition 拼接的前置条件 * @param columns SQL 中的 order by 语句,无需输入 Order By 关键字 * @return this */ public Wrapper orderBy(boolean condition, String columns) { if (condition) { sql.ORDER_BY(columns); } return this; } /** *

* SQL中orderby关键字跟的条件语句 *

*

* eg: ew.groupBy("id,name").having("id={0}",22).and("password is not null" * ).orderBy("id,name") *

* * @param columns SQL 中的 order by 语句,无需输入 Order By 关键字 * @return this */ public Wrapper orderBy(String columns) { return orderBy(true, columns); } /** *

* SQL中orderby关键字跟的条件语句,可根据变更动态排序 *

* * @param condition 拼接的前置条件 * @param columns SQL 中的 order by 语句,无需输入 Order By 关键字 * @param isAsc 是否为升序 * @return this */ public Wrapper orderBy(boolean condition, String columns, boolean isAsc) { if (condition && StringUtils.isNotEmpty(columns)) { sql.ORDER_BY(columns + (isAsc ? " ASC" : " DESC")); } return this; } /** *

* SQL中orderby关键字跟的条件语句,可根据变更动态排序 *

* * @param condition 拼接的前置条件 * @param columns SQL 中的 order by 语句,无需输入 Order By 关键字 * @param isAsc 是否为升序 * @return this */ public Wrapper orderBy(boolean condition, Collection columns, boolean isAsc) { if (condition && CollectionUtils.isNotEmpty(columns)) { for (String column : columns) { orderBy(condition, column, isAsc); } } return this; } /** *

* SQL中orderby关键字跟的条件语句,可根据变更动态排序 *

* * @param columns SQL 中的 order by 语句,无需输入 Order By 关键字 * @param isAsc 是否为升序 * @return this */ public Wrapper orderBy(String columns, boolean isAsc) { return orderBy(true, columns, isAsc); } /** *

* 批量根据ASC排序 *

* * @param columns 需要排序的集合 * @return this */ public Wrapper orderAsc(Collection columns) { return orderBy(true, columns, true); } /** *

* 批量根据DESC排序 *

* * @param columns 需要排序的集合 * @return this */ public Wrapper orderDesc(Collection columns) { return orderBy(true, columns, false); } /** *

* LIKE条件语句,value中无需前后% *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 * @return this */ public Wrapper like(boolean condition, String column, String value) { if (condition) { handerLike(column, value, SqlLike.DEFAULT, false); } return this; } /** *

* LIKE条件语句,value中无需前后% *

* * @param column 字段名称 * @param value 匹配值 * @return this */ public Wrapper like(String column, String value) { return like(true, column, value); } /** *

* NOT LIKE条件语句,value中无需前后% *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 * @return this */ public Wrapper notLike(boolean condition, String column, String value) { if (condition) { handerLike(column, value, SqlLike.DEFAULT, true); } return this; } /** *

* NOT LIKE条件语句,value中无需前后% *

* * @param column 字段名称 * @param value 匹配值 * @return this */ public Wrapper notLike(String column, String value) { return notLike(true, column, value); } /** *

* 处理LIKE操作 *

* * @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))); } } /** *

* LIKE条件语句,value中无需前后% *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 * @param type * @return this */ public Wrapper like(boolean condition, String column, String value, SqlLike type) { if (condition) { handerLike(column, value, type, false); } return this; } /** *

* LIKE条件语句,value中无需前后% *

* * @param column 字段名称 * @param value 匹配值 * @param type * @return this */ public Wrapper like(String column, String value, SqlLike type) { return like(true, column, value, type); } /** *

* NOT LIKE条件语句,value中无需前后% *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 * @param type * @return this */ public Wrapper notLike(boolean condition, String column, String value, SqlLike type) { if (condition) { handerLike(column, value, type, true); } return this; } /** *

* NOT LIKE条件语句,value中无需前后% *

* * @param column 字段名称 * @param value 匹配值 * @param type * @return this */ public Wrapper notLike(String column, String value, SqlLike type) { return notLike(true, column, value, type); } /** *

* is not null 条件 *

* * @param condition 拼接的前置条件 * @param columns 字段名称。多个字段以逗号分隔。 * @return this */ public Wrapper isNotNull(boolean condition, String columns) { if (condition) { sql.IS_NOT_NULL(columns); } return this; } /** *

* is not null 条件 *

* * @param columns 字段名称。多个字段以逗号分隔。 * @return this */ public Wrapper isNotNull(String columns) { return isNotNull(true, columns); } /** *

* is null 条件 *

* * @param condition 拼接的前置条件 * @param columns 字段名称。多个字段以逗号分隔。 * @return this */ public Wrapper isNull(boolean condition, String columns) { if (condition) { sql.IS_NULL(columns); } return this; } /** *

* is null 条件 *

* * @param columns 字段名称。多个字段以逗号分隔。 * @return this */ public Wrapper isNull(String columns) { return isNull(true, columns); } /** *

* EXISTS 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param value 匹配值 * @return this */ public Wrapper exists(boolean condition, String value) { if (condition) { sql.EXISTS(value); } return this; } /** *

* EXISTS 条件语句,目前适配mysql及oracle *

* * @param value 匹配值 * @return this */ public Wrapper exists(String value) { return exists(true, value); } /** *

* NOT EXISTS条件语句 *

* * @param condition 拼接的前置条件 * @param value 匹配值 * @return this */ public Wrapper notExists(boolean condition, String value) { if (condition) { sql.NOT_EXISTS(value); } return this; } /** *

* NOT EXISTS条件语句 *

* * @param value 匹配值 * @return this */ public Wrapper notExists(String value) { return notExists(true, value); } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 逗号拼接的字符串 * @return this */ public Wrapper in(boolean condition, String column, String value) { if (condition && StringUtils.isNotEmpty(value)) { in(column, StringUtils.splitWorker(value, ",", -1, false)); } return this; } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param column 字段名称 * @param value 逗号拼接的字符串 * @return this */ public Wrapper in(String column, String value) { return in(true, column, value); } /** *

* NOT IN条件语句 *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 逗号拼接的字符串 * @return this */ public Wrapper notIn(boolean condition, String column, String value) { if (condition && StringUtils.isNotEmpty(value)) { notIn(column, StringUtils.splitWorker(value, ",", -1, false)); } return this; } /** *

* NOT IN条件语句 *

* * @param column 字段名称 * @param value 逗号拼接的字符串 * @return this */ public Wrapper notIn(String column, String value) { return notIn(true, column, value); } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 集合 * @return this */ public Wrapper in(boolean condition, String column, Collection value) { if (condition && CollectionUtils.isNotEmpty(value)) { sql.WHERE(formatSql(inExpression(column, value, false), value.toArray())); } return this; } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param column 字段名称 * @param value 匹配值 集合 * @return this */ public Wrapper in(String column, Collection value) { return in(true, column, value); } /** *

* NOT IN 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 集合 * @return this */ public Wrapper notIn(boolean condition, String column, Collection value) { if (condition && CollectionUtils.isNotEmpty(value)) { sql.WHERE(formatSql(inExpression(column, value, true), value.toArray())); } return this; } /** *

* NOT IN 条件语句,目前适配mysql及oracle *

* * @param column 字段名称 * @param value 匹配值 集合 * @return this */ public Wrapper notIn(String column, Collection value) { return notIn(true, column, value); } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 object数组 * @return this */ public Wrapper in(boolean condition, String column, Object[] value) { if (condition && ArrayUtils.isNotEmpty(value)) { sql.WHERE(formatSql(inExpression(column, Arrays.asList(value), false), value)); } return this; } /** *

* IN 条件语句,目前适配mysql及oracle *

* * @param column 字段名称 * @param value 匹配值 object数组 * @return this */ public Wrapper in(String column, Object[] value) { return in(true, column, value); } /** *

* NOT IN 条件语句,目前适配mysql及oracle *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param value 匹配值 object数组 * @return this */ public Wrapper notIn(boolean condition, String column, Object... value) { if (condition && ArrayUtils.isNotEmpty(value)) { sql.WHERE(formatSql(inExpression(column, Arrays.asList(value), true), value)); } return this; } /** *

* NOT IN 条件语句,目前适配mysql及oracle *

* * @param column 字段名称 * @param value 匹配值 object数组 * @return this */ public Wrapper notIn(String column, Object... value) { return notIn(true, column, value); } /** *

* 获取in表达式 *

* * @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; } /** *

* betwwee 条件语句 *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param val1 * @param val2 * @return this */ public Wrapper 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; } /** *

* betwwee 条件语句 *

* * @param column 字段名称 * @param val1 * @param val2 * @return this */ public Wrapper between(String column, Object val1, Object val2) { return between(true, column, val1, val2); } /** *

* NOT betwwee 条件语句 *

* * @param condition 拼接的前置条件 * @param column 字段名称 * @param val1 * @param val2 * @return this */ public Wrapper 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; } /** *

* NOT betwwee 条件语句 *

* * @param column 字段名称 * @param val1 * @param val2 * @return this */ public Wrapper notBetween(String column, Object val1, Object val2) { return notBetween(true, column, val1, val2); } /** *

* 为了兼容之前的版本,可使用where()或and()替代 *

* * @param sqlWhere where sql部分 * @param params 参数集 * @return this */ public Wrapper addFilter(String sqlWhere, Object... params) { return and(sqlWhere, params); } /** *

* 根据判断条件来添加条件语句部分 使用 andIf() 替代 *

*

* eg: ew.filterIfNeed(false,"name='zhangsan'").where("name='zhangsan'") * .filterIfNeed(true,"id={0}",22) *

* 输出: WHERE (name='zhangsan' AND id=22) *

* * @param need 是否需要添加该条件 * @param sqlWhere 条件语句 * @param params 参数集 * @return this */ public Wrapper addFilterIfNeed(boolean need, String sqlWhere, Object... params) { return need ? where(sqlWhere, params) : this; } /** *

* SQL注入内容剥离 *

* * @param value 待处理内容 * @return this */ protected String stripSqlInjection(String value) { return value.replaceAll("('.+--)|(--)|(\|)|(%7C)", ""); } /** *

* 格式化SQL *

* * @param sqlStr SQL语句部分 * @param params 参数集 * @return this */ protected String formatSql(String sqlStr, Object... params) { return formatSqlIfNeed(true, sqlStr, params); } /** *

* 根据需要格式化SQL
*
* Format SQL for methods: EntityWrapper.where/and/or...("name={0}", value); * ALL the {i} will be replaced with #{MPGENVALi}
*
* ew.where("sample_name={0}", "haha").and("sample_age >{0} * and sample_age<{1}", 18, 30) TO * sample_name=#{MPGENVAL1} and sample_age>#{MPGENVAL2} and * sample_age<#{MPGENVAL3}
*

* * @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; } /** *

* 自定义是否输出sql开头为 `WHERE` OR `AND` OR `OR` *

* * @param bool * @return this */ public Wrapper isWhere(Boolean bool) { this.isWhere = bool; return this; } /** *

* 手动把sql拼接到最后(有sql注入的风险,请谨慎使用) *

* * @param limit * @return this */ public Wrapper last(String limit) { sql.LAST(limit); return this; } /** * Fix issue 200. * * @return * @since 2.0.3 */ public Map getParamNameValuePairs() { return paramNameValuePairs; } public String getParamAlias() { return StringUtils.isEmpty(paramAlias) ? DEFAULT_PARAM_ALIAS : paramAlias; } /** *

* 参数别名设置,初始化时优先设置该值、重复设置异常 *

* * @param paramAlias 参数别名 * @return */ public Wrapper 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 查询方法)