官网文档地址：
https://mp.baomidou.com/guide/
https://mybatis.plus/guide/
一、引入依赖 https://mvnrepository.com/
<dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.2</version> </dependency>
二、配置
想要在控制台查看执行的 sql 语句，可以在 yml 文件中添加配置信息
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
三、代码生成器
（1）AutoGenerator 简介
AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
与 mybatis 中的 mybatis-generator-core 类似。
（2）添加依赖
<dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</artifactId> <version>3.4.1</version> </dependency>
<dependency> <groupId>org.apache.velocity</groupId> <artifactId>velocity-engine-core</artifactId> <version>2.3</version> </dependency>
创建一个 代码生成器。用于生成代码。
package com.lyh.test.test_mybatis_plus; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.generator.AutoGenerator; import com.baomidou.mybatisplus.generator.config.DataSourceConfig; import com.baomidou.mybatisplus.generator.config.GlobalConfig; import com.baomidou.mybatisplus.generator.config.PackageConfig; import com.baomidou.mybatisplus.generator.config.StrategyConfig; import com.baomidou.mybatisplus.generator.config.rules.DateType; import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy; import org.junit.jupiter.api.Test; public class TestAutoGenerate { @Test public void autoGenerate() { // Step1：代码生成器 AutoGenerator mpg = new AutoGenerator(); // Step2：全局配置 GlobalConfig gc = new GlobalConfig(); // 填写代码生成的目录(需要修改) String projectPath = "E:\myProject\test\test_mybatis_plus"; // 拼接出代码最终输出的目录 gc.setOutputDir(projectPath + "/src/main/java"); // 配置开发者信息（可选）（需要修改） gc.setAuthor("lyh"); // 配置是否打开目录，false 为不打开（可选） gc.setOpen(false); // 实体属性 Swagger2 注解，添加 Swagger 依赖，开启 Swagger2 模式（可选） //gc.setSwagger2(true); // 重新生成文件时是否覆盖，false 表示不覆盖（可选） gc.setFileOverride(false); // 配置主键生成策略，此处为 ASSIGN_ID（可选） gc.setIdType(IdType.ASSIGN_ID); // 配置日期类型，此处为 ONLY_DATE（可选） gc.setDateType(DateType.ONLY_DATE); // 默认生成的 service 会有 I 前缀 gc.setServiceName("%sService"); mpg.setGlobalConfig(gc); // Step3：数据源配置（需要修改） DataSourceConfig dsc = new DataSourceConfig(); // 配置数据库 url 地址 dsc.setUrl("jdbc:mysql://localhost:3306/testMyBatisPlus?useUnicode=true&characterEncoding=utf8"); // dsc.setSchemaName("testMyBatisPlus"); // 可以直接在 url 中指定数据库名 // 配置数据库驱动 dsc.setDriverName("com.mysql.cj.jdbc.Driver"); // 配置数据库连接用户名 dsc.setUsername("root"); // 配置数据库连接密码 dsc.setPassword("123456"); mpg.setDataSource(dsc); // Step:4：包配置 PackageConfig pc = new PackageConfig(); // 配置父包名（需要修改） pc.setParent("com.lyh.test"); // 配置模块名（需要修改） pc.setModuleName("test_mybatis_plus"); // 配置 entity 包名 pc.setEntity("entity"); // 配置 mapper 包名 pc.setMapper("mapper"); // 配置 service 包名 pc.setService("service"); // 配置 controller 包名 pc.setController("controller"); mpg.setPackageInfo(pc); // Step5：策略配置（数据库表配置） StrategyConfig strategy = new StrategyConfig(); // 指定表名（可以同时操作多个表，使用 , 隔开）（需要修改） strategy.setInclude("test_mybatis_plus_user"); // 配置数据表与实体类名之间映射的策略 strategy.setNaming(NamingStrategy.underline_to_camel); // 配置数据表的字段与实体类的属性名之间映射的策略 strategy.setColumnNaming(NamingStrategy.underline_to_camel); // 配置 lombok 模式 strategy.setEntityLombokModel(true); // 配置 rest 风格的控制器（@RestController） strategy.setRestControllerStyle(true); // 配置驼峰转连字符 strategy.setControllerMappingHyphenStyle(true); // 配置表前缀，生成实体时去除表前缀 // 此处的表名为 test_mybatis_plus_user，模块名为 test_mybatis_plus，去除前缀后剩下为 user。 strategy.setTablePrefix(pc.getModuleName() + "_"); mpg.setStrategy(strategy); // Step6：执行代码生成操作 mpg.execute(); } }
四、自动填充功能。
使用 @TableField 注解，标注需要进行填充的字段。
/** * 创建时间 */ @TableField(fill = FieldFill.INSERT) private Date createTime; /** * 最后修改时间 */ @TableField(fill = FieldFill.INSERT_UPDATE) private Date updateTime;
package com.lyh.test.test_mybatis_plus.handler; import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler; import org.apache.ibatis.reflection.MetaObject; import org.springframework.stereotype.Component; import java.util.Date; @Component public class MyMetaObjectHandler implements MetaObjectHandler { @Override public void insertFill(MetaObject metaObject) { this.strictInsertFill(metaObject, "createTime", Date.class, new Date()); this.strictInsertFill(metaObject, "updateTime", Date.class, new Date()); } @Override public void updateFill(MetaObject metaObject) { this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date()); } }
五、逻辑删除
删除数据，可以通过物理删除，也可以通过逻辑删除。
物理删除指的是直接将数据从数据库中删除，不保留。
逻辑删除指的是修改数据的某个字段，使其表示为已删除状态，而非删除数据，保留该数据在数据库中，但是查询时不显示该数据（查询时过滤掉该数据）。
给数据表增加一个字段：is_delete，用于表示该数据是否被逻辑删除。
步骤1: 配置com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig
- 例: application.yml
mybatis-plus: global-config: db-config: logic-delete-field: isDelete # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2) logic-delete-value: 1 # 逻辑已删除值(默认为 1) logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
步骤2: 实体类字段上加上@TableLogic注解
使用逻辑删除: 可以定义一个自动填充规则，初始值为 0。0 表示未删除， 1 表示删除。
/** * 逻辑删除（0 未删除、1 删除） */ @TableLogic(value = "0", delval = "1") @TableField(fill = FieldFill.INSERT) private Integer isDelete; @Override public void insertFill(MetaObject metaObject) { this.strictInsertFill(metaObject, "idDelete", Integer.class, 0); }
六、配置分页插件。
与 mybatis 的插件 pagehelper 用法类似。
通过简单的配置即可使用。
编写一个 配置类，内部使用 @Bean 注解将 PaginationInterceptor 交给 Spring 容器管理。
//Spring boot方式 @Configuration @MapperScan("com.baomidou.cloud.service.*.mapper*") public class MybatisPlusConfig { // 旧版 @Bean public PaginationInterceptor paginationInterceptor() { PaginationInterceptor paginationInterceptor = new PaginationInterceptor(); // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求 默认false // paginationInterceptor.setOverflow(false); // 设置最大单页限制数量，默认 500 条，-1 不受限制 // paginationInterceptor.setLimit(500); // 开启 count 的 join 优化,只针对部分 left join paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true)); return paginationInterceptor; } // 最新版 @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2)); return interceptor; } }
package com.lyh.test.test_mybatis_plus.config; import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor; import org.mybatis.spring.annotation.MapperScan; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * 自定义一个配置类，mapper 扫描也可在此写上 */ @Configuration @MapperScan("com.lyh.test.test_mybatis_plus.mapper") public class Myconfig { /** * 分页插件 * @return 分页插件的实例 */ @Bean public PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor(); } }
编写分页代码。
直接 new 一个 Page 对象，对象需要传递两个参数（当前页，每页显示的条数）。
调用 mybatis-plus 提供的分页查询方法，其会将 分页查询的数据封装到 Page 对象中。
public interface UserMapper {//可以继承或者不继承BaseMapper /** * <p> * 查询 : 根据state状态查询用户列表，分页显示 * </p> * * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位(你可以继承Page实现自己的分页对象) * @param state 状态 * @return 分页对象 */ IPage<User> selectPageVo(Page<?> page, Integer state); }
<select id="selectPageVo" resultType="com.baomidou.cloud.entity.UserVo"> SELECT id,name FROM user WHERE state=#{state} </select>
public IPage<User> selectUserPage(Page<User> page, Integer state) { // 不进行 count sql 优化，解决 MP 无法自动优化 SQL 问题，这时候你需要自己查询 count 部分 // page.setOptimizeCountSql(false); // 当 total 为小于 0 或者设置 setSearchCount(false) 分页插件不会进行 count 查询 // 要点!! 分页返回的对象与传入的对象是同一个 return userMapper.selectPageVo(page, state); }
@Test public void testPage() { // Step1：创建一个 Page 对象 Page<User> page = new Page<>(); // Page<User> page = new Page<>(2, 5); // Step2：调用 mybatis-plus 提供的分页查询方法 userService.page(page, null); // Step3：获取分页数据 System.out.println(page.getCurrent()); // 获取当前页 System.out.println(page.getTotal()); // 获取总记录数 System.out.println(page.getSize()); // 获取每页的条数 System.out.println(page.getRecords()); // 获取每页数据的集合 System.out.println(page.getPages()); // 获取总页数 System.out.println(page.hasNext()); // 是否存在下一页 System.out.println(page.hasPrevious()); // 是否存在上一页 }
import lombok.Data; import java.util.List; /** * 分页返回对象 * @param <T> */ @Data public class PageResult<T> { private Long total; private List<T> items; }
@Override public PageResult<Article> searchArticlePage(Integer page, Integer size) { IPage<Article> articleIPage = new Page<>(page,size); QueryWrapper<Article> articleQueryWrapper = new QueryWrapper<>(); articleQueryWrapper.lambda().eq(Article::getIsDeleted,0); IPage<Article> iPage = articleMapper.selectPage(articleIPage, articleQueryWrapper); PageResult<Article> pageResult = new PageResult<>(); pageResult.setItems(iPage.getRecords()); pageResult.setTotal(iPage.getTotal()); System.out.println("文章总数：" + pageResult.getTotal()); return pageResult; }
七、mybatis-plus 实现乐观锁（通过 version 机制）
实现思路：
Step1：取出记录时，获取当前version
Step2：更新时，带上这个version
Step3：执行更新时， set version = newVersion where version = oldVersion
Step4：如果version不对，就更新失败
配置乐观锁插件。
编写一个配置类（可以与上例的分页插件共用一个配置类），将 OptimisticLockerInterceptor 通过 @Bean 交给 Spring 管理。
/** * 乐观锁插件 * @return 乐观锁插件的实例 */ @Bean public OptimisticLockerInterceptor optimisticLockerInterceptor() { return new OptimisticLockerInterceptor(); }
定义一个数据库字段 version。
CREATE TABLE test_mybatis_plus_user ( id BIGINT NOT NULL COMMENT '主键ID', name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名', age INT(11) NULL DEFAULT NULL COMMENT '年龄', email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱', create_time timestamp NULL DEFAULT NULL COMMENT '创建时间', update_time timestamp NULL DEFAULT NULL COMMENT '最后修改时间', delete_flag tinyint(1) NULL DEFAULT NULL COMMENT '逻辑删除（0 未删除、1 删除）', version int NULL DEFAULT NULL COMMENT '版本号（用于乐观锁， 默认为 1）', PRIMARY KEY (id) );
使用 @Version 注解标注对应的实体类。
可以通过 @TableField 进行数据自动填充。
/** * 版本号（用于乐观锁， 默认为 1） */ @Version @TableField(fill = FieldFill.INSERT) private Integer version; @Override public void insertFill(MetaObject metaObject) { this.strictInsertFill(metaObject, "version", Integer.class, 1); }
八、CRUD
使用代码生成器生成的 mapper 接口中，其继承了 BaseMapper 接口。
而 BaseMapper 接口中封装了一系列 CRUD 常用操作，可以直接使用，而不用自定义 xml 与 sql 语句进行 CRUD 操作（当然根据实际开发需要，自定义 sql 还是有必要的）。
【添加数据：（增）】 int insert(T entity); // 插入一条记录 注： T 表示任意实体类型 entity 表示实体对象 【删除数据：（删）】 int deleteById(Serializable id); // 根据主键 ID 删除 int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据 map 定义字段的条件删除 int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象 int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除 注： id 表示 主键 ID columnMap 表示表字段的 map 对象 wrapper 表示实体对象封装操作类，可以为 null。 idList 表示 主键 ID 集合（列表、数组），不能为 null 或 empty 【修改数据：（改）】 int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。 int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象 注： update 中的 entity 为 set 条件，可以为 null。 updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句） 【查询数据：（查）】 T selectById(Serializable id); // 根据 主键 ID 查询数据 List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询 List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询 T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录 Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数 List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合） List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合） List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值） <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页 <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页 注： queryWrapper 表示实体对象封装操作类（可以为 null） page 表示分页查询条件
使用 代码生成器 生成的 service 接口中，其继承了 IService 接口。
IService 内部进一步封装了 BaseMapper 接口的方法（当然也提供了更详细的方法）。
使用时，可以通过 生成的 mapper 类进行 CRUD 操作，也可以通过 生成的 service 的实现类进行 CRUD 操作。（当然，自定义代码执行也可）
此处简单介绍一下 IService 中封装的常用方法。
【添加数据：（增）】 default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。 boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据 注： entityList 表示实体对象集合 batchSize 表示一次批量插入的数据量，默认为 1000 【添加或修改数据：（增或改）】 boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据 default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作 boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 【删除数据：（删）】 default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。 default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除 default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。 default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。 【修改数据：（改）】 default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。 default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。 boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据 【查找数据：（查）】 default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。 default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。 default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询 default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。 Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。 default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。 default List<T> list(); // 返回所有数据。 default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。 default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。 default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。 default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询 default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询 注： get 用于返回一条记录。 list 用于返回多条记录。 count 用于返回记录总数。 page 用于分页查询。 【链式调用：】 default QueryChainWrapper<T> query(); // 普通链式查询 default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改 default UpdateChainWrapper<T> update(); // 普通链式修改 default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改 注： query 表示查询 update 表示修改 Lambda 表示内部支持 Lambda 写法。 形如： query().eq("column", value).one(); lambdaQuery().eq(Entity::getId, value).list(); update().eq("column", value).remove(); lambdaUpdate().eq(Entity::getId, value).update(entity);
上面介绍的 接口方法的参数中，会出现各种 wrapper，比如 queryWrapper、updateWrapper 等。wrapper 的作用就是用于定义各种各样的查询条件（where）。
Wrapper 条件构造抽象类 -- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。 -- QueryWrapper Entity 对象封装操作类，用于查询。 -- UpdateWrapper Update 条件封装操作类，用于更新。 -- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper -- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。 -- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。
常用条件
【通用条件：】 【比较大小： ( =, <>, >, >=, <, <= )】 eq(R column, Object val); // 等价于 =，例: eq("name", "老王") ---> name = '老王' ne(R column, Object val); // 等价于 <>，例: ne("name", "老王") ---> name <> '老王' gt(R column, Object val); // 等价于 >，例: gt("name", "老王") ---> name > '老王' ge(R column, Object val); // 等价于 >=，例: ge("name", "老王") ---> name >= '老王' lt(R column, Object val); // 等价于 <，例: lt("name", "老王") ---> name < '老王' le(R column, Object val); // 等价于 <=，例: le("name", "老王") ---> name <= '老王' 【范围：（between、not between、in、not in）】 between(R column, Object val1, Object val2); // 等价于 between a and b, 例： between("age", 18, 30) ---> age between 18 and 30 notBetween(R column, Object val1, Object val2); // 等价于 not between a and b, 例： notBetween("age", 18, 30) ---> age not between 18 and 30 in(R column, Object... values); // 等价于 字段 IN (v0, v1, ...),例: in("age",{1,2,3}) ---> age in (1,2,3) notIn(R column, Object... values); // 等价于 字段 NOT IN (v0, v1, ...), 例: notIn("age",{1,2,3}) ---> age not in (1,2,3) inSql(R column, Object... values); // 等价于 字段 IN (sql 语句), 例: inSql("id", "select id from table where id < 3") ---> id in (select id from table where id < 3) notInSql(R column, Object... values); // 等价于 字段 NOT IN (sql 语句) 【模糊匹配：（like）】 like(R column, Object val); // 等价于 LIKE '%值%'，例: like("name", "王") ---> name like '%王%' notLike(R column, Object val); // 等价于 NOT LIKE '%值%'，例: notLike("name", "王") ---> name not like '%王%' likeLeft(R column, Object val); // 等价于 LIKE '%值'，例: likeLeft("name", "王") ---> name like '%王' likeRight(R column, Object val); // 等价于 LIKE '值%'，例: likeRight("name", "王") ---> name like '王%' 【空值比较：（isNull、isNotNull）】 isNull(R column); // 等价于 IS NULL，例: isNull("name") ---> name is null isNotNull(R column); // 等价于 IS NOT NULL，例: isNotNull("name") ---> name is not null 【分组、排序：（group、having、order）】 groupBy(R... columns); // 等价于 GROUP BY 字段, ...， 例: groupBy("id", "name") ---> group by id,name orderByAsc(R... columns); // 等价于 ORDER BY 字段, ... ASC， 例: orderByAsc("id", "name") ---> order by id ASC,name ASC orderByDesc(R... columns); // 等价于 ORDER BY 字段, ... DESC， 例: orderByDesc("id", "name") ---> order by id DESC,name DESC having(String sqlHaving, Object... params); // 等价于 HAVING ( sql语句 )， 例: having("sum(age) > {0}", 11) ---> having sum(age) > 11 【拼接、嵌套 sql：（or、and、nested、apply）】 or(); // 等价于 a or b， 例：eq("id",1).or().eq("name","老王") ---> id = 1 or name = '老王' or(Consumer<Param> consumer); // 等价于 or(a or/and b)，or 嵌套。例: or(i -> i.eq("name", "李白").ne("status", "活着")) ---> or (name = '李白' and status <> '活着') and(Consumer<Param> consumer); // 等价于 and(a or/and b)，and 嵌套。例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着') nested(Consumer<Param> consumer); // 等价于 (a or/and b)，普通嵌套。例: nested(i -> i.eq("name", "李白").ne("status", "活着")) ---> (name = '李白' and status <> '活着') apply(String applySql, Object... params); // 拼接sql（若不使用 params 参数，可能存在 sql 注入），例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08") ---> date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'") last(String lastSql); // 无视优化规则直接拼接到 sql 的最后，可能存若在 sql 注入。 exists(String existsSql); // 拼接 exists 语句。例: exists("select id from table where age = 1") ---> exists (select id from table where age = 1) 【QueryWrapper 条件：】 select(String... sqlSelect); // 用于定义需要返回的字段。例： select("id", "name", "age") ---> select id, name, age select(Predicate<TableFieldInfo> predicate); // Lambda 表达式，过滤需要的字段。 lambda(); // 返回一个 LambdaQueryWrapper 【UpdateWrapper 条件：】 set(String column, Object val); // 用于设置 set 字段值。例: set("name", null) ---> set name = null etSql(String sql); // 用于设置 set 字段值。例: setSql("name = '老李头'") ---> set name = '老李头' lambda(); // 返回一个 LambdaUpdateWrapper
@Test public void testQueryWrapper() { // Step1：创建一个 QueryWrapper 对象 QueryWrapper<User> queryWrapper = new QueryWrapper<>(); // Step2： 构造查询条件 queryWrapper .select("id", "name", "age") .eq("age", 20) .like("name", "j"); // Step3：执行查询 userService .list(queryWrapper) .forEach(System.out::println); }
https://www.bilibili.com/video/av28331070/?p=5&spm_id_from=pageDriver