mybatis-plus学习笔记

为什么要使用mybatis-plus

传统方式pojo-dao-service-controller

• 需要写大量的mapper.xml

使用了mybatis-plus之后

• pojo
• mapper接口
• 使用

快速使用

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.muyu</groupId>
	<artifactId>mybatis_plus</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>mybatis_plus</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/>
    </parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

配置application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db01?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimeZone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: mima

pojo

package com.muyu.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User{
	private long id;
	private String name;
	private Integer age;
	private String email;
}

mapper

package com.muyu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.muyu.pojo.User;
import org.springframework.stereotype.Repository;

//在对应的Mapper上面继承基本的类BaseMapper
@Repository
//或者@Mapper
public interface UserMapper extends BaseMapper<User> {
	//所有的CRUD的操作都已经完成了
}

在启动类添加扫描mapper文件注解

@SpringBootApplication
@MapperScan("com.muyu.mapper")
public class MybatisplusTestApplication {

	public static void main(String[] args) {
		SpringApplication.run(MybatisplusTestApplication.class, args);
	}

}

test

package com.muyu;

import com.muyu.mapper.UserMapper;
import com.muyu.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MybatisPlusApplicationTests {

	//集成了BaseMapper，所有的方法都来自自己的父类
	//我们也可以自己编写额外的扩展方法;
	@Autowired
	private UserMapper userMapper;

	@Test
	void contextLoads() {
		//参数是一个Wrapper，条件构造器，这里我们先不用，null
		//查询所有的用户
		List<User> users = userMapper.selectList(null);
		users.forEach(System.out::println);
	}

}

配置日志

我们所有的sql现在是不可见的，需要配置日志才可以看到
application.xml

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

或application.yml

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

CRUD扩展

插入操作

insert 插入

	@Test
	void testInsert(){
		User user = new User();
		user.setName("木羽");
		user.setAge(2);
		user.setEmail("yigemuyu@qq.com");
		int insert = userMapper.insert(user);//自动生成id
		System.out.println("插入了"+insert+"条数据");
		System.out.println(user);
	}

主键生成策略

分布式系统唯一ID生成方案汇总

雪花算法：

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。几乎可以保证全球唯一。

主键自增

1. 实体类字段上TableId(type = IdType.AUTO)
2. 数据库字段一定要是自增！
3. 再次测试插入即可

public enum IdType {
    AUTO(0),//主键自增
    NONE(1),//无状态，表示未设置主键类型，默认使用雪花算法
    INPUT(2),//在插入前自定义主键的值，用法 @TableId(value = "ID", type = IdType.INPUT)
    //以下三种都是用了Mybatisplus中的IdWorker类生成，idWorker中调用了分布式唯一 ID 生成器 - Sequence
    ID_WORKER(3),//全局唯一ID (idWorker),数值类型 数据库中也必须是数值类型 否则会报错
    UUID(4),//全局唯一ID (UUID，不含中划线)
    ID_WORKER_STR(5);//字符串全局唯一ID (idWorker 的字符串表示)，数据库也要保证一样字符类型
}

更新操作

Update 更新

	@Test
	void testUpdate(){
		User user = new User();
		user.setName("li");
		user.setId(8L);
		user.setAge(24);
		int i = userMapper.updateById(user);
		System.out.println(i);
		System.out.println(user);
	}

所有的sql都是mybatis-plus自动帮你配置的

自动填充

创建时间、修改时间！这些操作都是自动化完成的，我们不希望手动更新！

阿里巴巴开发手册：所有的数据库表：gmt_create gmt_modified几乎所有的表都要配置上，并且要自动化

方式一：数据库级别

在表中新增字段create_time,update_time
并对其字段进行设置，楼主使用的是navicat

创建时，只在创建的时候更新一次

修改时，每次对字段进行修改都要进行更新

这种方式不推荐使用，工作中不允许修改数据库

方式二：代码级别

1. 实体类字段上需要添加注解

   	@TableField(fill= FieldFill.INSERT)
   	private Date createTime;
   	@TableField(fill = FieldFill.INSERT_UPDATE)
   	private Date updateTime;
   

2. 创建一个注解的处理器

package com.muyu.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component//一定不要忘记把处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler{
	//插入时的填充策略

	@Override
	public void insertFill(MetaObject metaObject) {
		log.info("start insert fill....");
		this.setFieldValByName("createTime",new Date(),metaObject);
		this.setFieldValByName("updateTime",new Date(),metaObject);
	}

	//更新时的填充策略
	@Override
	public void updateFill(MetaObject metaObject) {
		log.info("start update fill......");
		this.setFieldValByName("updateTime",new Date(),metaObject);
	}
}

结果：

此处有一个小坑，楼主设置了好多次都没成

这是因为启动类放到了其他包下边，启动类和其他配置文件需要保证在一个包下，哪怕配置类在这个包的子包下也可以。于是修改成这个结构

成功

乐观锁

在面试过程中，我们经常会被问到乐观锁，悲观锁！这个其实非常简单！（再回去学一下JUC）

乐观锁：顾名思义十分乐观，他总是认为不会出现问题，无论干什么都不去上锁！如果出现了问题，就再次更新值测试

悲观锁：顾名思义十分悲观，他总是认为会出现问题，无论干什么都去上锁！再去操作！

乐观锁实现方式

• 取出记录时，获取当前version

• 更新时，带上这个version

• 执行更新时，set version = newVersion where version = oldVersion

• 如果version不对，就更新失败

• 这样如果同时有多个操作version的人的话，也只能修改一次

测试MP的乐观锁插件

1. 给数据库添加乐观锁的字段version

   

2. 同步实体类

   	@Version//乐观锁的注解
   	private Integer version;
   

3. 注册组件

//注册乐观锁插件
@Configuration //设置当前类为一个配置类
@MapperScan("com.muyu.mapper")  //将扫描放到配置类上
@EnableTransactionManagement //开启自动事务管理
public class MyConf {

	@Bean
	public OptimisticLockerInterceptor optimisticLockerInterceptor(){
		return new OptimisticLockerInterceptor();
	}
}

修改成功

@Test
void testOptimisticLocker(){
   User user = userMapper.selectById(1L);
   user.setName("fxxx");
   userMapper.updateById(user);
}

修改失败

@Test
void testOptimisticLocker2(){
   //线程1
   User user1 = userMapper.selectById(1L);
   user1.setName("fxxx1111");
   //线程2 进行了插队操作
   User user2 = userMapper.selectById(1L);
   user2.setName("fxxx22222");
   //线程2 执行 线程2 正常执行
   userMapper.updateById(user2);
   //线程1 执行 因为线程2执行之后，version的值已经加1 ，所以线程1在进行修改的时候，发现version版本不符合预期，所以执行失败
   userMapper.updateById(user1);
}

查询操作

//测试查询
@Test
void testSelectById(){
   User user = userMapper.selectById(1L);
   System.out.println(user);
}

//测试批量查询
@Test
void testSelectByBatchId(){
   List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
   users.forEach(System.out::println);

}

//条件查询 map
@Test
void testSelectByBatchIds(){
   HashMap<String, Object> map = new HashMap<>();
   map.put("version",1);
   List<User> users = userMapper.selectByMap(map);
   users.forEach(System.out::println);
}

分页查询

分页在网站上使用的十分多！

1. 原始的limit进行分页
2. pageHelper 第三方插件
3. mybatis plus 内置了分页插件！

如何使用分页插件

1. 先配置拦截器

   //分页插件
   @Bean
   public PaginationInterceptor paginationInterceptor() {
       return new PaginationInterceptor();
   }
   

2. 再直接使用page对象即可

   @Test
   void testPage(){
      //参数1，当前页
      //参数2，页面大小
      Page<User> page = new Page<>(1, 5);
      userMapper.selectPage(page,null);
      //获取所有的记录
      page.getRecords().forEach(System.out::println);
      //查询总数一共有多少
      System.out.println(page.getTotal());
      System.out.println("是否有下一页"+page.hasNext());         //是否有下一页
      System.out.println("是否有上一页"+page.hasPrevious());      //是否有上一页
      System.out.println("每页的记录数量"+page.getSize());         //每页的记录数量
      System.out.println("获得当前的页数"+page.getCurrent());      //获得当前的页数
   
   }
   

输出结果

User(id=1, name=Jone, age=18, email=test1@baomidou.com, createTime=Sun Aug 15 14:26:32 CST 2021, updateTime=Sun Aug 15 14:26:32 CST 2021, version=1)
User(id=2, name=Jack, age=20, email=test2@baomidou.com, createTime=Sun Aug 15 14:26:32 CST 2021, updateTime=Sun Aug 15 14:26:32 CST 2021, version=1)
User(id=3, name=Tom, age=28, email=test3@baomidou.com, createTime=Sun Aug 15 14:26:32 CST 2021, updateTime=Sun Aug 15 14:26:32 CST 2021, version=1)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com, createTime=Sun Aug 15 14:26:32 CST 2021, updateTime=Sun Aug 15 14:26:32 CST 2021, version=1)
User(id=5, name=Billie, age=24, email=test5@baomidou.com, createTime=Sun Aug 15 14:26:32 CST 2021, updateTime=Sun Aug 15 14:26:32 CST 2021, version=2)
17
是否有下一页true
是否有上一页false
每页的记录数量5
获得当前的页数1

删除操作

1. 根据id删除记录

//根据id删除
@Test
void testDeleteById(){
   userMapper.deleteById(10L);
}
//删除多个
@Test
void testDeleteBatchId(){
   userMapper.deleteBatchIds(Arrays.asList(1L,2L,3L));
}
//根据条件删除
@Test
void testDeleteMap(){
   HashMap<String, Object> map = new HashMap<>();
   map.put("name","范栩");
   userMapper.deleteByMap(map);
}

逻辑删除

逻辑删除是因为，对于真正的业务情况来说，数据是很重要的，不可以随便删除，我们只要将其在某种逻辑上删除就好，比如已经逻辑删除的东西在正常情况下对外不可见，但是却是真实存储在数据库中的，通过一个标识符表示他的状态，0为正常，1为已删除。在需要的时候，我们可以拿到这个数据，这就是逻辑删除的基本使用。

说明:

只对自动注入的sql起效:

• 插入: 不作限制
• 查找: 追加where条件过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
• 更新: 追加where条件防止更新到已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
• 删除: 转变为 更新

例如:

• 删除: update user set deleted=1 where id = 1 and deleted=0
• 查找: select id,name,deleted from user where deleted=0

字段类型支持说明:

• 支持所有数据类型(推荐使用 Integer,Boolean,LocalDateTime)
• 如果数据库字段使用datetime,逻辑未删除值和已删除值支持配置为字符串null,另一个值支持配置为函数来获取值如now()

附录:

• 逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案，但实际就是删除。
• 如果你需要频繁查出来看就不应使用逻辑删除，而是以一个状态去表示。

使用方法：

步骤1: 配置

com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig

• 例: application.yml

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

步骤2: 实体类字段上加上@TableLogic注解

@TableLogic
private Integer deleted;

步骤3：在配置类配置删除注射器

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

步骤4：测试

@Test
void deleteUser(){
	userMapper.deleteById(17);
}
//测试查询
@Test
void testSelec![](https://img-blog.csdnimg.cn/f1ae61c7606c442db7168fda979f404d.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjE1OTU5,size_16,color_FFFFFF,t_70)
tById(){
	User user = userMapper.selectById(17L);
	System.out.println(user);
}

查询结果

性能分析器

在遇到慢sql的时候可以使用这个性能分析插件，可以输出每条sql，以及他的运行时间，如果超出规定的时间，可以对其进行拦截。

对性能拦截器进行配置

@Bean
@Profile({"dev","test"})//设置此方法在什么环境中起作用
public PerformanceInterceptor performanceInterceptor(){
	PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
	performanceInterceptor.setMaxTime(1L);//设置最大运行时间，单位：ms
	performanceInterceptor.isFormat();//格式化sql
	return performanceInterceptor;
}

设置当前环境为开发环境

spring:
    profiles:
        active: dev

测试

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

可以看到32ms的运行时间使这条sql报错了

我们将拦截的最大时间调高

测试成功

条件构造器(Wrapper)

说明:

• 以下出现的第一个入参boolean condition表示该条件是否加入最后生成的sql中，例如：query.like(StringUtils.isNotBlank(name), Entity::getName, name) .eq(age!=null && age >= 0, Entity::getAge, age)
• 以下代码块内的多个方法均为从上往下补全个别boolean类型的入参,默认为true
• 以下出现的泛型Param均为Wrapper的子类实例(均具有AbstractWrapper的所有方法)
• 以下方法在入参中出现的R为泛型,在普通wrapper中是String,在LambdaWrapper中是函数(例:Entity::getId,Entity为实体类,getId为字段id的getMethod)
• 以下方法入参中的R column均表示数据库字段,当R具体类型为String时则为数据库字段名(字段名是数据库关键字的自己用转义符包裹!)!而不是实体类数据字段名!!!,另当R具体类型为SFunction时项目runtime不支持eclipse自家的编译器!!!
• 以下举例均为使用普通wrapper,入参为Map和List的均以json形式表现!
• 使用中如果入参的Map或者List为空,则不会加入最后生成的sql中!!!
• 有任何疑问就点开源码看,看不懂函数的点击我学习新知识

使用Wrapper进行条件查询，这里是使用了链式编程的写法（链式编程的实现，就是在每一个方法的返回值，都返回一个this）

@Test
void testWrapper(){
	QueryWrapper<User> wrapper = new QueryWrapper();
	wrapper.isNotNull("name") //name不为空
			.isNotNull("email") //email不为空
			.ge("age",21) //年龄大于等于21
			.lt("id",10);//id小于10
	List<User> users = userMapper.selectList(wrapper);
	users.forEach(System.out::println);
}

条件查询名字

@Test
public void testWrapper2(){
	QueryWrapper<User> wrapper = new QueryWrapper<>();
	wrapper.eq("name","范栩");
	User user = userMapper.selectOne(wrapper);  // 查询一个数据
	System.out.println(user);
}

区间查询

@Test
public void testWrapper3(){
	QueryWrapper<User> wrapper = new QueryWrapper<>();
	wrapper.between("age",25,30);
	List<User> users = userMapper.selectList(wrapper);  // 查询一个数据
	users.forEach(System.out::println);
}

他的源码是Object类，我就试了一下String类型是否也可以正确执行
答案是可以

使用like进行查询

@Test
	public void testWrapper4(){
		QueryWrapper<User> wrapper = new QueryWrapper<>();
		wrapper.like("name","张");
		List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
		maps.forEach(System.out::println);
	}

使用子查询，查询id大于10的user

@Test
public void testWrapper5(){
	QueryWrapper<User> wrapper = new QueryWrapper<>();
	wrapper.inSql("id","select id from user where id>10");
	List<User> users = userMapper.selectList(wrapper);
	users.forEach(System.out::println);
}

升序排序

@Test
public void testWrapper6(){
	QueryWrapper<User> wrapper = new QueryWrapper<>();
	wrapper.orderByAsc("id");
	List<User> users = userMapper.selectList(wrapper);
	users.forEach(System.out::println);
}

降序排序

@Test
public void testWrapper6(){
	QueryWrapper<User> wrapper = new QueryWrapper<>();
	wrapper.orderByDesc("id");
	List<User> users = userMapper.selectList(wrapper);
	users.forEach(System.out::println);
}

代码自动生成器