MyBatis-Plus 笔记

最新推荐文章于 2024-06-26 18:01:24 发布
最新推荐文章于 2024-06-26 18:01:24 发布
阅读量529 收藏 2
点赞数
分类专栏： 2、微服务核心 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mark42/article/details/121260103
版权
本文介绍了MyBatis-Plus的入门步骤，包括创建数据库、初始化SpringBoot工程、配置数据库、编写实体类和Mapper接口。重点讲解了MyBatis-Plus的主键策略、自动填充、乐观锁以及分页查询等功能，同时探讨了数据库分库分表的策略和解决方案。此外，还展示了如何使用条件构造器进行各种查询操作。
摘要由CSDN通过智能技术生成

MyBatis-Plus

1、MyBatis-Plus 入门

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

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

（一）简介

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

  • 润物无声

    • 只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。

  • 效率至上

    • 只需简单配置，即可快速进行 CRUD 操作，从而节省大量时间。

  • 丰富功能

    • 热加载、代码生成、分页、性能分析等功能一应俱全。

（二）创建并初始化数

（1）创建数据库

mybatis_plus

image-20211109111347906

utf8mb4 是 mysql 为了掩饰自己的尴尬所搞出来的一个字符集格式，它可以存放特殊字符，比如说微信中的特殊表情

（2）创建 User 表

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

CREATE TABLE user
(
	id BIGINT(20) 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 '邮箱',
	PRIMARY KEY (id)
);

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

INSERT INTO user (id, name, age, email) VALUES
(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');

（三）确认idea配置

（1）打开配置
image-20211109140654613 image-20211109140707043
（2）Java编译器
image-20211109140810134
（3）项目和文件的编码
image-20211109140907406
（4）Maven配置

自己的 Maven 地址

image-20211109141042610

（四）创建项目

（1）初始化工程

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

Group：com.atguigu

Artifact：mybatis-plus

版本：2.2.1.RELEASE

image-20211109142445899 image-20211109142735654

image-20211109143710417

（2）引入依赖

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.3.1</version>
    </dependency>

    <!--mysql运行时依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!--lombok用来简化实体类-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>
（3）idea中安装lombok插件

**（五）编写代码 **

（1）配置

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

spring boot 2.1及以上（内置jdbc8驱动）

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

注意：

1、这里的 url 使用了 ?serverTimezone=GMT%2B8 后缀，因为8.0版本的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 中 使用这个驱动

如果使用jdbc5驱动

**注意：**driver 和 url 的变化 com.mysql.cj.jdbc.Driver 中的 cj 去掉了

#mysql数据库连接
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
（2）启动类

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

@SpringBootApplication
@MapperScan("com.atguigu.mybatisplus.mapper")
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}
（3）添加实体

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

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

查看编译结果

image-20211109150607151
（4）添加mapper

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

public interface UserMapper extends BaseMapper<User> {
    
}

BaseMapper：

image-20211109150839972
（5）查看sql输出日志
#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
（6）测试

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

package com.atguigu.mybatisplus;
@SpringBootTest
class MybatisPlusApplicationTests {
    @Autowired
    private UserMapper userMapper;
    @Test
    void testSelectList() {
        //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
        //所以不填写就是无任何条件
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

注意：

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

image-20211109152658469

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

@Repository
// @Component
// @Service
public interface UserMapper extends BaseMapper<User> {

}

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

查看控制台输出：

image-20211109152812879

2、CRUD接口-主键策略

（一）插入操作

@SpringBootTest
public class CRUDTests {  
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert(){
        User user = new User();
        user.setName("Helen");
        user.setAge(18);
        user.setEmail("55317332@qq.com");
        int result = userMapper.insert(user);
        System.out.println("影响的行数：" + result); //影响的行数
        System.out.println("id：" + user); //id自动回填
    }
}

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

image-20211109153538597

（二）数据库分库分表策略

背景

随着业务规模的不断扩大，需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。

数据库的扩展方式主要包括：业务分库、主从复制，数据库分表。

（1）业务分库

业务分库指的是按照业务模块将数据分散到不同的数据库服务器。例如，一个简单的电商网站，包括用户、商品、订单三个业务模块，我们可以将用户数据、商品数据、订单数据分开放到三台不同的数据库服务器上，而不是将所有数据都放在一台数据库服务器上。这样就变成了3个数据库同时承担压力，系统的吞吐量自然就提高了。

img

虽然业务分库能够分散存储和访问压力，但同时也带来了新的问题，接下来我们进行详细分析。

  • join 操作问题

    • 业务分库后，原本在同一个数据库中的表分散到不同数据库中，导致无法使用 SQL 的 join 查询。

  • 事务问题

    • 原本在同一个数据库中不同的表可以在同一个事务中修改，业务分库后，表分散到不同的数据库中，无法通过事务统一修改。

  • 成本问题

    • 业务分库同时也带来了成本的代价，本来 1 台服务器搞定的事情，现在要 3 台，如果考虑备份，那就是3台变成了 6 台。
（2）主从复制和读写分离

读写分离的基本原理是将数据库读写操作分散到不同的节点上。读写分离的基本实现是：

  • 数据库服务器搭建主从集群，一主一从、一主多从都可以。
  • 数据库主机负责读写操作，从机只负责读操作。
  • 数据库主机通过复制将数据同步到从机，每台数据库服务器都存储了所有的业务数据。
  • 业务服务器将写操作发给数据库主机，将读操作发给数据库从机。

img

需要注意的是，这里用的是“主从集群”，而不是“主备集群”。“从机”的“从”可以理解为“仆从”，仆从是要帮主人干活的，“从机”是需要提供读数据的功能的；而“备机”一般被认为仅仅提供备份功能，不提供访问功能。所以使用“主从”还是“主备”，是要看场景的，这两个词并不是完全等同。

（3）数据库分表

将不同业务数据分散存储到不同的数据库服务器，能够支撑百万甚至千万用户规模的业务，但如果业务继续发展，同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如，淘宝的几亿用户数据，如果全部存放在一台数据库服务器的一张表中，肯定是无法满足性能要求的，此时就需要对单表数据进行拆分。

单表数据拆分有两种方式：垂直分表和水平分表。示意图如下：

img

单表进行切分后，是否要将切分后的多个表分散在不同的数据库服务器中，可以根据实际的切分效果来确定。如果性能能够满足业务要求，是可以不拆分到多台数据库服务器的，毕竟我们在上面业务分库的内容看到业务分库也会引入很多复杂性的问题。分表能够有效地分散存储压力和带来性能提升，但和分库一样，也会引入各种复杂性：

垂直分表：

  • 垂直分表适合将表中某些不常用且占了大量空间的列拆分出去。
  • 例如，前面示意图中的 nickname 和 description 字段，假设我们是一个婚恋网站，用户在筛选其他用户的时候，主要是用 age 和 sex 两个字段进行查询，而 nickname 和 description 两个字段主要用于展示，一般不会在业务查询中用到。description 本身又比较长，因此我们可以将这两个字段独立到另外一张表中，这样在查询 age 和 sex 时，就能带来一定的性能提升。

水平分表：

  • 水平分表适合表行数特别大的表，有的公司要求单表行数超过 1000 万就必须进行分表，这个数字可以作为参考，但并不是绝对标准，关键还是要看表的访问性能。对于一些比较复杂的表，可能超过 500 万就要分表了；而对于一些简单的表，即使存储数据超过 1 亿行，也可以不分表。
  • 但不管怎样，当看到表的数据量达到千万级别时，作为架构师就要警觉起来，因为这很可能是架构的性能瓶颈或者隐患。

水平分表相比垂直分表，会引入更多的复杂性，例如数据id：

主键自增：

  • 以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，1000000 ~ 1999999 放到表2中，以此类推。
  • 复杂点：分段大小的选取。分段太小会导致切分后子表数量过多，增加维护复杂度；分段太大可能会导致单表依然存在性能问题，一般建议分段大小在 100 万至 2000 万之间，具体需要根据业务选取合适的分段大小。
  • 优点：可以随着数据的增加平滑地扩充新的表。例如，现在的用户是 100 万，如果增加到 1000 万，只需要增加新的表就可以了，原有的数据不需要动。
  • 缺点：分布不均匀，假如按照 1000 万来进行分表，有可能某个分段实际存储的数据量只有 1000 条，而另外一个分段实际存储的数据量有 900 万条。

Hash ：

  • 同样以用户 ID 为例，假如我们一开始就规划了 10 个数据库表，路由算法可以简单地用 user_id % 10 的值来表示数据所属的数据库表编号，ID 为 985 的用户放到编号为 5 的子表中，ID 为 10086 的用户放到编号为 6 的字表中。
  • 复杂点：初始表数量的选取。表数量太多维护比较麻烦，表数量太少又可能导致单表性能存在问题。
  • 优点：表分布比较均匀。
  • 缺点：扩充新的表很麻烦，所有数据都要重分布。

分布式ID生成器之*雪花算法：snowflake*

雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。

  • 核心思想：

    • 长度共64bit（一个long型）。
    • 首先是一个符号位，1bit标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0。
    • 41bit时间截(毫秒级)，存储的是时间截的差值（当前时间截 - 开始时间截)，结果约等于69.73年。
    • 10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID，可以部署在1024个节点）。
    • 12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID）。

img

  • 优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高。

（三）MP的主键策略

【面试题】常见的主键生成策略

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

6 主键生成策略

（1）ASSIGN_ID

MyBatis-Plus默认的主键策略是：ASSIGN_ID （使用了雪花算法）

@TableId(type = IdType.ASSIGN_ID)
private String id;
（2）AUTO 自增策略

① 需要在创建数据表的时候设置主键自增

image-20211109160241134

② 实体字段中配置 @TableId(type = IdType.AUTO)

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

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

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

3、CRUD接口-自动填充和乐观锁

（一）更新操作

@Test
public void testUpdateById(){  
    User user = new User();
    user.setId(1L);
    user.setAge(28);
    //注意：update时生成的sql自动是动态sql：UPDATE user SET age=? WHERE id=? 
    int result = userMapper.updateById(user);
    System.out.println("影响的行数：" + result);
}

（二）自动填充

需求描述：

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。我们可以使用 MyBatis Plus 的自动填充功能，完成这些字段的赋值工作。

（1）数据库修改

参考阿里规范手册，在 User 表中添加 datetime 类型的新的字段创建时间 gmt_create、修改时间 gmt_modified

image-20211109162957847
（2）实体类修改

实体上增加字段并添加自动填充注解

@Data
public class User {
    ......
        
    @TableField(fill = FieldFill.INSERT)
    private Date gmtCreate;
    //@TableField(fill = FieldFill.UPDATE)
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date gmtModified;
}

我们也可以自动填充而不是通过手动 user.setGmtCreate(new Date()); 或者 user.setGmtModified(new Date()); 的方式，这就需要实现元对象处理器接口了

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

注意：不要忘记添加 @Component 注解（或者@Service，@Repository）

package com.atguigu.mybatisplus.handler;
@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    // 使用mp实现添加操作，这个方法执行
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.setFieldValByName("gmtCreate", new Date(), metaObject);
        this.setFieldValByName("gmtModified", new Date(), metaObject);
    }
    
    // 使用mp实现修改操作，这个方法执行
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.setFieldValByName("gmtModified", new Date(), metaObject);
    }
}
（4）测试

（三）乐观锁

（1）场景

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。

此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。

现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多。

（2）乐观锁与悲观锁
  • 上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出被修改后的价格150元，这样他会将120元存入数据库。
  • 如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元。

接下来将我们演示这一过程

（3）模拟并发修改冲突
① 数据库中增加商品表
CREATE TABLE product
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
    price INT(11) DEFAULT 0 COMMENT '价格',
    version INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
    PRIMARY KEY (id)
);
② 添加数据
INSERT INTO product (id, NAME, price) VALUES (1, '外星人笔记本', 100);
③ 实体类
package com.atguigu.mybatisplus.entity;
@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;
}
④ Mapper
package com.atguigu.mybatisplus.mapper;
@Repository
public interface ProductMapper extends BaseMapper<Product> {
    
}
⑤ 测试
@Autowired
private ProductMapper productMapper;
@Test
public void testConcurrentUpdate() {
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格：" + p1.getPrice());
    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格：" + p2.getPrice());
    //3、小李将价格加了50元，存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    productMapper.updateById(p1);
    //4、小王将商品减了30元，存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    int result = productMapper.updateById(p2);
    if(result == 0){//更新失败，重试
        //重新获取数据
        p2 = productMapper.selectById(1L);
        //更新
        p2.setPrice(p2.getPrice() - 30);
        productMapper.updateById(p2);
    }
    //最后的结果
    Product p3 = productMapper.selectById(1L);
    System.out.println("最后的结果：" + p3.getPrice());
}
（4）解决方案

数据库中添加version字段，取出记录时，获取当前version

SELECT id,`name`,price,`version` FROM product WHERE id=1

更新时，version + 1，如果where语句中的version版本不对，则更新失败

UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1

接下来介绍如何在Mybatis-Plus项目中，使用乐观锁：

（5）乐观锁实现流程
① 修改实体类

在version上添加 @Version 注解

@Version
private Integer version;
② 创建配置文件

创建包 config，创建文件 MybatisPlusConfig.java 配置类

此时可以删除主类中的 @MapperScan 扫描注解，把扫描包的 MapperScan 注解写到配置类中

package com.atguigu.mybatisplus.config;
@EnableTransactionManagement //事务管理
@Configuration //表示这是一个配置类
@MapperScan("com.atguigu.mybatisplus.mapper")
public class MybatisPlusConfig {
    
}
**③ **注册乐观锁插件

在 MybatisPlusConfig 中注册 Bean

/**
  * 乐观锁插件
  */
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    return new OptimisticLockerInterceptor();
}
④ 测试

4、CRUD接口-查询和分页

（一）查询

（1）通过多个id批量查询

完成了动态sql的 foreach 的功能

@Test
public void testSelectBatchIds(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}
（2）简单的条件查询

通过map封装查询条件

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

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

（二）分页

（1）分页插件

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

**① **添加分页插件

配置类中添加@Bean配置

/**
 * 分页插件
 */
@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}
② 测试selectPage分页

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

@Test
public void testSelectPage() {
    // 1、创建page对象
    // 传入两个参数：当前页 和 每页显示记录数
    Page<User> page = new Page<>(1,5);
    // 调用mp分页查询的方法
    // 调用mp分页查询过程中，底层封装
    // 把分页所有的数据封装到page对象里面
    Page<User> pageParam = userMapper.selectPage(page, null);
    
    // 通过page对象获取分页数据
    pageParam.getRecords().forEach(System.out::println);
    System.out.println(pageParam.getRecord());// 每页数据List集合
    System.out.println(pageParam.getCurrent());//当前页
    System.out.println(pageParam.getPages());// 总页数
    System.out.println(pageParam.getSize());// 每页显示记录数
    System.out.println(pageParam.getTotal());// 总记录数
    System.out.println(pageParam.hasNext());// 下一页
    System.out.println(pageParam.hasPrevious());// 上一页
}

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

注意点：page 和 pageParam 是一个东西

image-20211110003458430

（2）返回指定的列

当指定了特定的查询列时，希望分页结果列表只返回被查询的列，而不是很多null值

    /**
     * selectPage 测试2
     */
    @Test
    void selectPageTest2() {
        Page<User> page = new Page<>(1, 5);

        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.select("name","age","email");

        userMapper.selectPage(page,userQueryWrapper);

        List<User> records = page.getRecords();
        records.forEach(System.out::println);
    }

我们发现 SQL 语句是我们想要的，但是打印出来的结果却不是我们想要的，这个时候就要用 selectMapsPage

image-20211110002255528

测试selectMapsPage分页：结果集是Map

BaseMapper 的 selectMapsPage 方法：

image-20211110002741399

@Test
public void testSelectMapsPage() {
    Page<Map<String, Object>> page = new Page<>(1, 5);
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    Page<Map<String, Object>> pageParam = userMapper.selectMapsPage(page, queryWrapper);
    List<Map<String, Object>> records = pageParam.getRecords();
    records.forEach(System.out::println);
    System.out.println(pageParam.getCurrent());
    System.out.println(pageParam.getPages());
    System.out.println(pageParam.getSize());
    System.out.println(pageParam.getTotal());
    System.out.println(pageParam.hasNext());
    System.out.println(pageParam.hasPrevious());
}

效果达成

image-20211110003716460

5、CRUD接口-删除和逻辑删除

（一）删除

（1）根据id删除记录
@Test
public void testDeleteById(){
    int result = userMapper.deleteById(5L);
    System.out.println(result);
}
（2）批量删除
@Test
public void testDeleteBatchIds() {
    int result = userMapper.deleteBatchIds(Arrays.asList(8, 9, 10));
    System.out.println(result);
}
（3）简单条件删除
@Test
public void testDeleteByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Helen");
    map.put("age", 18);
    int result = userMapper.deleteByMap(map);
    System.out.println(result);
}

（二）逻辑删除

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

逻辑删除的使用场景：

  • 可以进行数据恢复

  • 有关联数据，不便删除

（2）逻辑删除实现流程
① 修改

添加 deleted字段

ALTER TABLE `user` ADD COLUMN `deleted` boolean DEFAULT false
② 实体类修改

添加deleted 字段，并加上 @TableLogic 注解

@TableLogic
private Integer deleted;
③ 配置（可选）

application.properties 加入以下配置，此为默认值，如果你的默认值和 mp 默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0
④ 测试
  • 测试后发现，数据并没有被删除，deleted字段的值由0变成了1
  • 测试后分析打印的sql语句，是一条update
  • **注意：**被删除前，数据的deleted 字段的值必须是 0，才能被选取出来执行逻辑删除的操作
@Test
public void testLogicDelete() {
    int result = userMapper.deleteById(1L);
    System.out.println(result);
}

image-20211110004822521

⑤ 逻辑删除后的查询

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

@Test
public void testLogicDeleteSelect() {
    
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}

此时查询不到已经逻辑删除的信息了

6、条件构造器和常用接口

（一）wapper介绍

image-20211110005434087

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

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

​ QueryWrapper ： 查询条件封装

​ UpdateWrapper ： Update 条件封装

​ AbstractLambdaWrapper ： 使用Lambda 语法

​ LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper

​ LambdaUpdateWrapper ： Lambda 更新封装Wrapper

@SpringBootTest
public class QueryWrapperTests {
    
    @Autowired
    private UserMapper userMapper;
}

（二）测试用例

（1）ge、gt、le、lt、isNull、isNotNull
@Test
public void testDelete() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .isNull("name")
        .ge("age", 12)
        .isNotNull("email");
    int result = userMapper.delete(queryWrapper);
    System.out.println("delete return count = " + result);
}
（2）eq、ne

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

@Test
public void testSelectOne() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "Tom");
    User user = userMapper.selectOne(queryWrapper);//只能返回一条记录，多于一条则抛出异常
    System.out.println(user);
}
（3）between、notBetween

包含大小边界

@Test
public void testSelectCount() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age", 20, 30);
    Integer count = userMapper.selectCount(queryWrapper); //返回数据数量
    System.out.println(count);
}
（4）like、notLike、likeLeft、likeRight

selectMaps()返回Map集合列表，通常配合select()使用

@Test
public void testSelectMaps() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .select("name", "age")
        .like("name", "e")
        .likeRight("email", "5");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
    maps.forEach(System.out::println);
}
（5）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
    public void testSelectObjs() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //queryWrapper.in("id", 1, 2, 3);
        queryWrapper.inSql("id", "select id from user where id <= 3");
        List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
        objects.forEach(System.out::println);
    }
（6）orderBy、orderByDesc、orderByAsc
@Test
public void testSelectListOrderBy() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("age", "id");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}
（7）or、and

不调用or则默认为使用 and连

@Test
public void testUpdateOr() {
    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
    //修改条件
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .like("name", "h")
        .or()
        .between("age", 20, 30);
    int result = userMapper.update(user, queryWrapper);
    System.out.println(result);
}
（8）lambda表达式

lambda表达式内的逻辑优先运算

@Test
public void testUpdateLambda() {
    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
    //修改条件
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .like("name", "n")
        .or(i -> i.like("name", "a").eq("age", 20));
    int result = userMapper.update(user, queryWrapper);
    System.out.println(result);
}
（9）set、setSql

**注意：**这里使用的是 UpdateWrapper

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

@Test
public void testUpdateSet() {
    //修改值
    User user = new User();
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .set("name", "Peter")//可以使用set设置修改的字段
        .set("age", 60)
        .setSql(" email = '123@qq.com'")//可以有子查询
        .like("name", "h");
    int result = userMapper.update(user, userUpdateWrapper);
    System.out.println(result);
}
（10）不同的写法

查询名字中包含n，且（年龄小于18或email为空的用户），并将这些用户的年龄设置为18，邮箱设置为 user@atguigu.com

  • QueryWrapper
@Test
public void test4() {
    //修改条件
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .like("name", "n")
        .and(i -> i.lt("age", 18).or().isNull("email")); //lambda表达式内的逻辑优先运算
    User user = new User();
    user.setAge(18);
    user.setEmail("user@atguigu.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println(result);
}
  • LambdaUpdateWrapper
@Test
public void test10() {
    //组装set子句
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper
        .set(User::getAge, 18)
        .set(User::getEmail, "user@atguigu.com")
        .like(User::getName, "n")
        .and(i -> i.lt(User::getAge, 18).or().isNull(User::getEmail)); //lambda表达式内的逻辑优先运算
    
    User user = new User();
    int result = userMapper.update(user, updateWrapper);
    System.out.println(result);
}

（三）查询方式

查询方式说明
setSqlSelect设置 SELECT 查询字段
whereWHERE 语句，拼接 + WHERE 条件
andAND 语句，拼接 + AND 字段=值
andNewAND 语句，拼接 + AND (字段=值)
orOR 语句，拼接 + OR 字段=值
orNewOR 语句，拼接 + OR (字段=值)
eq等于=
allEq基于 map 内容等于=
ne不等于<>
gt大于>
ge大于等于>=
lt小于<
le小于等于<=
like模糊查询 LIKE
notLike模糊查询 NOT LIKE
inIN 查询
notInNOT IN 查询
isNullNULL 值查询
isNotNullIS NOT NULL
groupBy分组 GROUP BY
havingHAVING 关键词
orderBy排序 ORDER BY
orderAscASC 排序 ORDER BY
orderDescDESC 排序 ORDER BY
existsEXISTS 条件语句
notExistsNOT EXISTS 条件语句
betweenBETWEEN 条件语句
notBetweenNOT BETWEEN 条件语句
addFilter自由拼接 SQL
last拼接在最后，例如：last(“LIMIT 1”)
yfstart
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql 无法存储表情 Linux mysql 无法存储表情 spring boot mybatis 存储表情到数据库
yu1xue1fei的博客
07-07 204
目录 1.Linux mysql 设置 1.1修改配置文件如下在 vim /etc/my.cnf 1.2重启mysql服务 2.设置数据局连接我这里是yml 3.设置DruidConfig配置文件 1.Linux mysql 设置 1.1修改配置文件如下在 vim /etc/my.cnf [client] default-character-set=utf8mb4 [mysql] default-character-set=utf8...
SpringBoot+MyBatisPlus+MySQL不能储存（保存）emoji表情问题解决
m0_59799878的博客
09-18 1123
1.之前在学习过程中不知道utf8和utf8mb4的区别，也没过多去了解，直到最近设置的数据库编码全是utf8后发现问题所在了，居然不能储存表情包！整个人直接傻了，后面知道了utf8是3字节不能储存表情，utf8mb4才可以，废话不多说马上整改，接下来的一幕就令人头疼了。心态再次崩，一直找了很多文章在修复，后来自己发现，数据库和表虽然改了字符集，那么字段（列属性）呢？这一波我真的无语了，改了表的字符集，字段居然没有跟着改，这里用命令更改,如下。好了，我以为这样就好了，结果还是报错了，如下。
QueryWrapper 大于，小于等详细记录 方法解释
最新发布
qq_27246521的博客
06-26 2683
queryWrapper.likeLeft（“属性”,“值”）——模糊查询匹配最后一位值‘%值’queryWrapper.likeRight（“属性”,“值”）——模糊查询匹配第一位值‘值%’queryWrapper.notLike（“属性”,“值”）——模糊查询不匹配值‘%值%’queryWrapper.like（“属性”,“值”）——模糊查询匹配值‘%值%’queryWrapper.in（“属性”，条件，条件 ）——符合多个条件的值。queryWrapper.le（）——小于等于。
MyBatisPlus条件构造器 — QueryWrapper、LambdaQueryWrapper
weixin_49455343的博客
07-20 3269
MyBatisPlus条件构造器 — QueryWrapper、LambdaQueryWrapper
​​​​​​​lambdaQueryWrapper模糊查询like方法
热门推荐
qq_44764295的博客
08-26 1万+
​​​​​​​lambdaQueryWrapper模糊查询
Mybatis+MySql 保存emoji表情
南极亚拉的博客
08-16 3929
现象： 当通过微信拿到用户的个人信息后保存用户带有表情的昵称时服务抛出了异常。 ### Error updating database. Cause: java.sql.SQLException: Incorrect string value: '\xF0\x9F\x92\xAB' for column 'nickname' at row 1 原因： 数据库设置的字符格式（utf-8）...
MyBatis-Plus 学习笔记.pdf
08-30
MyBatis-Plus 学习笔记 MyBatis-Plus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、...
mybatis-plus学习项目笔记
07-07
在这个"mybatis-plus学习项目笔记"中，我们可以深入探讨MyBatis-Plus的核心特性，以及如何在实际开发中有效地使用它。 1. **MyBatis-Plus简介** MyBatis-Plus是基于MyBatis框架的增强工具，它在MyBatis的基础上做...
【Mybatis-Plus学习笔记二】——Mybatis-Plus进阶使用.zip
06-09
【Mybatis-Plus学习笔记二】——Mybatis-Plus进阶使用.zip 博客地址：https://blog.csdn.net/weixin_43817709/article/details/117751784
【Mybatis-Plus学习笔记一】——Mybatis-Plus快速使用.zip
06-08
【Mybatis-Plus学习笔记一】——Mybatis-Plus快速使用.zip 博客地址：https://blog.csdn.net/weixin_43817709/article/details/117717192
整合mybatis-plus代码生成器.zip
07-16
MyBatis-Plus是一个强大的扩展库，它是MyBatis的简化版，提供了许多方便实用的功能，包括自动代码生成器。这个"整合mybatis-plus代码生成器.zip"文件显然是为了帮助开发者快速生成MyBatis-Plus的相关实体类、Mapper...
mybatis-plus-join是mybatis plus的一个多表插件
05-30
mybatis-plus-join是mybatis plus的一个多表插件，只要会用mp就会用这个插件，仅仅依赖了lombok，而且是扩展mp的构造器并非更改原本的构造器，不会对原有项目产生一点点影响 mybatis-plus的多表插件完全按照mybats plus的用法来做，支持一对一返回映射，多对多返回映射，自定义返回Vo，自定义表别名，自定义查询字段，你只要会mp，那你就会用mpj，无感引入，不会对之前的业务产生一点点影响，采用扩展方式来集成mp,更容易适配版本，后期mp版本升级，您不用更改东西，只需要更新版本就行
mybatis plus selectJoinPage 查询太慢问题解决
qq_43921238的博客
03-09 2856
mybatisPlus 默认的count sql是 select count(*) from (sql),sql为查询数据的sql.通过测试发现select 里没有distinct的关键字，只扫主表，如果加上distinct关键字就会扫整个sql。通过打印sql发现，是获取total时查询过慢，因为使用了多个leftJoin.最重要 是这点：.使count里的sql只有主表，没有leftJoin表。分析：因为分页本身数据不大，最多也就几十条，速度不应该太慢。项目中遇到，数据量如果过大，分页查询就很慢。
Java链表——插入和删除
Java 以及 后端，关注我，没错的
07-18 3662
目录 一、head头节点 二、插入 1.头插法 2.尾插法 3.按位置插入 首先引入我自定义建立链表对象的类：LinkNode public class ListNode { private int val; private ListNode next; public ListNode(int value) { this.val = value; } public ListNode() {} public ListNode getNext() { return this.
MyBatis-Plus 框架中QueryWrapper基本用法
weixin_45266691的博客
01-22 1144
是 MyBatis-Plus 框架提供的查询构造器，用于构建查询条件。它属于 MyBatis-Plus 的核心组件之一，简化了数据库操作的代码。MyBatis-Plus 还提供了 LambdaQueryWrapper，使用 Lambda 表达式进行类型安全的字段操作。的一些常见用法，具体的使用还取决于你的实际业务需求。根据具体的查询条件，你可以组合使用不同的方法，构建出灵活、简洁的查询语句。
mybatis-plus 基本CRUD
weixin_43788986的博客
09-28 893
基本数据库的表为student：使用的数据库和相关代码见。
QueryWrapper.lambda()表达式
liuxing201122013的专栏
10-20 6691
Mybatis-Plus中的条件构造器
m0_46159545的博客
07-06 1万+
Mybatis-Plus中的条件构造器 ​ 条件构造器（Wrapper）的作用： ​ MP提供的通用Mapper中，删改查（没有insert）的方法通常会需要我们传入一个条件构造器，用来生成最后执行的SQL语句。 ​ 比如List selectList( Wrapper wrapper)方法，当我们传入null时，默认生成的语句就是select * from xxx，这条语句没有查询条件，排序，子查询，模糊查询并且固定查询所有的字段，如果我们需要一些复杂的查询条件，就可以使用条件构造器来指定我们的SQ
MybatisPlus多表查询之零sql编写实现
zwrlj527的专栏
02-03 1719
MybatisPlus多表查询之零sql编写实现，只要表关系在你心中，就可以放飞自我。。。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值