MybatisPlus一篇文章就够了

MybatisPlus学习

其实我们用过了这么多第三方组件，也应该大体能知道整合的流程了，一般都是先导入依赖，然后研究依赖包如何进行配置，再然后去学习如何使用这个组件，当然MybatisPlus也不例外。

快速入门

#创建数据库 mybatis_plus
#创建user表,建表语句来自MybatisPlus官网
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)
);

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[e-mail]'),
(2, 'Jack', 20, '[e-mail]'),
(3, 'Tom', 28, '[e-mail]'),
(4, 'Sandy', 21, '[e-mail]'),
(5, 'Billie', 24, '[e-mail]');

1.导入依赖

<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!--mysql驱动,因为SpringBoot里已经有默认的依赖了，这里可以不写版本-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--MybatisPlus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version>
</dependency>

2.数据库连接配置

#数据库连接配置
spring:
  datasource:
    username: root
    url: jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone = GMT
    password: sznshige250
    driver-class-name: com.mysql.cj.jdbc.Driver

3.编写User类和Mapper接口

User实体类

package com.shen.pojo;

import lombok.Data;

/**
 * @Auther Shen
 * @Date 2020-07-10
 */
@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

UserMapper接口

package com.shen.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.shen.pojo.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Auther Shen
 * @Date 2020-07-10
 */
@Mapper //自动生成当前接口的实现类
public interface UserMapper extends BaseMapper<User> {

}

注意点：要在主启动类上添加@MapperScan这个注解，去扫描我们的Mapper接口，例如这里我需要主启动类上扫我的Mapper接口所在的包@MapperScan(“com.shen.mapper”)如下图：

4.测试

package com.shen;

import com.shen.mapper.UserMapper;
import com.shen.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 {

    @Autowired
    UserMapper userMapper;
    
    @Test
    void contextLoads() {
        
        //selectList方法中参数是：Wrapper条件构造器，这里先不用，就可以直接写null
        //查询全部用户
        List<User> users = userMapper.selectList(null);
        for (User user:users){
            System.out.println(user);
        }
    }
}

测试结果如下：

配置日志

上面执行的sql是不可见的，我们需要配置日志来查看执行的流程

#配置mybatis-plus的日志,可以用log4j，可以用slf4j,不过需要导入对应的包，这里使用了一个默认的日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

配置好之后再次执行查询所有用户的操作，控制台输出下面的结果，可以看到具体的执行过程

CRUD扩展

插入操作

@Test
void insert() {
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    user.setEmail("[e-mail]");
    userMapper.insert(user);
}

主键策略

package com.baomidou.mybatisplus.annotation;
import lombok.Getter;
/**
 * 生成ID类型枚举类
 *
 * @author hubin
 * @since 2015-11-10
 */
@Getter
public enum IdType {
    /**
     * 数据库ID自增
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 分配ID (主键类型为number或string）,
     * 雪花算法
     */
    ASSIGN_ID(3),
    /**
     * 分配UUID (主键类型为 string)
     */
    ASSIGN_UUID(4),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER_STR(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_UUID}
     */
    @Deprecated
    UUID(4);

    private final int key;

    IdType(int key) {
        this.key = key;
    }
}

• 如果数据库配置了id自增，我们在User实体类上也要配置上ID自增策略

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

• 如果插入时手动设置id，就可以配置，但与此同时，测试的时候就必须自己指定id

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

@Test
void insert() {
    User user = new User();
    user.setId(9L);//---就是这里，主键策略为INPUT的时候必须手动设置id
    user.setName("张三");
    user.setAge(18);
    user.setEmail("[e-mail]");
    userMapper.insert(user);
}

更新操作

@Test
void update() {
    User user = new User();
    user.setId(9L);
    user.setName("李四");
    user.setAge(25);
    //虽然这个是updateById(),但是它的参数却是user对象
    userMapper.updateById(user);
}

仔细看上面两张截图，可以明显的看到，MybatisPlus可以根据传入的参数，动态拼接SQL，这个动态拼接SQL在用Mybatis的时候是十分麻烦的，但用MybatisPlus的时候，我们不需要做什么操作，它自动帮我们动态的拼接了SQL，这点是十分方便的。

自动填充功能

什么时候用这个字段填充功能？

比如对数据进行插入或更新的时候，我们想知道插入操作的时间，或者更新这条数据的时间，这就要求我们每次对数据库进行操作的时候都要new Date(),然后再设置date，这样十分麻烦，所以MybatisPlus给我们提供了自动填充功能，具体怎么做呢，请继续往下看。

首先来看一波源码，@TableField的源码

然后我们点进去FieldFill类，可以看到所有的字段自动填充策略

package com.baomidou.mybatisplus.annotation;
/**
 * 字段填充策略枚举类
 * 判断注入的 insert 和 update 的 sql 脚本是否在对应情况下忽略掉字段的 if 标签生成
 * <if test="...">......</if>
 * 判断优先级比 {@link FieldStrategy} 高
 *
 * @author hubin
 * @since 2017-06-27
 */
public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插入时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插入和更新时填充字段
     */
    INSERT_UPDATE
}

看到这里，然后我们再参考一下官网的文档

https://mybatis.plus/guide/auto-fill-metainfo.html

• 第一步，先在数据表中添加两个字段，一个创建时间，一个更新时间
  
• 第二步，在实体类上加字段自动填充策略的注解

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

• 第三步，编写处理器，可以参考官方文档

package com.shen.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;

/**
 * @Auther Shen
 * @Date 2020-07-10
 */
@Slf4j
@Component //不要忘了注入到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    //插入时的自动填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        //根据名称设置填充字段的值
        // 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 insert fill ....");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

配置完成后，测试一下插入操作，可以看到sql语句，自动填充上了创建时间和更新时间。

乐观锁插件

下面部分文档来自于官网：https://mybatis.plus/guide/optimistic-locker-plugin.html

主要适用场景

意图：

当要更新一条记录的时候，希望这条记录没有被别人更新

乐观锁实现方式：

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

乐观锁配置需要2步 记得两步

1.插件配置

spring xml:

<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>

spring boot:

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

2.注解实体字段 @Version 必须要!

@Version
private Integer version;

特别说明:

• 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
• 整数类型下 newVersion = oldVersion + 1
• newVersion 会回写到 entity 中
• 仅支持 updateById(id) 与 update(entity, wrapper) 方法
• 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

3.测试

@Test
void update() {
    User user = userMapper.selectById(9L);  //先从数据库取出数据
    user.setName("李四");
    user.setAge(25);
    userMapper.updateById(user);            //然后更新数据
}

**结果：**可以看到SQL语句中带上了version字段

查询操作

查询这里先只说一下简单查询和分页查询，后面会写用Wrapper条件构造器查询

简单查询

@Test
void selectById(){
    //根据id查询
    User user = userMapper.selectById(1L);
    System.out.println(user);
}
@Test
void selectByIds(){
    //根据多个id，查询多个用户
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L));
    System.out.println(users);
}
@Test
void selectByMap(){
    //多条件查询
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","张三");
    map.put("age",18);
    //此时查询出来的就是name = 张三 AND age = 18的所有数据
    List<User> users = userMapper.selectByMap(map);
    System.out.println(users);
}

分页查询

1.配置分页插件

package com.shen.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @Auther Shen
 * @Date 2020-07-10
 */
@Configuration
@MapperScan("com.shen.mapper")
@EnableTransactionManagement  //开启对事务的支持
public class MybatisPlusConfig {
    //乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

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

2.测试

@Test//分页查询测试
void selectPage(){
    Page<User> page = new Page<>(1,5); //第一页，每页五条数据
    Page<User> users = userMapper.selectPage(page, null);
    page.getRecords().forEach(System.out::println);
}

删除操作

简单删除

@Test
//根据id删除
void deleteById() {

    int i = userMapper.deleteById(10L);
    System.out.println(i);
}

@Test
//根据多个id，删除多个用户
void deleteByIds() {
    int i = userMapper.deleteBatchIds(Arrays.asList(9L, 10L));
    System.out.println(i);

}

@Test
//多条件删除
void deleteByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "张三");
    map.put("age", 18);
    //此时删除的就是name = 张三 AND age = 18的所有数据
    int i = userMapper.deleteByMap(map);
    System.out.println(i);
}

逻辑删除

1.在数据库加字段deleted

2.在User类添加字段，并加上@TableLogic注解

@TableLogic
private Integer deleted;

3.配置逻辑删除

#配置默认的日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  #配置逻辑删除
  global-config:
    db-config:
      logic-delete-field: flag  #全局逻辑删除字段值 3.3.0开始支持，详情看下面。
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

4.使用

/*---------逻辑删除-------------*/
@Test
void logicDelete(){
    int i = userMapper.deleteById(10L);
}

测试结果如下：可以发现，逻辑删除其实是更新操作

我们再测试一下还能不能查到这个逻辑删除的数据

@Test
void logicDelete(){
    User user = userMapper.selectById(10L);
    System.out.println(user);
}

可以看到，没有查出来，而且SQL语句自动帮我们拼接上了deleted=0

性能分析插件(重要)

作用： 用于输出每条 SQL 语句及其执行时间 ， 超过自动停止运行，有助于发现问题。

官方提示：该插件 3.2.0 以上版本移除，推荐使用P6Spy，所以这里直接整合P6Spy

• 第一步： p6spy 依赖引入

<!-- p6spy -->
<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.0</version>
</dependency>

• 第二步： application.yml 配置

spring:
  datasource:
    username: root
    url: jdbc:p6spy:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone = GMT
    password: sznshige250
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver

就是将driver-class-name由com.mysql.cj.jdbc.Driver变为com.p6spy.engine.spy.P6SpyDriver,还有就是url将原来的jdbc:mysql改为现在的jdbc:p6spy:mysql,详细的看正上方粘贴的配置文件。

• 第三步：添加P6Spy的专属配置文件

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory

# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger

#日志输出到控制台，不会产生日志文件spy.log
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger

# 使用日志系统记录sql，会产生日志文件spy.log
#appender=com.p6spy.engine.spy.appender.Slf4JLogger

# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

• 测试，可以明显的看到sql语句，和运行的时间和毫秒数
  

注意点1：整合了P6Spy后就要把最开始的日志配置注销掉，就如下面代码所示，如果自己的application.yml中存在下面的配置，要注释掉，或者删掉，才能看到P6Spy专用配置文件的效果。

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

注意点2：现在用的MP，所以可以使用com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger作为自定义打印日志的配置

# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger

但如果不想用MP的，也是可以自定义打印日志的格式的，可以编写一个类，实现MessageFormattingStrategy接口，然后重写它的方法，return自定义的格式，下面是我的自定义的日志打印格式类

package com.shen.handler;

import com.p6spy.engine.spy.appender.MessageFormattingStrategy;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Auther Shen
 * @Date 2020-07-10
 */

public class P6Spy implements MessageFormattingStrategy {
    private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

    @Override
    public String formatMessage(int connectionId, String now, long elapsed, String category, String prepared, String sql, String url) {
        return !"".equals(sql.trim()) ? this.format.format(new Date()) + " | took " + elapsed + "ms" + "\n" + sql.replaceAll("[\\s]+", " ") + ";" : "";
    }

}

写好自定义的日志打印格式类后需要将spy.properties中logMessageFormat的值配置为自己的类

logMessageFormat=com.shen.handler.P6Spy

配置好之后再次执行，输出的日志就是下面这样的了

条件构造器

@Test
void test1() {
    //查询姓名为张三的用户
    //eq:等于，例：eq("name", "老王")--->name = '老王'
    //ne：不等于，例: ne("name", "老王")--->name <> '老王'
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq(true,"name","张三");
    User user = userMapper.selectOne(wrapper);
    System.out.println(user);

}

@Test
void test2() {
    //查询年龄大于等于18岁的用户
    //ge:大于等于;gt:大于;lt:小于;le:小于等于;
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.ge("age",18);
    List<User> users = userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

@Test
void test3() {
    //查询年龄在20和30之间的用户
    //第一种方法用between，第二种方法用ge和le
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",20,30);
    //方法二：wrapper.ge("age",20).le("age",30);
    List<User> users = userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}

@Test
void test4() {
    //模糊查询，查询名字里存在“张”的用户
    //like("name", "张")--->name like '%张%'
    //模糊查询，查询名字是以“张”开头的用户
    //likeLeft("name", "张")--->name like '%张'
    //模糊查询，查询名字是以“张”结尾的用户
    //likeRight("name", "张")--->name like '张%'
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.like("name","张");
    //wrapper.likeLeft("name","张");
    //wrapper.likeRight("name","张");
    List<User> users = userMapper.selectList(wrapper);
    for (User user : users) {
        System.out.println(user);
    }
}
//还有好多，就不一个一个测试了，具体的可以去MP官网查询

代码生成器

package com.shen;

import com.baomidou.mybatisplus.annotation.DbType;
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 com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;

/**
 * MP的代码自动生成器
 *
 * @Auther Shen
 * @Date 2020-07-11
 */

public class CodeGenerator {
    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("Shen");
        gc.setOpen(false); //执行完成后是否打开资源管理器
        gc.setFileOverride(false); // 是否覆盖已有文件
        gc.setServiceName("%sService"); // 去Service的I前缀
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);// 是否开启swagger2模式
        mpg.setGlobalConfig(gc);
        //2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone = GMT");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("sznshige250");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        //3、包的配置
        PackageConfig pc = new PackageConfig();
        //pc.setModuleName("blog");
        pc.setParent("com.shen");
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);
        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("User"); // 设置要映射的表名
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true); // 自动lombok；
        strategy.setLogicDeleteFieldName("deleted"); //逻辑删除对应的字段
        // 自动填充配置,数据进行插入或更新的时候，自动填充或者更新时间
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);
        // 乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true); //localhost:8080 / hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }
}

代码生成器所依赖的包

<!--==============数据库层面======================-->
<!--lombok,MP代码生成器需要用到-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!--mysql驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--MybatisPlus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version>
</dependency>
<!--MP的代码生成器-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.3.2</version>
</dependency>
<!--MP代码生成器所需要的渲染的模板引擎-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>
<!-- p6spy用来生成SQL日志 -->
<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
    <version>3.9.0</version>
</dependency>
<!--Swagger2,MP的代码生成器也可以自动生成-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<!--Controller层需要，MP代码生成器也需要-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

注意点：MP的代码生成器不能生成P6Spy的配置，所以需要自己手动配置

以上就完成了所有的MP学习????

转载请标明出处https://blog.csdn.net/weixin_44001012