mybatisplus--使用说明书

最新推荐文章于 2025-05-11 14:01:47 发布

xiaoxiaokunkunkun

最新推荐文章于 2025-05-11 14:01:47 发布

阅读量633

点赞数 1

CC 4.0 BY-SA版权

文章标签： mybatis

本文链接：https://blog.youkuaiyun.com/kunug/article/details/110627913

首先感谢狂神视频的帮助，狂神牛皮，哈哈哈哈哈

MyBatisPlus概述（简称mp）

为什么要学习它呢？MyBatisPlus可以节省大量工作时间，所有的CRUD代码它都可以自动化完成！

是什么？简单理解就是mybatis 的升级版，是mybatis更好用

官网：https://mp.baomidou.com/ MyBatis Plus，简化 MyBatis ！

特点

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

损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作， BaseMapper

强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分

CRUD 操作，更有强大的条件构造器，满足各类使用需求, 以后简单的CRUD操作，它不用自己编写

了！

支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错

支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配

置，完美解决主键问题

支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大

的 CRUD 操作

支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）

内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、

Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（自动帮你生成代码）

内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同

于普通 List 查询

分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、

Postgre、SQLServer 等多种数据库

内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢

查询

内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误

操作

快速入门（可以跟着官方文档搭建一个快速入门案例，写的非常清楚）

地址：https://mp.baomidou.com/guide/quick-start.html#初始化工程

1、创建数据库mybatis_plus_test

2、创建数据库

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

-- 真实开发中，version（乐观锁）、deleted（逻辑删除）、create_time、update_time  这些字段后面学习会用到

3、编写项目，初始化项目！使用SpringBoot初始化！

4、导入依赖(这里我先把后面会用到的依赖都导入进来)

这里需要注意尽量不要同时导入 mybatis 和 mybatisplus！版本的差异！

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

<!--数据库驱动-->
<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>

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

<!--代码生成器-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.0.5</version>
</dependency>
<!--模板引擎-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</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>

<!--test测试-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!--springMVC-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.66</version>
</dependency>

5、连接数据库！这一步和 mybatis 相同！

# mysql 5 驱动不同 com.mysql.jdbc.Driver
# mysql 8 驱动不同com.mysql.cj.jdbc.Driver、需要增加时区的配置 serverTimezone=GMT%2B8
#mysql配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus_test?serverTimezone=UTC&characterEncoding=utf-8
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus_test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=tom
spring.datasource.password=123456

6、传统的使用mybatis需要自己手动写很多简单crud，使用了mybatis-plus 之后

domain

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user")
public class User {

    @TableId(value = "id",type = IdType.AUTO)//设置主键自增  这里需要注意，设置主键自增的时候不要忘记数据库也要设置主键自增
    private Long id;
    private String name;
    private Integer age;
    private String email;
    }

mapper接口

这里需注意点，我们需要在主启动类上去扫描我们的mapper包下的所有接口

@MapperScan("club.znyf.mybatis_plus_ks.mapper")  //一定不要忘记配置，扫描mapper包下的所有接口

package club.znyf.mybatis_plus_ks.mapper;

import club.znyf.mybatis_plus_ks.domain.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper extends BaseMapper<User> {
    //这里已经实现了基本的crud操作
}

7、测试

@SpringBootTest
class MybatisPlusKsApplicationTests {

    @Autowired
    UserMapper userMapper;

    @Test
    void contextLoads() {
        //wrapper是一个条件构造器 它的实现类是QueryWrapper
        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }
  }

配置日志

现在执行的sql是看不见的，我们想看见是怎么执行的，所以在在propertites文件中配置

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

CRUD操作

插入操作

@Test
public void testInsert() {
    User user = new User();
    user.setName("ks");
    user.setAge(23);
    int insert = userMapper.insert(user);
    System.out.println(insert);//受影响的行数
    System.out.println(user);  //控制台打印结果可以看出，id可以自动回填
}

主键生成策略

mp默认的是生成策略是ID_WORKER 全局唯一id

我这里设置的是主键策略为自增

1、那么就需要在实体类字段上加

@TableId(value = "id",type = IdType.AUTO)//设置主键自增  这里需要注意，设置主键自增的时候不要忘记数据库也要设置主键自增
private Long id;

2、数据库字段别忘记改为自增！

3、再次测试即可发现id自增了

更新操作

/**
 * 这里测试version注解的时候就不会成功，
 * 因为是我们自己创建的User对象，
 * version字段为空所以不会更新version
 */
@Test
public void testUpdate() {
    User user = new User();
    user.setId(6l);
    user.setName("ksksss");
    user.setAge(214);
    int i = userMapper.updateById(user);
    System.out.println(i);
}

自动填充

创建时间、修改时间这些我们一般都希望是自动生成，不要我们去手动更新！

阿里巴巴开发手册：所有的数据库表：gmt_create、gmt_modifified几乎所有的表都要配置上！而且需

要自动化！

1、给表上新加上create_time 和 update_time字段不要设置默认值

2、给实体类也同步加上这两个字段，同时增加@TableField注解

 /**
     * 这里需要注意导入Date类的时候，导入的是util包下的，不要导成sql包下的，
     * 两者之间的区别util包下的Date带日期和时间,sql包下的Date只有日期
     */
    @TableField(fill = FieldFill.INSERT)  //插入时自动填充
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)//插入或更新时自动填充
    private Date updateTime;

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

package club.znyf.mybatis_plus_ks.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;

/**
 * @Classname MyMetaObjectHandler
 * @Description TODO
 * @Date 2020/11/30 22:39
 * @Created by asus
 */

@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 update ....");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

4、测试插入和更新、并观察是否有时间变化

乐观锁

什么是乐观锁

乐观锁 : 故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，再次更新值测试

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

乐观锁的机制

乐观锁实现方式：

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

乐观锁：
1、先查询，获得版本号 version = 1 
-- A 
update user set name = "hekun", version = version + 1 where id = 2 and version = 1 
-- B 线程抢先完成，这个时候 version = 2，会导致 A 修改失败！ 
update user set name = "hekun", version = version + 1 where id = 2 and version = 1

mp中实现乐观锁插件

1、给数据库中增加version字段并设置默认值为1

2、为实体类加对应的字段并加上注解

@Version    //乐观锁
private Integer version;

3、在MybatisPlusConfig类中注册乐观锁组件

package club.znyf.mybatis_plus_ks.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.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @Classname MybatisPlusConfig
 * @Description TODO
 * @Date 2020/11/30 23:05
 * @Created by asus
 */
@EnableTransactionManagement
@Configuration  //表明是一个配置类,相当于spring中xml配置文件的作用
public class MybatisPlusConfig {

    //注册乐观锁插件
    @Bean  //等同于xml配置文件中的<bean>标签
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }
    
    //========下面的插件先不看后面才会用到========

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

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

    //sql执行效率插件
    @Bean
    @Profile({"dev","test"}) //设置在 dev test 环境开启 ，注意别忘记在springboot中配置环境为dev 或者test
    public PerformanceInterceptor performanceInterceptor(){
        PerformanceInterceptor performanceInterceptor=new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true);//是否格式化代码
        return performanceInterceptor;
    }
}

4、测试乐观锁

测试成功可以发现version+1了

这里需要注意具体看看第一个test类

/**
 * 这里测试version注解的时候就不会成功，
 * 因为是我们自己创建的User对象，
 * version字段为空所以不会更新version
 */
@Test
public void testUpdate() {
    User user = new User();
    user.setId(6l);
    user.setName("ksksss");
    user.setAge(214);
    int i = userMapper.updateById(user);
    System.out.println(i);
}


//测试乐观锁成功案例
@Test
public void testoptimisticLocker1() {

    User user = userMapper.selectById(12l);
    user.setName("hk");
    user.setAge(23);
    int i = userMapper.updateById(user);
    System.out.println(i);
}

//测试乐观锁失败的案例（模拟多线程情况下）
@Test
public void testoptimisticLocker2() {
    //线程一
    User user1 = userMapper.selectById(12l);
    user1.setName("hk111");
    user1.setAge(23);

    //线程二，插队了
    User user2 = userMapper.selectById(12l);
    user2.setName("hk222");
    user2.setAge(23);
    int i2 = userMapper.updateById(user2);

    int i1 = userMapper.updateById(user1); //查看控制台输出可以看到 影响行数为0，而且id为12的行name字段为hk222
                                          // 说明这句更新操作没有成功，原因就是version
                                          //如果没有这里没有乐观锁这里就会覆盖插队线程二的值
}

查询操作

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

/**
 * 根据id批量查询
 */
@Test
public void testSelectIds() {
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    for (User user : users) {
        System.out.println(user);
    }
}

/**
 * 按条件查询之map
 */
@Test
public void testSelectByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","hk");
    List<User> users = userMapper.selectByMap(map);
    for (User user : users) {
        System.out.println(user);
    }
}

/**
 * 按条件查询之QueryWapper
 */
@Test
public void testSelectQuserWapper() {
    List<User> users = userMapper.selectList(new QueryWrapper<User>().between("age", 18, 23));
    for (User user : users) {
        System.out.println(user);
    }
}

分页查询

分页有多种

1、使用手动使用limit

2、使用第三次分页插件如pagehelper

3、mp其实也内置了分页插件

怎么mp中如何去使用？

1、在MybatisPlusConfig中配置分页拦截器组件

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

2、直接使用page对象即可

/**
 * 分页查询
 */
@Test
public void testpage() {
    Page<User> page = new Page<User>(1, 2);
    IPage<User> userIPage = userMapper.selectPage(page, null);
    List<User> records = userIPage.getRecords();//这里也可以使用page对象调用getRecords()
    for (User record : records) {
        System.out.println(record);
    }
    System.out.println(userIPage.getTotal());
}

删除操作

/**
 * 根据id删除
 */
@Test
public void testDelete() {
    User user = userMapper.selectById(1l);
    userMapper.deleteById(user.getId());
}

/**
 * 根据id批量删除
 */
@Test
public void testDeleteIdS() {

    int i = userMapper.deleteBatchIds(Arrays.asList(4l, 5l));
}

/**
 * 删除操作之map
 */
@Test
public void testDeleteByMap() {
    Map map=new HashMap<String,Object>();
    map.put("name","hk");
    int i = userMapper.deleteByMap(map);
}

/**
 * 删除操作之前QueryWapper
 */
@Test
public void testDeleteQueryWapper() {
    int delete = userMapper.delete(new QueryWrapper<User>().eq("name", "hk"));
}

逻辑删除

实在在很多时候使用的是逻辑删除，很少使用物理删除，可以这里理解逻辑删除和物理删除，当我们设置为逻辑删除时，就好比我们将电脑上的文件删除了会存在回收站一份，而并非真正的删除。而物理删除，就是将回收站清空，真正删除

物理删除：从数据库中直接移除

逻辑删除：再数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1

mp中如何设置逻辑删除？

1、在数据库表中增加字段deleted，一般默认值设置为0 表示未删除 1 表示删除

2、实体类中增加deleted属性

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

3、在MybatisPlusConfig中配置逻辑删除插件

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

4、在propertites文件中配置

#逻辑删除配置
#逻辑已删除值(默认为1)  #这里有一个坑在properties文件中 一行配置文件之后不要使用#注释，否者会出现不知道的错误
mybatis-plus.global-config.db-config.logic-delete-value=1 
#逻辑未删除值(默认为0)
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5、测试删除

可以发现删除走的更新操作，而不是删除操作

/**
 * 根据id删除
 */
@Test
public void testDelete() {
    User user = userMapper.selectById(1l);
    userMapper.deleteById(user.getId());
}

/**
 * 根据id批量删除
 */
@Test
public void testDeleteIdS() {

    int i = userMapper.deleteBatchIds(Arrays.asList(4l, 5l));
}

性能开发插件

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

MP也提供性能分析插件，如果超过这个时间就停止运行！

性能开发插件在mp中的使用

1、在MybatisPlusConfig中配置性能开发插件

这里需要注意在springboot环境中指定为dev或者test

#设置环境为dev环境
spring.profiles.active=dev

//sql执行效率插件
@Bean
@Profile({"dev","test"}) //设置在 dev test 环境开启 ，注意别忘记在springboot中配置环境为dev 或者test
public PerformanceInterceptor performanceInterceptor(){
    PerformanceInterceptor performanceInterceptor=new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(100);//设置sql执行的最大时间，如果超过了则不执行
    performanceInterceptor.setFormat(true);//是否格式化代码
    return performanceInterceptor;
}

2、测试使用

@Test
void contextLoads() {
    //wrapper是一个条件构造器 它的实现类是QueryWrapper
    List<User> users = userMapper.selectList(null);
    for (User user : users) {
        System.out.println(user);
    }
}
/**
控制台打印输出   可以发现这条sql语句用时36ms
 Time：36 ms - ID：club.znyf.mybatis_plus_ks.mapper.UserMapper.selectList
Execute SQL：
    SELECT
        id,
        name,
        age,
        email,
        create_time,
        update_time,
        version,
        deleted 
    FROM
        user 
    WHERE
        deleted=0
        **/

条件构造器

QueryWapper

用好了可以简化我们很大的开发，它可以写出绝大部分的sql，详细使用建议查看mp官方文档

package club.znyf.mybatis_plus_ks;

import club.znyf.mybatis_plus_ks.domain.User;
import club.znyf.mybatis_plus_ks.mapper.UserMapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;
import java.util.Map;

@SpringBootTest
public class WrapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        // 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        List<User> users = userMapper.selectList(userQueryWrapper.isNotNull("name")
                .isNotNull("email")
                .ge("age", 12));
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    void test2(){
        // 查询名字狂神说
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","hk");
        User user = userMapper.selectOne(wrapper); // 查询一个数据，出现多个结果使用List 或者 Map
        System.out.println(user);
    }

    @Test
    void test3(){
        // 查询年龄在 20 ~ 30 岁之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30); // 区间
        Integer count = userMapper.selectCount(wrapper);// 查询结果数
        System.out.println(count);
    }

    // 模糊查询
    @Test
    void test4(){
        // 查询年龄在 20 ~ 30 岁之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 左和右  t%
        wrapper
                .notLike("name","e")
                .likeRight("email","t");

        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

    // 模糊查询
    @Test
    void test5(){

        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // id 在子查询中查出来
        wrapper.inSql("id","select id from user where id<3");

        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

    //测试六
    @Test
    void test6(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 通过id进行排序
        //wrapper.orderByAsc("id");
        wrapper.orderByDesc("id");

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

}

代码自动生成神器啊！！！

mapper、domain、service、controller都可以自动生成完成！

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、

Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

这里我也是简单介绍一下怎么使用，更详细的使用方法建议还是去看官方文档

这里使用时还需要注意一点，自动生成完代码后该配置的文件还得必须配，不然会报莫名其妙的错误

建议使用时，先将propertites文件写好包括数据库连接信息等等；

mybatisplus配置类改加的插件也先加好；

pom文件依赖该引入的引入；

如其他插件也有需要配置类，也该配置的配置，如Swagger2Configuration；

package club.znyf.mybatis_plus_ks;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
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;
import java.util.List;

/**
 * @Classname CodeGenerator
 * @Description TODO
 * @Date 2020/12/1 1:51
 * @Created by asus
 */
//代码自动生成器
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("hekun"); //设置作者名字
        gc.setOpen(false); //生成完后是否打开资源管理器，也就是文件夹
        gc.setFileOverride(false);//是否覆盖原来生成的
        gc.setServiceName("%sService");//去掉Service的I前缀
        gc.setIdType(IdType.AUTO);//设置主键生成策略
        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_test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("tom");
        dsc.setPassword("123456");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 3包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog");
        pc.setParent("club.znyf"); //生成的代码位置在club.znyf.blog下
        pc.setEntity("domian");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        // 4策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//设置要映射的表名(是一个可变参数)
        strategy.setTablePrefix("t_");//去掉表前缀的t_
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        //strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);//自动lombok
        strategy.setLogicDeleteFieldName("deleted");//设置逻辑删除
        //自动填充配置
        TableFill create_time = new TableFill("create_time", FieldFill.INSERT);
        TableFill update_time = new TableFill("update_time", FieldFill.INSERT_UPDATE);
        List<TableFill> list=new ArrayList<>();
        list.add(create_time);
        list.add(update_time);
        strategy.setTableFillList(list);

        //乐观锁配置
        strategy.setVersionFieldName("version");

        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true); //loclhost:8080/hello_id_2

        mpg.setStrategy(strategy);

        mpg.execute(); //执行
    }

}

最后

最后将我这次学习mybatisplus使用到的一些配置文件都全部帖出来，方便下次再见复习在看！

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.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>club.znyf</groupId>
    <artifactId>mybatis_plus_ks</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis_plus_ks</name>
    <description>Demo project for Spring Boot</description>

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

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

        <!--数据库驱动-->
        <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>

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

        <!--代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.0.5</version>
        </dependency>
        <!--模板引擎-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </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>

        <!--test测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--springMVC-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.66</version>
        </dependency>
    </dependencies>

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

</project>

application.propertites文件

#设置环境为dev环境
spring.profiles.active=dev
#mysql配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus_test?serverTimezone=UTC&characterEncoding=utf-8
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus_test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=tom
spring.datasource.password=123456
#日志配置
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#逻辑删除配置
#逻辑已删除值(默认为1)  #这里有一个坑在properties文件中 一行配置文件之后不要使用#注释，否者会出现不知道的错误
mybatis-plus.global-config.db-config.logic-delete-value=1 
#逻辑未删除值(默认为0)
mybatis-plus.global-config.db-config.logic-not-delete-value=0 
#mapper.xml配置文件位置
mybatis-plus.mapper-locations=classpath*:mapper/*Mapper.xml
#表字段-映射为驼峰
#mybatis-plus.configuration.map-underscore-to-camel-case=true
#主键类型设置为数据库ID自增
#mybatis-plus.global-config.db-config.id-type=auto

MybatisPlusConfig.java文件

package club.znyf.hk_mybatisplus.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.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;

/**
 * @Classname MybatisPlusConfig
 * @Description TODO
 * @Date 2020/11/30 23:05
 * @Created by asus
 */
//@EnableTransactionManagement
@Configuration  //表明是一个配置类,相当于spring中xml配置文件的作用
public class MybatisPlusConfig {

    //注册乐观锁插件
    @Bean  //等同于xml配置文件中的<bean>标签
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }

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

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

    //sql执行效率插件
    @Bean
    @Profile({"dev","test"}) //设置在 dev test 环境开启 ，注意别忘记在springboot中配置环境为dev 或者test
    public PerformanceInterceptor performanceInterceptor(){
        PerformanceInterceptor performanceInterceptor=new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);//设置sql执行的最大时间，如果超过了则不执行
        performanceInterceptor.setFormat(true);//是否格式化代码
        return performanceInterceptor;
    }
}

Swagger2Config.java文件

package club.znyf.hk_mybatisplus.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

//
@Configuration
@EnableSwagger2
public class Swagger2Configuration {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("club.znyf"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("mybaitsplus文档")
                .description("mybaitsplus文档")
//                .termsOfServiceUrl("/")
                .version("1.0")
                .build();
    }

}

实体类User.java文件

package club.znyf.mybatis_plus_ks.domain;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * @Classname User
 * @Description TODO
 * @Date 2020/11/30 21:46
 * @Created by asus
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("user")
public class User {

    @TableId(value = "id",type = IdType.AUTO)//设置主键自增  这里需要注意，设置主键自增的时候不要忘记数据库也要设置主键自增
    private Long id;
    private String name;
    private Integer age;
    private String email;

    /**
     * 这里需要注意导入Date类的时候，导入的是util包下的，不要导成sql包下的，
     * 两者之间的区别util包下的Date带日期和时间,sql包下的Date只有日期
     */
    @TableField(fill = FieldFill.INSERT)  //插入时自动填充
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)//插入或更新时自动填充
    private Date updateTime;

    @Version    //乐观锁
    private Integer version;

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

}