SpringBoot系列:MybatisPlus的入门级使用教程(下)

简介: 距离上一篇文章已经过去一个多月了,最近忙着项目上线,连轴转了一个多月,头发都少了不少!今天分享的是MP入门使用教程的最后的部分,也是使用的比较多的地方,就是如何使用MP进行条件查询!

前言


距离上一篇文章已经过去一个多月了,最近忙着项目上线,连轴转了一个多月,头发都少了不少!今天分享的是MP入门使用教程的最后的部分,也是使用的比较多的地方,就是如何使用MP进行条件查询!


正文


本文是在前两篇文章的基础之上进行拓展,所以如果有不清楚的可以先参考前面的两篇文章:SpringBoot系列:MybatisPlus的入门级使用教程(上),以及SpringBoot系列:MybatisPlus的入门级使用教程(中),源码地址会放在最后。


先来看一个使用MP进行条件查询的例子:


//构造条件构造器
 QueryWrapper<User> wrapper = new QueryWrapper<>();
 //构造条件
 wrapper.eq("User_ID",ID);
 //使用提供的selectList默认方法进行结果查询
 List<EduChapter> userList = baseMapper.selectList(wrapper);
复制代码


上述代码中首先使用QuerWrapper构造一个条件构造器,类型是需要查询的实体类User,然后使用条件构造器组装查询条件,上面是userid等于id,然后使用mp提供的默认的查询结果的selectList方法进行查询,条件就是上面构造的条件。


看起来很简单,这里主要就是使用QuerWrapper条件构造器构造查询条件,然后作为参数传入查询方法中即可。


接下来看看QuerWrapper的源码,源码比较长,这里截取部分,有需要的可以自行查看:


public class QueryWrapper<T> extends AbstractWrapper<T, String, QueryWrapper<T>> {
.....
}
复制代码


可以发现这里QueryWrapper继承了AbstractWrapper抽象类,点进去看看AbstractWrapper抽象类的源码:


public abstract class AbstractWrapper<T, R, This extends AbstractWrapper<T, R, This>> extends Wrapper<T> implements Compare<This, R>, Nested<This>, Join<This>, Func<This, R> {
    private static final String MP_GENERAL_PARAMNAME = "MPGENVAL";
    private static final String DEFAULT_PARAM_ALIAS = "ew";
    private static final String PLACE_HOLDER = "{%s}";
    private static final String MYBATIS_PLUS_TOKEN = "#{%s.paramNameValuePairs.%s}";
    protected final This typedThis = this;
    protected AtomicInteger paramNameSeq;
    protected Map<String, Object> paramNameValuePairs;
    protected String paramAlias = null;
    protected String lastSql = "";
    protected T entity;
    protected MergeSegments expression;
    protected Class<T> entityClass;
    public AbstractWrapper() {
    }
    public T getEntity() {
        return this.entity;
    }
    public This setEntity(T entity) {
        this.entity = entity;
        this.initEntityClass();
        return this.typedThis;
    }
    protected void initEntityClass() {
        if (this.entity != null) {
            this.entityClass = this.entity.getClass();
        }
    }
    protected Class<T> getCheckEntityClass() {
        Assert.notNull(this.entityClass, "entityClass must not null,please set entity before use this method!");
        return this.entityClass;
    }
    public <V> This allEq(boolean condition, Map<R, V> params, boolean null2IsNull) {
        if (condition && CollectionUtils.isNotEmpty(params)) {
            params.forEach((k, v) -> {
                if (StringUtils.checkValNotNull(v)) {
                    this.eq(k, v);
                } else if (null2IsNull) {
                    this.isNull(k);
                }
            });
        }
        return this.typedThis;
    }
    public <V> This allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) {
        if (condition && CollectionUtils.isNotEmpty(params)) {
            params.forEach((k, v) -> {
                if (filter.test(k, v)) {
                    if (StringUtils.checkValNotNull(v)) {
                        this.eq(k, v);
                    } else if (null2IsNull) {
                        this.isNull(k);
                    }
                }
            });
        }
        return this.typedThis;
    }
    public This eq(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.EQ, val);
    }
    public This ne(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.NE, val);
    }
    public This gt(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.GT, val);
    }
    public This ge(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.GE, val);
    }
    public This lt(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.LT, val);
    }
    public This le(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.LE, val);
    }
    public This like(boolean condition, R column, Object val) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.LIKE, () -> {
            return this.formatSql("{0}", "%" + val + "%");
        });
    }
    public This notLike(boolean condition, R column, Object val) {
        return this.not(condition).like(condition, column, val);
    }
    public This likeLeft(boolean condition, R column, Object val) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.LIKE, () -> {
            return this.formatSql("{0}", "%" + val);
        });
    }
    public This likeRight(boolean condition, R column, Object val) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.LIKE, () -> {
            return this.formatSql("{0}", val + "%");
        });
    }
    public This between(boolean condition, R column, Object val1, Object val2) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.BETWEEN, () -> {
            return this.formatSql("{0}", val1);
        }, SqlKeyword.AND, () -> {
            return this.formatSql("{0}", val2);
        });
    }
    public This notBetween(boolean condition, R column, Object val1, Object val2) {
        return this.not(condition).between(condition, column, val1, val2);
    }
    public This and(boolean condition, Function<This, This> func) {
        return this.and(condition).addNestedCondition(condition, func);
    }
    public This or(boolean condition, Function<This, This> func) {
        return this.or(condition).addNestedCondition(condition, func);
    }
    public This nested(boolean condition, Function<This, This> func) {
        return this.addNestedCondition(condition, func);
    }
    public This or(boolean condition) {
        return this.doIt(condition, SqlKeyword.OR);
    }
    public This apply(boolean condition, String applySql, Object... value) {
        return this.doIt(condition, WrapperKeyword.APPLY, () -> {
            return this.formatSql(applySql, value);
        });
    }
    public This last(boolean condition, String lastSql) {
        if (condition) {
            this.lastSql = " " + lastSql;
        }
        return this.typedThis;
    }
    public This exists(boolean condition, String existsSql) {
        return this.doIt(condition, SqlKeyword.EXISTS, () -> {
            return String.format("(%s)", existsSql);
        });
    }
    public This notExists(boolean condition, String notExistsSql) {
        return this.not(condition).exists(condition, notExistsSql);
    }
    public This isNull(boolean condition, R column) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.IS_NULL);
    }
    public This isNotNull(boolean condition, R column) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.IS_NOT_NULL);
    }
    public This in(boolean condition, R column, Collection<?> value) {
        return CollectionUtils.isEmpty(value) ? this.typedThis : this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.IN, this.inExpression(value));
    }
    public This notIn(boolean condition, R column, Collection<?> value) {
        return CollectionUtils.isEmpty(value) ? this.typedThis : this.not(condition).in(condition, column, value);
    }
    public This inSql(boolean condition, R column, String inValue) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, SqlKeyword.IN, () -> {
            return String.format("(%s)", inValue);
        });
    }
    public This notInSql(boolean condition, R column, String inValue) {
        return this.not(condition).inSql(condition, column, inValue);
    }
    public This groupBy(boolean condition, R... columns) {
        return ArrayUtils.isEmpty(columns) ? this.typedThis : this.doIt(condition, SqlKeyword.GROUP_BY, () -> {
            return this.columnsToString(columns);
        });
    }
    public This orderBy(boolean condition, boolean isAsc, R... columns) {
        if (ArrayUtils.isEmpty(columns)) {
            return this.typedThis;
        } else {
            SqlKeyword mode = isAsc ? SqlKeyword.ASC : SqlKeyword.DESC;
            Object[] var5 = columns;
            int var6 = columns.length;
            for(int var7 = 0; var7 < var6; ++var7) {
                R column = var5[var7];
                this.doIt(condition, SqlKeyword.ORDER_BY, () -> {
                    return this.columnToString(column);
                }, mode);
            }
            return this.typedThis;
        }
    }
    public This having(boolean condition, String sqlHaving, Object... params) {
        return this.doIt(condition, SqlKeyword.HAVING, () -> {
            return this.formatSqlIfNeed(condition, sqlHaving, params);
        });
    }
    protected This not(boolean condition) {
        return this.doIt(condition, SqlKeyword.NOT);
    }
    protected This and(boolean condition) {
        return this.doIt(condition, SqlKeyword.AND);
    }
    protected This addCondition(boolean condition, R column, SqlKeyword sqlKeyword, Object val) {
        return this.doIt(condition, () -> {
            return this.columnToString(column);
        }, sqlKeyword, () -> {
            return this.formatSql("{0}", val);
        });
    }
    protected This addNestedCondition(boolean condition, Function<This, This> func) {
        return this.doIt(condition, WrapperKeyword.LEFT_BRACKET, (ISqlSegment)func.apply(this.instance(this.paramNameSeq, this.paramNameValuePairs)), WrapperKeyword.RIGHT_BRACKET);
    }
    protected abstract This instance(AtomicInteger var1, Map<String, Object> var2);
    protected final String formatSql(String sqlStr, Object... params) {
        return this.formatSqlIfNeed(true, sqlStr, params);
    }
    protected final String formatSqlIfNeed(boolean need, String sqlStr, Object... params) {
        if (need && !StringUtils.isEmpty(sqlStr)) {
            if (ArrayUtils.isNotEmpty(params)) {
                for(int i = 0; i < params.length; ++i) {
                    String genParamName = "MPGENVAL" + this.paramNameSeq.incrementAndGet();
                    sqlStr = sqlStr.replace(String.format("{%s}", i), String.format("#{%s.paramNameValuePairs.%s}", this.getParamAlias(), genParamName));
                    this.paramNameValuePairs.put(genParamName, params[i]);
                }
            }
            return sqlStr;
        } else {
            return null;
        }
    }
    private ISqlSegment inExpression(Collection<?> value) {
        return () -> {
            return (String)value.stream().map((i) -> {
                return this.formatSql("{0}", i);
            }).collect(Collectors.joining(",", "(", ")"));
        };
    }
    protected final void initNeed() {
        this.paramNameSeq = new AtomicInteger(0);
        this.paramNameValuePairs = new HashMap(16);
        this.expression = new MergeSegments();
    }
    protected This doIt(boolean condition, ISqlSegment... sqlSegments) {
        if (condition) {
            this.expression.add(sqlSegments);
        }
        return this.typedThis;
    }
    public String getParamAlias() {
        return StringUtils.isEmpty(this.paramAlias) ? "ew" : this.paramAlias;
    }
    public String getSqlSegment() {
        String sqlSegment = this.expression.getSqlSegment();
        if (StringUtils.isNotEmpty(sqlSegment)) {
            return sqlSegment + this.lastSql;
        } else {
            return StringUtils.isNotEmpty(this.lastSql) ? this.lastSql : null;
        }
    }
    public MergeSegments gt() {
        return this.expression;
    }
    public Map<String, Object> getParamNameValuePairs() {
        return this.paramNameValuePairs;
    }
    protected String columnsToString(R... columns) {
        return (String)Arrays.stream(columns).map(this::columnToString).collect(Collectors.joining(","));
    }
    protected abstract String columnToString(R var1);
    public This clone() {
        return (AbstractWrapper)SerializationUtils.clone(this.typedThis);
    }
}
复制代码


AbstractWrapper继承了Wrapper抽象类,并且AbstractWrapper中提供了eq、gt、ge等条件判断方法,以及getExpression()生成条件表达式方法。类以及接口之间的关系如下图:


cbe3ac79d5824f1eab43f46ce5f138f7~tplv-k3u1fbpfcp-zoom-in-crop-mark_1304_0_0_0.webp.jpg


总结如下:


Wrapper : 它是条件构造抽象类,也是最顶端的父类;


AbstractWrapper : 也是条件构造器抽象类,继承了Wrapper 抽象类,它主要用于查询条件封装,生成 sql 的 where 条件

QueryWrapper : 是条件构造器的实体类,是对各类的Entity对象封装的操作类;


可以发现在AbstractWrapper类中有各类的ge、gt、le、lt、isNull、isNotNull、eq、ne等方法,它们等同于,sql语句中的大于、等于、小于等条件,比如


wrapper.eq("User_ID",ID);
复制代码


这行代码就表示,条件是user_ID字段的值等于ID,源码如下:


public This eq(boolean condition, R column, Object val) {
        return this.addCondition(condition, column, SqlKeyword.EQ, val);
}
复制代码


eq这类的方法的第一个参数是condition表示该条件是否加入生成的sql中,默认以及不写就是true,第二个参数表示的是字段名(注意需要和数据库中的字段名一样),第三个参数就是字段的值。


所以可以发现条件构造器最主要的就是eq、ge、gt这类方法的使用。它们大多数都是一样的,这里简单演示几种:


比如allEq,源码可以参考上面AbstractWrapper的源码:


QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    Map<String, Object> map = new HashMap<>();
    map.put("id", 2);
    map.put("name", "Jack");
    map.put("age", 20);
    queryWrapper.allEq(map);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
复制代码


like的使用:


QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
    .like("address","上海")
    .notLike("name", "e")
    .likeRight("email", "t");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
    maps.forEach(System.out::println);
复制代码


or、and的使用:如果不调用or则默认为使用 and


//修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or()
        .between("age", 20, 30);
    int result = userMapper.update(user, userUpdateWrapper);
复制代码


这里使用的是 UpdateWrapper, 它主要用于Update 条件封装,对Entity对象进行更新操作。


还可以使用select方法指定需要查询的字段,这里就是指定查询的id,name,age:


QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("id", "name", "age");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
复制代码


set、setSql:


//修改值
    User user = new User();
    user.setAge(99);
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
        .setSql(" email = '123@qq.com'");//可以有子查询
    int result = userMapper.update(user, userUpdateWrapper);
复制代码


最终的sql会合并 user.setAge(),以及 userUpdateWrapper.set()  和 setSql() 中 的字段。等同于:


UPDATE user SET age=99, name="老李头", email = '123@qq.com' WHERE deleted=0 AND name LIKE "h" 
复制代码

总结


以上就是关于mybatisplus的条件构造器的使用,至此mybatisplus的介绍大结局了,要想掌握更多的mp的使用,还是要在日常的开发中多多练习。更多关于mybatisplus的内容可以参考以下内容:


mybatisplus源码地址:
https://gitcode.net/mirrors/baomidou/mybatis-plus?utm_source=csdn_github_accelerator
MP官网地址:
https://baomidou.com/pages/24112f/
复制代码


目录
相关文章
|
2月前
|
Cloud Native Java C++
Springboot3新特性:开发第一个 GraalVM 本机应用程序(完整教程)
文章介绍如何在Spring Boot 3中利用GraalVM将Java应用程序编译成独立的本机二进制文件,从而提高启动速度、减少内存占用,并实现不依赖JVM运行。
255 1
Springboot3新特性:开发第一个 GraalVM 本机应用程序(完整教程)
|
2月前
|
前端开发 Java 数据安全/隐私保护
用户登录前后端开发(一个简单完整的小项目)——SpringBoot与session验证(带前后端源码)全方位全流程超详细教程
文章通过一个简单的SpringBoot项目,详细介绍了前后端如何实现用户登录功能,包括前端登录页面的创建、后端登录逻辑的处理、使用session验证用户身份以及获取已登录用户信息的方法。
276 2
用户登录前后端开发(一个简单完整的小项目)——SpringBoot与session验证(带前后端源码)全方位全流程超详细教程
|
23天前
|
SQL Java 数据库连接
【MyBatisPlus·最新教程】包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段
MyBatis-Plus是一个MyBatis的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。本文讲解了最新版MP的使用教程,包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段等核心功能。
【MyBatisPlus·最新教程】包含多个改造案例,常用注解、条件构造器、代码生成、静态工具、类型处理器、分页插件、自动填充字段
|
1月前
|
SQL 缓存 Java
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
本文详细介绍了MyBatis的各种常见用法MyBatis多级缓存、逆向工程、分页插件 包括获取参数值和结果的各种情况、自定义映射resultMap、动态SQL
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
|
1月前
|
SQL 存储 数据库
深入理解@TableField注解的使用-MybatisPlus教程
`@TableField`注解在MyBatis-Plus中是一个非常灵活和强大的工具,能够帮助开发者精细控制实体类与数据库表字段之间的映射关系。通过合理使用 `@TableField`注解,可以实现字段名称映射、自动填充、条件查询以及自定义类型处理等高级功能。这些功能在实际开发中,可以显著提高代码的可读性和维护性。如果需要进一步优化和管理你的MyBatis-Plus应用程
150 3
|
2月前
|
Java API Apache
Springboot+shiro,完整教程,带你学会shiro
这篇文章提供了一个完整的Apache Shiro与Spring Boot结合使用的教程,包括Shiro的配置、使用以及在非Web和Web环境中进行身份验证和授权的示例。
77 2
Springboot+shiro,完整教程,带你学会shiro
|
2月前
|
前端开发 Java Apache
Springboot整合shiro,带你学会shiro,入门级别教程,由浅入深,完整代码案例,各位项目想加这个模块的人也可以看这个,又或者不会mybatis-plus的也可以看这个
本文详细讲解了如何整合Apache Shiro与Spring Boot项目,包括数据库准备、项目配置、实体类、Mapper、Service、Controller的创建和配置,以及Shiro的配置和使用。
421 1
Springboot整合shiro,带你学会shiro,入门级别教程,由浅入深,完整代码案例,各位项目想加这个模块的人也可以看这个,又或者不会mybatis-plus的也可以看这个
|
2月前
|
缓存 NoSQL Java
springboot的缓存和redis缓存,入门级别教程
本文介绍了Spring Boot中的缓存机制,包括使用默认的JVM缓存和集成Redis缓存,以及如何配置和使用缓存来提高应用程序性能。
121 1
springboot的缓存和redis缓存,入门级别教程
|
3月前
|
JavaScript Java 关系型数据库
毕设项目&课程设计&毕设项目:基于springboot+vue实现的在线考试系统(含教程&源码&数据库数据)
本文介绍了一个基于Spring Boot和Vue.js实现的在线考试系统。随着在线教育的发展,在线考试系统的重要性日益凸显。该系统不仅能提高教学效率,减轻教师负担,还为学生提供了灵活便捷的考试方式。技术栈包括Spring Boot、Vue.js、Element-UI等,支持多种角色登录,具备考试管理、题库管理、成绩查询等功能。系统采用前后端分离架构,具备高性能和扩展性,未来可进一步优化并引入AI技术提升智能化水平。
毕设项目&课程设计&毕设项目:基于springboot+vue实现的在线考试系统(含教程&源码&数据库数据)
|
3月前
|
Java 关系型数据库 MySQL
毕设项目&课程设计&毕设项目:springboot+jsp实现的房屋租租赁系统(含教程&源码&数据库数据)
本文介绍了一款基于Spring Boot和JSP技术的房屋租赁系统,旨在通过自动化和信息化手段提升房屋管理效率,优化租户体验。系统采用JDK 1.8、Maven 3.6、MySQL 8.0、JSP、Layui和Spring Boot 2.0等技术栈,实现了高效的房源管理和便捷的租户服务。通过该系统,房东可以轻松管理房源,租户可以快速找到合适的住所,双方都能享受数字化带来的便利。未来,系统将持续优化升级,提供更多完善的服务。
毕设项目&课程设计&毕设项目:springboot+jsp实现的房屋租租赁系统(含教程&源码&数据库数据)