狂神说---MyBatisPlus学习

MyBatisPlus学习

MyBatisPlus官网教程
哔哩哔哩《狂神说》学习网站

MyBatisPlus快速入门

1.新建mybatis_plus数据库

DROP TABLE IF EXISTS user;

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)
);

2.新增数据进表

INSERT INTO USER (id, NAME, age, email) VALUES
(1, 'Jone', 18, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

3.新建springboot项目（mybatis_plus）

编写项目，初始化项目！使用springboot初始化！

4…导入依赖

<!--数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

5.连接数据库 application.xml

是否使用安全连接：useSSL=false

#  mysql5 驱动不同 com.mysql.jdbc.Driver
#  mysql8 驱动不同 com.mysql.cj.jdbc.Driver  serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=UTF-8&&useSSL=false&serverTimezone=GMT%2B8&useUnicode=true
spring.datasource.username=root
spring.datasource.password=123456

5.传统的Pojo-dao（连接mybatis，配置mapper.xml文件）-service-controller

6.用mybatis-plus后（pojo-mapper接口-使用）

Pojo:
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    
    
    private Long id;
    private String name;
    private Integer age;
    private String email;

}

Mapper:
//在对应的mapper上继承基本的类 ---BaseMapper
@Repository//表示是持久层   dao层的 mapper
public interface UserMapper extends BaseMapper<User>{
    
    
    //在继承BaseMapper之后，所有的CRUD操作已经编写完成
}

注意点：主启动类MybatisPlusApplication 添加扫描包

@MapperScan("com.hh.mapper") //扫描包
@SpringBootApplication
public class MybatisPlusApplication {
    
    

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

使用（测试类）
@SpringBootTest
class MybatisPlusApplicationTests {
    
    
    @Autowired//远程注入  继承了BaseMapper，所有的方法都来自于父类
    private UserMapper userMapper;
    @Test
    void contextLoads() {
    
    
        //参数 wrapper ，条件构造器
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

演示结果：
User(id=1, name=Jone, age=18, email=[email protected])
User(id=2, name=Jack, age=20, email=[email protected])
User(id=3, name=Tom, age=28, email=[email protected])
User(id=4, name=Sandy, age=21, email=[email protected])
User(id=5, name=Billie, age=24, email=[email protected])

7.日志配置

#配置日志 方便在开发的时候看到查询语句是怎么运行的，在运营阶段可以关闭日志，提高效率 
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl



演示结果：
Preparing: SELECT id,name,age,email FROM user 

CRUD 扩展

插入

@Test
void testinsert() {
    
    
    User user = new User();
    user.setName("哈哈学mybatis_plus");
    user.setAge(10);
    user.setEmail("[email protected]");
    int result = userMapper.insert(user);//id 自动生成了
    System.out.println(result);//受影响行数
    System.out.println(user);//发现，id会自动回填
}

数据库插入的id的默认值为：全局的唯一id
主键生成策略

//默认ID_WORKER全局唯一ID
@TableId(type = IdType.ID_WORKER)

分布式系统唯一id生成方法汇总

雪花算法：snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看 https://github.com/twitter/snowflake。雪花算法支持的TPS可以达到419万左右（2^22*1000）。
雪花算法在工程实现上有单机版本和分布式版本。单机版本如下，分布式版本可以参看美团leaf算法：https://github.com/Meituan-Dianping/Leaf

主键自增
1.实体类上：@TableId(type = IdType.AUTO)
2.数据库字段一定要设置为自增

测试：
查看自增量


其余的源码解释：

public enum IdType {
    
    
    AUTO(0),//数据库ID自增
    
    NONE(1),//未设置主键INPUT(2),//手动输入
    ID_WORKER(3),//默认的全局唯一ID 
    UUID(4),//全局唯一ID UUID
    ID_WORKER_STR(5);// 字符串表示法
 }

一般手动就必须配置id，注意：此时的数据库字段不能设置为自增

@TableId(type = IdType.INPUT)

user.setId(7L);

修改

//测试修改
@Test
void testUpdate() {
    
    
    User user = new User();
//通过条件自动拼接动态SQL
    user.setId(6L);
    user.setName("哈哈学mybatis_plus2");
    user.setAge(20);
    user.setEmail("[email protected]");

    int i = userMapper.updateById(user);
    System.out.println(i);
}

自动填充

方式一：数据库级别（不建议使用）
1.在表新增字段 create_time ,update_time

2.在此测试更新，需要先把实体类同步

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    
    

    //ID_WORKER 全局唯一ID ;AUTO:自增
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updateTime;
}

3.测试

@SpringBootTest
class MybatisPlusApplicationTests {
    
    

    @Autowired//远程注入  继承了BaseMapper，所有的方法都来自于父类
    private UserMapper userMapper;

    @Test
    public void contextLoads() {
    
    
        //参数 wrapper ，条件构造器
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

    //测试新增（插入）
    @Test
    public void testInsert(){
    
    
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        User user = new User();
        user.setId(6L);
        user.setName("狂神");
        user.setAge(16);
        user.setEmail("[email protected]");
//        user.setCreateTime(simpleDateFormat.format(new Date()));
        user.setCreateTime(new Date());
        user.setUpdateTime(new Date());
        int result =  userMapper.insert(user);
        System.out.println(result);//受影响行数
        System.out.println(user);//发现，id会自动回填
    }
    
    //测试修改
    @Test
    public void testUpdate(){
    
    
        User user = new User();
        user.setId(6L);
        user.setName("关注狂神说");
        user.setAge(18);
		//这里注意：并没有设置修改的时间，起作用的是数据库勾选的更新

        //注意：updateById 但是参数是一个对象
        int i= userMapper.updateById(user);
        System.out.println(i);
    }
}

演示结果

方式二：代码级别
1.删除数据库的默认值，更新操作

2.实体类字段属性上需要增加注解

 
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    
    

    //ID_WORKER 全局唯一ID ;AUTO:自增【数据库记得id要设置自增！！！】
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;

    //字段添加填充内容
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

//    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
//    private Date createTime;
//    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
//    private Date updateTime;
}

3.编写处理器来处理这个注解

package com.hh.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 insertFill ......");
        // setFieldValByName(String fieldName【实体类字段】, Object fieldVal, MetaObject metaObject)
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

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

4.测试插入和修改

    //测试新增（插入）
    @Test
    public void testInsert(){
    
    
        User user = new User();
        user.setName("哈哈学mybatis-plus");
        user.setAge(8);
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        user.setUpdateTime(new Date());
        int result =  userMapper.insert(user);
        System.out.println(result);//受影响行数
        System.out.println(user);//发现，id会自动回填
    }

    //测试修改
    @Test
    public void testUpdate(){
    
    
        User user = new User();
        user.setId(7L);
        user.setName("五哈");
        user.setAge(18);
        //注意：updateById 但是参数是一个对象
        int i= userMapper.updateById(user);
        System.out.println(i);
    }

插入演示：

修改演示：

乐观锁处理

乐观锁学习
乐观锁实现方式：
取出记录时，获取当前 version
更新时，带上这个 version
执行更新时， set version = newVersion where version = oldVersion
如果 version 不对，就更新失败

测试一下Mybatis_plus【MP】的乐观锁插件
1.给数据库添加 version 字段


2.同步实体类字段

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

3.注册组件
主启动类可以把扫描包的工作交给config

//@MapperScan("com.hh.mapper") //扫描包
@SpringBootApplication
public class MybatisPlusApplication {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}

组件

@MapperScan("com.hh.mapper") //扫描包
@EnableTransactionManagement//自动管理事务注解
@Configuration//配置类
public class MyBatisPlusConfig {
    
    
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
    
    
        return new OptimisticLockerInterceptor();
    }
    
}

4.测试

//测试乐观锁--成功
    @Test
    public void testOptimisticLocker(){
    
    
        //1.查询用户信息   2.修改用户信息 3.执行更新操作
        User user = userMapper.selectById(1L);
        user.setName("hhhhhhhh");
        user.setEmail("[email protected]");
        userMapper.updateById(user);
    }
    
 //测试乐观锁--失败 【多线程下】
    @Test
    public void testOptimisticLocker2(){
    
    
        //1.查询用户信息   2.修改用户信息 3.执行更新操作
        //线程1
        User user1 = userMapper.selectById(1L);
        user1.setName("线程1");
        user1.setEmail("[email protected]");
        //线程2（模拟插队操作）
        User user2 = userMapper.selectById(1L);
        user2.setName("线程2");
        user2.setEmail("[email protected]");
        userMapper.updateById(user2);
        //如果没有乐观锁就会覆盖插队线程的值
        userMapper.updateById(user1);
    }

多线程：

查询操作

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

 //测试批量查询
    @Test
    public void selectByBatchId(){
    
    
     //参数 wrapper ，条件构造器
     List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2,3));
     users.forEach(System.out::println);
     }

 //按条件查询之一-----map操作
    @Test
    public void selectByBatchIds(){
    
    
        HashMap<String, Object> map = new HashMap<>();

        //自定义要查询
        map.put("name","关注狂伸说");
        map.put("age",18);

        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

分页查询

如何使用？
分页代码官网参考
1.配置拦截器组件即可 （ 在MyBatisPlusConfig配置类中添加）

// 分页------旧版  
    @Bean
    public PaginationInterceptor paginationInterceptor() {
    
    
        return new PaginationInterceptor();
    }
    
 // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }

2.直接使用page对象即可

//测试分页查询
    @Test
    public void testPage(){
    
    
        //current:当前页；size：页面大小（页面条数）
        Page<User> page = new Page<>(1,5);
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

删除操作

   @Test
    public void deleteById(){
    
    
        userMapper.deleteById(7L);
    }
    //删除----通过id批量删除数据
    @Test
    public void deleteBatchId(){
    
    
        userMapper.deleteBatchIds(Arrays.asList(6L,5L));
    }
    //删除----通过map删除数据
    @Test
    public void deleteMap(){
    
    
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","关注狂神说"); //自定义要删除的数据
        userMapper.deleteByMap(map);
    }

逻辑删除

区别：物理删除是真正的删除，再也找不到这个文件了。
逻辑删除并没有真正的删除掉，可以重新恢复，类似于回收站，还可以再找回数据

物理删除：真实删除。将对应数据从数据库中删除，之后查询不到此条被删除数据；
逻辑删除：假删除。在数据库中没有被移除，而是通过改变一个变量来让它失效！！！！
例如：delete=0；delete=1
管理员可以查看被删除的数据，防止数据的丢失

测试一下：
1.数据库新增字段 deleted（逻辑删除）

2.实体类同步数据（实体类字段上加上@TableLogic注解）

    @TableLogic //逻辑删除
    private Integer deleted;

3.在MyBatisPlusConfig配置类添加组件 ，注入bean

    //逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector(){
    
    
        return new LogicSqlInjector();
    }

4.在application.properties里面配置逻辑删除的设定（或者用application.yml）
逻辑删除官网参考

#  application.properties
#逻辑删除 （0-没有被删除，1-删除）
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

#   application.yml
mybatis-plus:
  global-config:
    db-config:
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

5.测试

性能分析插件

性能分析插件参考博客
作用：性能分析拦截器，用于输出每条sql语句及其执行的时间
mybatis-plus(MP)也提供了性能分析插件，如果超过之歌时间就停止运行

1.导入插件

 //性能分析插件——————sql执行效率插件
    @Bean
    @Profile({
    
    "dev","test"})
    public PerformanceInterceptor performanceInterceptor() {
    
    
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        // 在工作中，不允许用户等待  （分别测试 1ms:1毫秒    1000ms:1秒）
        performanceInterceptor.setMaxTime(1000); // ms 设置sql执行的最大s时间,如果超过了则不执行
        performanceInterceptor.setFormat(true); // 是否进行格式化
        return new PerformanceInterceptor();
    }

注意：要在springboot中配置环境为dev环境或者test环境

#设置开发的环境  application.properties或者 application.yml
spring.profiles.active=dev

2.测试使用

条件查询器Wrapper

条件查询器Wrapper
测试类

package com.hh;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hh.mapper.UserMapper;
import com.hh.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;
import java.util.Map;

/*
条件查询器--Wrapper--测试类
 */
@SpringBootTest
public class WrapperTest {
    
    

    @Autowired//远程注入  继承了BaseMapper，所有的方法都来自于父类
    private UserMapper userMapper;

    //查询name、email不为空，且年龄》=12的用户
    @Test
    void contextLoads() {
    
    
        //参数 wrapper ，条件构造器
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("name").isNotNull("email").ge("age","12");
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

    //查询名字“五哈"
    @Test
    public void test2(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","五哈");
        User user = userMapper.selectOne(wrapper);//查询一个数据用 selectOne，多个用list 或map
        System.out.println(user);
    }

    //查询年龄在20-30之间的
    @Test
    public void test3(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30);
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }

    //模糊查询（名字不包含e ,邮箱以 t 开头的）
    @Test
    public void test4(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //likeRight(t%)  以 t 开头的
        // likeLeft(%t)  以 t 结尾的
        wrapper.notLike("name","e").likeRight("email","t");//SELECT id,name,age,email,version,deleted,create_time,update_time FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ?
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }


    //嵌套查询（可以插入自己写的SQL语句）
    @Test
    public void test5(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.inSql("id","select id from user where id<3");
        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

    //排序---通年龄进行排序(升序 ：orderByAsc() ；降序 ：orderByDesc())
    @Test
    public void test6(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("age");  
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

}

测试一：

测试二：

后面的测试自己试验看结果

代码自动生成器

代码生成器（旧）
代码生成器（新）

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
准备条件 ：1.pom.xml配置包、2.application.properties配置、3.MyBatisPlusConfig配置类，4.自备数据库 然后就可以进行测试了
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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hh</groupId>
    <artifactId>hh-community</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>hh-community</name>
    <description>何何学代码生成器</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--文件上传 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.48</version>
        </dependency>
        <!--mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!--velocity模板引擎，mybatis-plus代码生成器需要 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--swagger2  -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!--thymeleaf -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <!--<configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>-->
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.4.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- 解决在 src/test/java/MyTest.java 用main运行报错问题 -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.6.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <classpathScope>test</classpathScope>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

#服务端口 查看端口是否被占用 netstat -aon|findstr "9000"
server.port=9000
spring.profiles.active=dev
#禁用模板缓存
spring.thymeleaf.cache=false

#数据库连接配置
#  mysql5 驱动不同 com.mysql.jdbc.Driver
#  mysql8 驱动不同 com.mysql.cj.jdbc.Driver  serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8&&useSSL=false&serverTimezone=GMT%2B8&useUnicode=true
spring.datasource.username=root
spring.datasource.password=123456

#配置日志 方便在开发的时候看到查询语句是怎么运行的，在运营阶段可以关闭日志，提高效率
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#逻辑删除 （0-没有被删除，1-删除）
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

配置类MyBatisPlusConfig

package com.hh.config;


import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@MapperScan("com.hh.mapper") //扫描包
@EnableTransactionManagement//自动管理事务注解
@Configuration//配置类
public class MyBatisPlusConfig {
    
    

    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
    
    
        return new OptimisticLockerInterceptor();
    }
    // 分页------旧版  https://baomidou.com/pages/8f40ae/
    @Bean
    public PaginationInterceptor paginationInterceptor() {
    
    
        return new PaginationInterceptor();
    }

    //逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector(){
    
    
        return new LogicSqlInjector();
    }

    //性能分析插件——————sql执行效率插件
    @Bean
    @Profile({
    
    "dev","test"})
    public PerformanceInterceptor performanceInterceptor() {
    
    
        PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
        // 在工作中，不允许用户等待  （分别测试 1ms:1毫秒    1000ms:1秒）
        performanceInterceptor.setMaxTime(1000); // ms 设置sql执行的最大s时间,如果超过了则不执行
        performanceInterceptor.setFormat(true); // 是否进行格式化
        return new PerformanceInterceptor();
    }
}

package com.hh;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;

//代码自动生成器
public class HhCode {
    
    

    public static void main(String[] args) {
    
    
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        //配置策略
        // 1.全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");//获取当前用户的目录（当前项目的目录）
        gc.setOutputDir(projectPath + "/src/main/java");//代码生成放置的位置
        gc.setAuthor("hh");//作者
        gc.setOpen(false);//是否打开资源管理器（是否打开window文件夹）
        gc.setFileOverride(false);//是否覆盖之前生成的
        gc.setServiceName("%sService");//去service的I前缀
        gc.setIdType(IdType.ID_WORKER);//默认策略ID_WORKER 全局唯一ID       ;AUTO:自增
        gc.setDateType(DateType.ONLY_DATE);//日期
        // gc.setSwagger2(true); //是否用Swagger2文档     实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);

        // 2.数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        //jdbc:mysql://localhost:3306/ant?useUnicode=true&useSSL=false&characterEncoding=utf8
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8&&useSSL=false&serverTimezone=GMT%2B8&useUnicode=true");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");//  mysql5: dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        mpg.setDataSource(dsc);

        // 3.包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog");// pc.setModuleName(scanner("模块名"));
        pc.setParent("com.hh");//"com.baomidou.ant"
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        // 4. 策略配置
        StrategyConfig strategy = new StrategyConfig();
//        strategy.setInclude("user");//映射表名 ****************`user``blog``student``teacher`**********************
        strategy.setInclude("blog","student","teacher");//映射表名  例如：user：用户表
        strategy.setNaming(NamingStrategy.underline_to_camel);//包命名-- 下划线转驼峰命名
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//列名-- 下划线转驼峰命名
        strategy.setEntityLombokModel(true);//自动lombok
        //逻辑删除 deleted
        strategy.setLogicDeleteFieldName("deleted");

        //自动填充配置  （例如：创建时间和修改时间）
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);

        //乐观锁  version
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true); //开启 restfull的驼峰命名规则
        strategy.setControllerMappingHyphenStyle(true);//localhost：8080/hello_id_2
        mpg.setStrategy(strategy);

        mpg.execute();//执行
    }
}

Mybatis-Plus的使用小技巧，高级面试题+解析
MyBatis、Mybatis Plus（面试常问）