2 MyBatisPlus入门

一、简介

官网：http://mp.baomidou.com/

参考教程：http://mp.baomidou.com/guide/

MyBatis-Plus（简称 MP）是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

二、特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多种数据库
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 XML 热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
支持关键词自动转义：支持数据库关键词（order、key......）自动转义，还可自定义关键词
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
内置 Sql 注入剥离器：支持 Sql 注入剥离，有效预防 Sql 注入攻击

快速开始参考：http://mp.baomidou.com/guide/quick-start.html

测试项目：mybatis_plus

数据库：mybatis_plus

一、创建并初始化数据库

1、创建数据库：

mybatis_plus

2、创建`User`表

其表结构如下：

id	name	age	email
1	Jone	18	test1@baomidou.com
2	Jack	20	test2@baomidou.com
3	Tom	28	test3@baomidou.com
4	Sandy	21	test4@baomidou.com
5	Billie	24	test5@baomidou.com

其对应的数据库 Schema 脚本如下：

1
DROP TABLE IF EXISTS user;
2
3
CREATE TABLE user
4
(
5
    id BIGINT(20) NOT NULL COMMENT '主键ID',
6
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
7
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
8
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
9
    PRIMARY KEY (id)
10
);

其对应的数据库 Data 脚本如下：


DELETE FROM user;
2
3
INSERT INTO user (id, name, age, email) VALUES
4
(1, 'Jone', 18, 'test1@baomidou.com'),
5
(2, 'Jack', 20, 'test2@baomidou.com'),
6
(3, 'Tom', 28, 'test3@baomidou.com'),
7
(4, 'Sandy', 21, 'test4@baomidou.com'),
8
(5, 'Billie', 24, 'test5@baomidou.com');

二、初始化工程

使用 Spring Initializr 快速初始化一个 Spring Boot 工程

Group：com.atguigu

Artifact：mybatis-plus

版本：2.2.1.RELEASE

三、添加依赖

1、引入依赖

spring-boot-starter、spring-boot-starter-test

添加：mybatis-plus-boot-starter、MySQL、```lombok```、

在项目中使用Lombok可以减少很多重复代码的书写。比如说getter/setter/toString等方法的编写

<dependencies>
2
    <dependency>
3
        <groupId>org.springframework.boot</groupId>
4
        <artifactId>spring-boot-starter</artifactId>
5
    </dependency>
6
7
    <dependency>
8
        <groupId>org.springframework.boot</groupId>
9
        <artifactId>spring-boot-starter-test</artifactId>
10
        <scope>test</scope>
11
        <exclusions>
12
            <exclusion>
13
                <groupId>org.junit.vintage</groupId>
14
                <artifactId>junit-vintage-engine</artifactId>
15
            </exclusion>
16
        </exclusions>
17
    </dependency>
18
19
    <!--mybatis-plus-->
20
    <dependency>
21
        <groupId>com.baomidou</groupId>
22
        <artifactId>mybatis-plus-boot-starter</artifactId>
23
        <version>3.0.5</version>
24
    </dependency>
25
26
    <!--mysql-->
27
    <dependency>
28
        <groupId>mysql</groupId>
29
        <artifactId>mysql-connector-java</artifactId>
30
    </dependency>
31
32
    <!--lombok用来简化实体类-->
33
    <dependency>
34
        <groupId>org.projectlombok</groupId>
35
        <artifactId>lombok</artifactId>
36
    </dependency>
37
</dependencies>

注意：引入MyBatis-Plus之后请不要再次引入MyBatis以及MyBatis-Spring，以避免因版本差异导致的问题。

2、idea中安装lombok插件

（2）idea2019版本

四、配置

在application.properties配置文件中添加 MySQL 数据库的相关配置：

MySQL5 的


#mysql数据库连接
2
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
3
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus
4
spring.datasource.username=root
5
spring.datasource.password=123456

mysql8以上（spring boot 2.1）

注意：driver和url的变化

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
2
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
3
spring.datasource.username=root
4
spring.datasource.password=123456

注意：

1、这里的 url 使用了?serverTimezone=GMT%2B8 后缀，因为Spring Boot 2.1 集成了 8.0版本的jdbc驱动，这个版本的 jdbc 驱动需要添加这个后缀，否则运行测试用例报告如下错误：

java.sql.SQLException: The server time zone value 'ÖÐ¹ú±ê×¼Ê±¼ä' is unrecognized or represents more

2、这里的 driver-class-name 使用了 com.mysql.cj.jdbc.Driver ，在 jdbc 8 中建议使用这个驱动，之前的 com.mysql.jdbc.Driver 已经被废弃，否则运行测试用例的时候会有 WARN 信息

五、编写代码

1、主类

在 Spring Boot 启动类中添加@MapperScan注解，扫描 Mapper 文件夹

注意：扫描的包名根据实际情况修改


@SpringBootApplication
2
@MapperScan("com.atguigu.mybatisplus.mapper")
3
public class MybatisPlusApplication {
4
    ......
5
}

2、实体

创建包entity编写实体类User.java（此处使用了Lombok简化代码）


@Data
2
public class User {
3
    private Long id;
4
    private String name;
5
    private Integer age;
6
    private String email;
7
}

查看编译结果

Lombok使用参考：

https://blog.csdn.net/motui/article/details/79012846

3、mapper

创建包mapper编写Mapper 接口： UserMapper.java

public interface UserMapper extends BaseMapper<User> {
2
    
3
}

六、开始使用

添加测试类，进行功能测试：


@RunWith(SpringRunner.class)
2
@SpringBootTest
3
public class MybatisPlusApplicationTests {
4
5
    @Autowired
6
    private UserMapper userMapper;
7
8
    @Test
9
    public void testSelectList() {
10
        System.out.println(("----- selectAll method test ------"));
11
        //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
12
        //所以不填写就是无任何条件
13
        List<User> users = userMapper.selectList(null);
14
        users.forEach(System.out::println);
15
    }
16
}

注意：

IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。

为了避免报错，可以在 dao 层的接口上添加 @Repository 注

控制台输出：

1
User(id=1, name=Jone, age=18, email=test1@baomidou.com)
2
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
3
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
4
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
5
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

七、配置日志

查看sql输出日志

#mybatis日志
2
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

一、insert

1、插入操作


@RunWith(SpringRunner.class)
2
@SpringBootTest
3
public class CRUDTests {
4
5
    @Autowired
6
    private UserMapper userMapper;
7
8
    @Test
9
    public void testInsert(){
10
11
        User user = new User();
12
        user.setName("Helen");
13
        user.setAge(18);
14
        user.setEmail("55317332@qq.com");
15
16
        int result = userMapper.insert(user);
17
        System.out.println(result); //影响的行数
18
        System.out.println(user); //id自动回填
19
    }
20
}

注意：数据库插入id值默认为：全局唯一id

2、主键策略

（1）ID_WORKER

MyBatis-Plus默认的主键策略是：ID_WORKER全局唯一ID

参考资料：分布式系统唯一ID生成方案汇总：https://www.cnblogs.com/haoxinyue/p/5208136.html

（2）自增策略

要想主键自增需要配置如下主键策略
- 需要在创建数据表的时候设置主键自增
- 实体字段中配置 @TableId(type = IdType.AUTO)

@TableId(type = IdType.AUTO)
2
private Long id;

要想影响所有实体的配置，可以设置全局主键配置

#全局设置主键生成策略
2
mybatis-plus.global-config.db-config.id-type=auto

其它主键策略：分析 IdType 源码可知

@Getter
2
public enum IdType {
3
    /**
4
     * 数据库ID自增
5
     */
6
    AUTO(0),
7
    /**
8
     * 该类型为未设置主键类型
9
     */
10
    NONE(1),
11
    /**
12
     * 用户输入ID
13
     * 该类型可以通过自己注册自动填充插件进行填充
14
     */
15
    INPUT(2),
16
17
    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
18
    /**
19
     * 全局唯一ID (idWorker)
20
     */
21
    ID_WORKER(3),
22
    /**
23
     * 全局唯一ID (UUID)
24
     */
25
    UUID(4),
26
    /**
27
     * 字符串全局唯一ID (idWorker 的字符串表示)
28
     */
29
    ID_WORKER_STR(5);
30
31
    private int key;
32
33
    IdType(int key) {
34
        this.key = key;
35
    }
36
}

二、update

1、根据Id更新操作

注意：update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=?

@Test
2
    public void testUpdateById(){
3
4
        User user = new User();
5
        user.setId(1L);
6
        user.setAge(28);
7
8
        int result = userMapper.updateById(user);
9
        System.out.println(result);
10
11
    }

2、自动填充

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。

我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作：

（1）数据库表中添加自动填充字段

在User表中添加datetime类型的新的字段 create_time、update_time

（2）实体上添加注解

@Data
2
public class User {
3
    ......
4
        
5
    @TableField(fill = FieldFill.INSERT)
6
    private Date createTime;
7
8
    //@TableField(fill = FieldFill.UPDATE)
9
    @TableField(fill = FieldFill.INSERT_UPDATE)
10
    private Date updateTime;
11
}

（3）实现元对象处理器接口

注意：不要忘记添加 @Component 注解

package com.atguigu.mybatisplus.handler;
2
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
3
import org.apache.ibatis.reflection.MetaObject;
4
import org.slf4j.Logger;
5
import org.slf4j.LoggerFactory;
6
import org.springframework.stereotype.Component;
7
import java.util.Date;
8
9
@Component
10
public class MyMetaObjectHandler implements MetaObjectHandler {
11
12
    private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);
13
14
    @Override
15
    public void insertFill(MetaObject metaObject) {
16
        LOGGER.info("start insert fill ....");
17
        this.setFieldValByName("createTime", new Date(), metaObject);
18
        this.setFieldValByName("updateTime", new Date(), metaObject);
19
    }
20
21
    @Override
22
    public void updateFill(MetaObject metaObject) {
23
        LOGGER.info("start update fill ....");
24
        this.setFieldValByName("updateTime", new Date(), metaObject);
25
    }
26
}

（4）测试

3、乐观锁

主要适用场景：当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新

乐观锁实现方式：

取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败

（1）数据库中添加version字段

ALTER TABLE `user` ADD COLUMN `version` INT

（2）实体类添加version字段

并添加 @Version 注解

@Version
2
@TableField(fill = FieldFill.INSERT)
3
private Integer version;

（3）元对象处理器接口添加version的insert默认值

@Override
2
public void insertFill(MetaObject metaObject) {
3
    ......
4
    this.setFieldValByName("version", 1, metaObject);
5
}

特别说明:

* 支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime

整数类型下newVersion = oldVersion + 1
newVersion会回写到entity中
仅支持updateById(id)与update(entity, wrapper)方法
在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

（4）在 MybatisPlusConfig 中注册 Bean**

创建配置类

package com.atguigu.mybatisplus.config;
2
3
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
4
import org.mybatis.spring.annotation.MapperScan;
5
import org.springframework.context.annotation.Bean;
6
import org.springframework.context.annotation.Configuration;
7
import org.springframework.transaction.annotation.EnableTransactionManagement;
8
9
@EnableTransactionManagement
10
@Configuration
11
@MapperScan("com.atguigu.mybatis_plus.mapper")
12
public class MybatisPlusConfig {
13
14
    /**
15
     * 乐观锁插件
16
     */
17
    @Bean
18
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
19
        return new OptimisticLockerInterceptor();
20
    }
21
}

（5）测试乐观锁可以修改成功

测试后分析打印的sql语句，将version的数值进行了加1操作

/**
2
 * 测试 乐观锁插件
3
 */
4
@Test
5
public void testOptimisticLocker() {
6
7
    //查询
8
    User user = userMapper.selectById(1L);
9
    //修改数据
10
    user.setName("Helen Yao");
11
    user.setEmail("helen@qq.com");
12
    //执行更新
13
    userMapper.updateById(user);
14
}

（5）测试乐观锁修改失败

/**
2
 * 测试乐观锁插件 失败
3
 */
4
@Test
5
public void testOptimisticLockerFail() {
6
7
    //查询
8
    User user = userMapper.selectById(1L);
9
    //修改数据
10
    user.setName("Helen Yao1");
11
    user.setEmail("helen@qq.com1");
12
13
    //模拟取出数据后，数据库中version实际数据比取出的值大，即已被其它线程修改并更新了version
14
    user.setVersion(user.getVersion() - 1);
15
16
    //执行更新
17
    userMapper.updateById(user);
18
}

三、select

1、根据id查询记录

@Test
2
public void testSelectById(){
3
4
    User user = userMapper.selectById(1L);
5
    System.out.println(user);
6
}

2、通过多个id批量查询

完成了动态sql的foreach的功能

@Test
2
public void testSelectBatchIds(){
3
4
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
5
    users.forEach(System.out::println);
6
}

3、简单的条件查询

通过map封装查询条件

@Test
2
public void testSelectByMap(){
3
4
    HashMap<String, Object> map = new HashMap<>();
5
    map.put("name", "Helen");
6
    map.put("age", 18);
7
    List<User> users = userMapper.selectByMap(map);
8
9
    users.forEach(System.out::println);
10
}

注意：map中的key对应的是数据库中的列名。例如数据库user_id，实体类是userId，这时map的key需要填写user_id

4、分页

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

（1）创建配置类

此时可以删除主类中的 @MapperScan扫描注解


/**
2
 * 分页插件
3
 */
4
@Bean
5
public PaginationInterceptor paginationInterceptor() {
6
    return new PaginationInterceptor();
7
}

（2）测试selectPage分页

测试：最终通过page对象获取相关数据

@Test
2
public void testSelectPage() {
3
4
    Page<User> page = new Page<>(1,5);
5
    userMapper.selectPage(page, null);
6
7
    page.getRecords().forEach(System.out::println);
8
    System.out.println(page.getCurrent());
9
    System.out.println(page.getPages());
10
    System.out.println(page.getSize());
11
    System.out.println(page.getTotal());
12
    System.out.println(page.hasNext());
13
    System.out.println(page.hasPrevious());
14
}

控制台sql语句打印：SELECT id,name,age,email,create_time,update_time FROM user LIMIT 0,5

（3）测试selectMapsPage分页：结果集是Map

@Test
2
public void testSelectMapsPage() {
3
4
    Page<User> page = new Page<>(1, 5);
5
6
    IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);
7
8
    //注意：此行必须使用 mapIPage 获取记录列表，否则会有数据类型转换错误
9
    mapIPage.getRecords().forEach(System.out::println);
10
    System.out.println(page.getCurrent());
11
    System.out.println(page.getPages());
12
    System.out.println(page.getSize());
13
    System.out.println(page.getTotal());
14
    System.out.println(page.hasNext());
15
    System.out.println(page.hasPrevious());
16
}

四、delete

1、根据id删除记录

@Test
2
public void testDeleteById(){
3
4
    int result = userMapper.deleteById(8L);
5
    System.out.println(result);
6
}

2、批量删除

 @Test
2
    public void testDeleteBatchIds() {
3
4
        int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
5
        System.out.println(result);
6
    }

3、简单的条件查询删除

@Test
2
public void testDeleteByMap() {
3
4
    HashMap<String, Object> map = new HashMap<>();
5
    map.put("name", "Helen");
6
    map.put("age", 18);
7
8
    int result = userMapper.deleteByMap(map);
9
    System.out.println(result);
10
}

4、逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

（1）数据库中添加 deleted字段

ALTER TABLE `user` ADD COLUMN `deleted` boolean

（2）实体类添加deleted *字段*

并加上 @TableLogic 注解和 @TableField(fill = FieldFill.INSERT) 注解


@TableLogic
2
@TableField(fill = FieldFill.INSERT)
3
private Integer deleted;

（3）元对象处理器接口添加deleted的insert默认值

1
@Override
2
public void insertFill(MetaObject metaObject) {
3
    ......
4
    this.setFieldValByName("deleted", 0, metaObject);
5
}

（4）application.properties 加入配置

此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
2
mybatis-plus.global-config.db-config.logic-not-delete-value=0

（5）在 MybatisPlusConfig 中注册 Bean

@Bean
2
public ISqlInjector sqlInjector() {
3
    return new LogicSqlInjector();
4
}

（6）测试逻辑删除

测试后发现，数据并没有被删除，deleted字段的值由0变成了1
测试后分析打印的sql语句，是一条update
注意：被删除数据的deleted 字段的值必须是 0，才能被选取出来执行逻辑删除的操作

/**
2
 * 测试 逻辑删除
3
 */
4
@Test
5
public void testLogicDelete() {
6
7
    int result = userMapper.deleteById(1L);
8
    System.out.println(result);
9
}

（7）测试逻辑删除后的查询

MyBatis Plus中查询操作也会自动添加逻辑删除字段的判断

/**
2
 * 测试 逻辑删除后的查询：
3
 * 不包括被逻辑删除的记录
4
 */
5
@Test
6
public void testLogicDeleteSelect() {
7
    User user = new User();
8
    List<User> users = userMapper.selectList(null);
9
    users.forEach(System.out::println);
10
}

测试后分析打印的sql语句，包含 WHERE deleted=0

SELECT id,name,age,email,create_time,update_time,deleted FROM user WHERE deleted=0

五、性能分析

性能分析拦截器，用于输出每条 SQL 语句及其执行时间

SQL 性能执行分析,开发环境使用，超过指定时间，停止运行。有助于发现问题

1、配置插件

（1）参数说明

参数：maxTime： SQL 执行最大时长，超过自动停止运行，有助于发现问题。

参数：format： SQL是否格式化，默认false。

（2）在 MybatisPlusConfig 中配置

/**
2
 * SQL 执行性能分析插件
3
 * 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
4
 */
5
@Bean
6
@Profile({"dev","test"})// 设置 dev test 环境开启
7
public PerformanceInterceptor performanceInterceptor() {
8
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
9
    performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
10
    performanceInterceptor.setFormat(true);
11
    return performanceInterceptor;
12
}

（3）Spring Boot 中设置dev环境

#环境设置：dev、test、prod
2
spring.profiles.active=dev

可以针对各环境新建不同的配置文件application-dev.properties、application-test.properties、application-prod.properties

也可以自定义环境名称：如test1、test2

2、测试

（1）常规测试

/**
2
 * 测试 性能分析插件
3
 */
4
@Test
5
public void testPerformance() {
6
    User user = new User();
7
    user.setName("我是Helen");
8
    user.setEmail("helen@sina.com");
9
    user.setAge(18);
10
    userMapper.insert(user);
11
}

输出：

（2）将maxTime 改小之后再次进行测试

1
performanceInterceptor.setMaxTime(5);//ms，超过此处设置的ms不执行

如果执行时间过长，则抛出异常：The SQL execution time is too large,

输出：

六、其它

如果想进行复杂条件查询，那么需要使用条件构造器 Wapper，涉及到如下方法

1、delete

2、selectOne

3、selectCount

4、selectList

5、selectMaps

6、selectObjs

7、update

一、wapper介绍

Wrapper ：条件构造抽象类，最顶端父类

AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件

QueryWrapper ： Entity 对象封装操作类，不是用lambda语法

UpdateWrapper ： Update 条件封装，用于Entity对象更新操作

AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。

LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper

LambdaUpdateWrapper ： Lambda 更新封装Wrapper


@RunWith(SpringRunner.class)
2
@SpringBootTest
3
public class QueryWrapperTests {
4
    
5
    @Autowired
6
    private UserMapper userMapper;
7
}

二、AbstractWrapper

注意：以下条件构造器的方法入参中的column均表示数据库字段

1、ge、gt、le、lt、isNull、isNotNull

@Test
2
public void testDelete() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper
6
        .isNull("name")
7
        .ge("age", 12)
8
        .isNotNull("email");
9
    int result = userMapper.delete(queryWrapper);
10
    System.out.println("delete return count = " + result);
11
}

SQL：UPDATE user SET deleted=1 其中 deleted=0 AND name IS NULL AND age >= ？并且电子邮件不为空

2、eq、ne

注意：seletOne返回的是一条实体记录，当出现多条时会报错

@Test
2
public void testSelectOne() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper.eq("name", "Tom");
6
7
    User user = userMapper.selectOne(queryWrapper);
8
    System.out.println(user);
9
}

选择 id，name，age，email，create_time，update_time，deleted，version FROM user WHERE deleted=0 AND name = ？

3、之间、不之间

包含大小边界


@Test
2
public void testSelectCount() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper.between("age", 20, 30);
6
7
    Integer count = userMapper.selectCount(queryWrapper);
8
    System.out.println(count);
9
}

从用户中选择 COUNT（1），其中 deleted=0 且 age 介于？和？

4、全方程

@Test
2
public void testSelectList() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    Map<String, Object> map = new HashMap<>();
6
    map.put("id", 2);
7
    map.put("name", "Jack");
8
    map.put("age", 20);
9
10
    queryWrapper.allEq(map);
11
    List<User> users = userMapper.selectList(queryWrapper);
12
13
    users.forEach(System.out::println);
14
}

选择 ID，名称，年龄，电子邮件，create_time，update_time，已删除，版本

FROM user where deleted=0 AND name = ？AND id = ？AND 年龄 = ？

5、like、notLike、likeLeft、likeRight

selectMaps返回Map集合列表

@Test
2
public void testSelectMaps() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper
6
        .notLike("name", "e")
7
        .likeRight("email", "t");
8
9
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
10
    maps.forEach(System.out::println);
11
}

选择 ID，名称，年龄，电子邮件，create_time，update_time，已删除，版本

FROM user where deleted=0 AND name NOT LIKE ？并发送电子邮件赞？

6、in、notIn、inSql、notinSql、exists、notExists

in、notIn 中：

notIn("age",{1,2,3})--->age not in (1,2,3)
notIn("age", 1, 2, 3)--->age not in (1,2,3)

inSql、notinSql：可以实现子查询

例: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)


@Test
2
public void testSelectObjs() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    //queryWrapper.in("id", 1, 2, 3);
6
    queryWrapper.inSql("id", "select id from user where id < 3");
7
8
    List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
9
    objects.forEach(System.out::println);
10
}

选择 ID，名称，年龄，电子邮件，create_time，update_time，已删除，版本

FROM user where deleted=0 AND id IN（从 id < 3 的用户中选择 id）

7、or、和

注意：这里使用的是 UpdateWrapper

不调用或则默认为使用 和 连

@Test
2
public void testUpdate1() {
3
4
    //修改值
5
    User user = new User();
6
    user.setAge(99);
7
    user.setName("Andy");
8
9
    //修改条件
10
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
11
    userUpdateWrapper
12
        .like("name", "h")
13
        .or()
14
        .between("age", 20, 30);
15
16
    int result = userMapper.update(user, userUpdateWrapper);
17
18
    System.out.println(result);
19
}

UPDATE user SET name=？， age=？， update_time=？其中 deleted=0 且名称为 LIKE ？或者年龄介于？和？

8、嵌套or、嵌套和

这里使用了lambda表达式，or中的表达式最后翻译成sql时会被加上圆括号

@Test
2
public void testUpdate2() {
3
4
5
    //修改值
6
    User user = new User();
7
    user.setAge(99);
8
    user.setName("Andy");
9
10
    //修改条件
11
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
12
    userUpdateWrapper
13
        .like("name", "h")
14
        .or(i -> i.eq("name", "李白").ne("age", 20));
15
16
    int result = userMapper.update(user, userUpdateWrapper);
17
18
    System.out.println(result);
19
}

UPDATE user SET name=？， age=？， update_time=？

其中 deleted=0 且名称为 LIKE ？

OR （ name = ？年龄 <> ？)

9、orderBy、orderByDesc、orderByAsc

@Test
2
public void testSelectListOrderBy() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper.orderByDesc("id");
6
7
    List<User> users = userMapper.selectList(queryWrapper);
8
    users.forEach(System.out::println);
9
}

选择 ID，名称，年龄，电子邮件，create_time，update_time，已删除，版本

FROM user WHERE deleted=0 按 ID DESC 订购

10、尾

直接拼接到 sql 的最后

注意：只能调用一次，多次调用以最后一次为准有sql注入的风险，请谨慎使用

@Test
2
public void testSelectListLast() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper.last("limit 1");
6
7
    List<User> users = userMapper.selectList(queryWrapper);
8
    users.forEach(System.out::println);
9
}

选择 ID，名称，年龄，电子邮件，create_time，update_time，已删除，版本

FROM user WHERE deleted=0 限制 1

11、指定要查询的列

@Test
2
public void testSelectListColumn() {
3
4
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
5
    queryWrapper.select("id", "name", "age");
6
7
    List<User> users = userMapper.selectList(queryWrapper);
8
    users.forEach(System.out::println);
9
}

选择 id，name，age FROM user WHERE deleted=0

12、set、setSql

最终的sql会合并 user.setAge（），以及 userUpdateWrapper.set（）和 setSql（）中的字段

@Test
2
public void testUpdateSet() {
3
4
    //修改值
5
    User user = new User();
6
    user.setAge(99);
7
8
    //修改条件
9
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
10
    userUpdateWrapper
11
        .like("name", "h")
12
        .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
13
        .setSql(" email = '123@qq.com'");//可以有子查询
14
15
    int result = userMapper.update(user, userUpdateWrapper);
16
}

更新用户 set age=？， update_time=？， name=？， email = '123@qq.com' 其中 deleted=0 和 name LIKE ？

posted @ 2025-05-17 15:06 autumnmoonming 阅读(47) 评论(0) 收藏举报

刷新页面返回顶部

autumnmoonming

2 MyBatisPlus入门

一、简介

二、特性

一、创建并初始化数据库

1、创建数据库：

2、创建User表

二、初始化工程

三、添加依赖

1、引入依赖

2、idea中安装lombok插件

四、配置

五、编写代码

1、主类

2、实体

3、mapper

六、开始使用

七、配置日志

一、insert

1、插入操作

2、主键策略

二、update

1、根据Id更新操作

2、自动填充

3、乐观锁

三、select

1、根据id查询记录

2、通过多个id批量查询

3、简单的条件查询

4、分页

四、delete

1、根据id删除记录

2、批量删除

3、简单的条件查询删除

4、逻辑删除

五、性能分析

1、配置插件

2、测试

六、其它

一、wapper介绍

二、AbstractWrapper

1、ge、gt、le、lt、isNull、isNotNull

2、eq、ne

3、之间、不之间

4、全方程

5、like、notLike、likeLeft、likeRight

6、in、notIn、inSql、notinSql、exists、notExists

7、or、和

8、嵌套or、嵌套和

9、orderBy、orderByDesc、orderByAsc

10、尾

11、指定要查询的列

12、set、setSql

公告

2、创建`User`表