MP实战系列(五)之封装方法讲解

本文涉及的产品
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
RDS MySQL Serverless 高可用系列,价值2615元额度,1个月
简介: mybatis plus封装的方法怎么用?以及它们对应的sql是那些sql?及其什么情况用?这些需要说下,以下我将会将我常用的说下,不是常用的,可能提以下或者不提。根据主键查询 UserEntity userEntity = ud.

mybatis plus封装的方法怎么用?以及它们对应的sql是那些sql?及其什么情况用?

这些需要说下,以下我将会将我常用的说下,不是常用的,可能提以下或者不提。

根据主键查询

    UserEntity userEntity = ud.selectById(id);

 

上述这个没什么好说的

 

根据实体查询

     UserEntity u = new UserEntity();
        u.setEmail("123@qq.com");
        UserEntity u1 = ud.selectOne(u);

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

        
        EntityWrapper<UserEntity> wrapper = new EntityWrapper<UserEntity>();
        wrapper.eq("email", "123@qq.com");
        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 (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 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;


/**
 * <p>
 * 条件构造抽象类,定义T-SQL语法
 * </p>
 *
 * @author hubin , yanghu , Dyang , Caratacus
 * @Date 2016-11-7
 */
@SuppressWarnings("serial")
public abstract class Wrapper<T> 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的形式

 

 

通过这篇博文,可以让你明白这些方法的应用场景

 

相关实践学习
基于CentOS快速搭建LAMP环境
本教程介绍如何搭建LAMP环境,其中LAMP分别代表Linux、Apache、MySQL和PHP。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心,利用清洁计算为万物互联的新世界提供源源不断的能源动力,目前开服的区域包括中国(华北、华东、华南、香港)、新加坡、美国(美东、美西)、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程,来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品:云服务器ECS 云服务器 ECS(Elastic Compute Service)是一种弹性可伸缩的计算服务,助您降低 IT 成本,提升运维效率,使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
目录
相关文章
|
3天前
|
监控 前端开发 数据库
RACSignal的八种常用用法
RACSignal的八种常用用法
13 0
|
5月前
|
SQL 监控
MP-p6spy日志分析打印
MP-p6spy日志分析打印
63 0
|
11月前
|
Python
__name__的基本用法
__name__的基本用法
67 0
【FFmpeg】ffmpeg 命令查询一 ( 版本 | 编译配置 | 复用格式 | 编解码器 )(六)
【FFmpeg】ffmpeg 命令查询一 ( 版本 | 编译配置 | 复用格式 | 编解码器 )(六)
474 0
【FFmpeg】ffmpeg 命令查询一 ( 版本 | 编译配置 | 复用格式 | 编解码器 )(六)
|
编解码
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )(三)
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )(三)
161 0
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )(三)
|
编解码
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )
344 0
【FFmpeg】ffmpeg 命令查询三 ( 查询 ffmpeg 命令分类支持的参数 )
|
JSON Android开发 数据格式
Okhttp3-基本用法
前言 Okhttp官网Okhttp-Github android网络框架之OKhttp一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso) 用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient) 官网的解释如下: 基本用法 1.集成 1.1.依赖 implementation 'com.squareup.okhttp3:okhttp:3.11.0' 可以去Okhttp-Github 查看并依赖最新的版本。
3083 0
|
C# 容器 数据格式
AvalonDock的基本用法
原文:AvalonDock的基本用法         AvalonDock是优秀的开源项目,用于创建可停靠式布局,能够在WPF中方便开发出类似VS2010的软件界面。对于复杂的软件系统,大量控件的使用会使的界面变得难以管理。
2058 0
|
Java
Systrace的用法小结
通过SysTrace可以帮助我们分析性能问题,包含方法的耗时时长、CPU的使用情况、ANR、布局情况等;相比性能工具TraceView,主要用来分析每个方法的执行时间,对于冷启动而言,想抓trace只能通过代码的方式,这样会导致整个应用比较卡顿,测试出的方法时间,不是真正的执行时间,只能看下时间长短的相对占比。
3433 0