mybatis-plus(释放双手,告别高重复sql)

1.mybatisPlus简介

什么是mybatisPlus?

我们先来看一下mybatisPuls官网的简介,简单的来说就是mybatis的一个插件,配合mybatis使用,达到快速开发,我们在使用mybatis的时候,很多简单的增删改查,已经分页查询,我们要写很多次,重复写,而mybatisPlus就是给我们封装了一些简单的sql,我们不需要写sql,直接调用即可.就是可以让我们更加专注于业务逻辑,大大减少我们自己写sql对数据库进行crud操作.但是复杂的sql还是需要自己写.但是总的来说,大部分sql是不用我们自己写的.

mybatisPuls特性:

1.无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作， BaseMapper

2.强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分CRUD 操作，更有强大的条件构造器，满足各类使用需求, 以后简单的CRUD操作，它不用自己编写了！

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

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

5.支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类可进行强大的 CRUD 操作支持自定义全局通用操作：

6.支持全局通用方法注入（ Write once, use anywhere ）内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（自动帮你生成代码）

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

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

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

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

2.快速入门

我们先按照官网的快速入门先来了解下这个mybatisPuls到底能做什么?
接下来我们在进行深入研究,现在脑子里面有个一个认知,知道这是个什么东西?然后我们再进行深入的学习.

mybatisPuls官方快速入门地址

1.创建数据库:mybatis-puls,执行以下sql

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

执行完以上sql 可以得到以下这个表:

2.新建一个springBoot项目:并且导入依赖

<!-- 数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- mybatis-plus -->
<!-- mybatis-plus 是自己开发，并非官方的！ -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.0.5</version>
</dependency>

只要我们导入了mybatis-puls,就不需要我们自己导入mytais了,因为mybatisPuls已经自动帮我们导入了mybatis的依赖

3.连接数据库,配置连接数据库的信息
需要注意的是,新版数据库的驱动不同,需要增加驱动的时区

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

4.新建实体类

@Data //get和set方法
@ToString //ToString方法
@NoArgsConstructor //无参构造
@AllArgsConstructor  //有参构造
public class User {
    
    
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

原生的mybatis开发是需要:bean类->dao接口->mapper.xml文件->service->controller
5.现在则不需要怎么复杂:bean->mapper接口->使用

/**
 * 在对应的mapper上实现基本的接口就行  泛型就是我们需要操作的实体类
 */
@Repository //dao层
public interface UserMapper extends BaseMapper<User> {
    
    
    //所有的crud操作已经操作完成,因为BaseMapper中已经定义了需要常用的数据库操作
    //简化了mapper配置文件
}

6.在springBoot的启动类上加上这个注解(一定要加上这个注解)
7.测试:

@SpringBootTest
class MybatisPulsApplicationTests {
    
    

    //继承了 BaseMapper UserMapper所有的方法都继承于BaseMapper 也可以自己定义接口然后实现

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
    
    
        //参数是一个wrapper,条件构造器,查询的时候所带的条件,没有条件就是查询全部 传个null就行
        List<User> userList = userMapper.selectList(null);
        for (User user : userList) {
    
    
            System.out.println(user);
        }
    }

}

成功查询出数据
我们没有写sql,也没有写mapper配置文件就可以查出数据了,那是谁帮我们实现的呢?
我们继承的这个接口里面有很多的方法,mybatisPlus都给我们实现了.我们只需要调用即可

配置日志:application.properties 在中配置

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

配置了日志之后,我们就可以看到执行的sql以及执行的详细信息
插入操作:

    @Test
    void insertTest() {
    
    
        //会帮我们生成id
        User user = new User(null,"admin",25,"[email protected]");
        int insertCount = userMapper.insert(user); //返回插入后影响的行数
        System.out.println(insertCount);

    }

但是遇到的问题就是,我数据库的id是设置为自增列,但是他给我的却是一个long类型的数值,而且还是那么长,明显不是我们想要的结果.接下来,我们来看一下如何解决这个方案

主键生成策略
这里随便搜了一篇文章大家了解一下就行:有个概念就行
分布式唯一id方案

雪花算法：(我们这个long类型的id就是用的雪花算法生成的是mybatisPlus默认的)

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

3.主键自增策略

1.数据库的id字段要设置为自动递增
2.在实体类的id属性上标注: @TableId(type = IdType.AUTO)

IdType的值由这些,供我们进行选择,默认的就是,Id_WORKER

重新让数据库id自从从n开始的命令:
下次自增从6开始

alter table `user` auto_increment=6;

设置完之后我们在次执行插入操作:就不会在带上id属性而是根据数据库的自增来

其余属性解释

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

修改操作
修改的时候,底层使用的是?号占位符的方式,所以不用担心sql注入的问题
可以通过,我们给user设置的属性值,来动态配置sql

    @Test
    void updateTest() {
    
    
        //会帮我们生成id
        User user = new User(6L,"root",23,"[email protected]");
        int insertCount = userMapper.updateById(user); //根据id进行修改操作,返回修改的后影响的行数
        System.out.println(insertCount);

    }

自动填充:
创建时间,修改时间,这个操作一般都是自动化完成,不希望我们手动操作
阿里巴巴开发手册:所有的数据库表:gmt_create和gmt_modifled,几乎所有表都需要配置上这两个字段,而且需要自动化,也就是创建时间和修改时间.

方式1:数据库级别的修改(不建议使用)
1.在表中新增字段
2.实体类中新增两个属性:
private Date createTime;
private Date updateTime;
设置为按时间戳更新

方式2:代码级别:
1.删除掉刚刚数据库表设置的按时间戳自动更新

2.在实体类上的两个字段上添加@TableField注解

 @TableField(fill = FieldFill.INSERT) //插入的时候更新时间
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE) //修改的时候更新时间
    private Date updateTime;

3.编写处理器来处理我们标注的这个注解

@Component //把处理器添加到ioc容器中
@Slf4j
public class MyDataObjectHandler 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 update fill.....");
        this.setFieldValByName("updateTime",new Date(),metaObject);//更新时填充时间
    }
}

4.乐观锁

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

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

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

乐观锁：1、先查询，获得版本号 version = 1

-- A线程
update user set name = "admin", version = version + 1
where id = 2 and version = 1

-- B 线程抢先完成，这个时候 version = 2，会导致 A 修改失败！
update user set name = "admin", version = version + 1
where id = 2 and version = 1

测试一下mybatisplus的乐观锁插件

1.给数据库中增加version字段(int类型 默认值为1)
2.实体类添加version字段:并且添加 @version 注解
3.注册组件:

@SpringBootApplication
public class MybatisPulsApplication {
    
    

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

}

4.测试乐观锁:

  //单线程下测试乐观锁成功
    @Test
    public  void VersionTest1(){
    
    
        //查询用户信息
        User user = userMapper.selectById(1l);
        System.out.println(user);
        //修改用户信息
        user.setName("Toms");
        user.setAge(50);
        userMapper.updateById(user);
    }
    //多线程下测试乐观锁失败
    @Test
    public  void VersionTest2(){
    
    
         //线程1
        User user1 = userMapper.selectById(1l);
        user1.setName("Toms11");
        user1.setAge(501);

        //模拟另外一个线程插队操作
        User user2 = userMapper.selectById(1l);
        user2.setName("Toms22");
        user2.setAge(50);
        userMapper.updateById(user2);


        userMapper.updateById(user1);
    }

按条件查询:
map集合里面可以放多个值,每多放一个map就是多一个条件

    //条件查询 map集合里面可以放多个值
    @Test
    void selectMapTest(){
    
    
        HashMap<String, Object> map = new HashMap<>();
               map.put("name","admin");
        map.put("age","30");
        List<User> userList = userMapper.selectByMap(map);//查询name=某个值的user
        System.out.println("查询出来的结果"+userList);
    }

底层执行的sql:

SELECT id,name,age,email,create_time,update_time,version FROM user WHERE name = ? AND age = ?

4.分页查询

1.在myabtisConfig中注册分页插件

测试代码

 //分页查询
    @Test
    void PageTest(){
    
    

        //查询出来的数据都封装在userPage对象中
        Page<User> userPage = new Page<>(1,3); //current:查询那一页的数据 ,size:每页显示多少条数据
        userMapper.selectPage(userPage, null);
        List<User> userList = userPage.getRecords();
        userList.forEach(System.out::println);

        long pages = userPage.getPages();       //总共分了多少页
        System.out.println(pages);

        long size = userPage.getSize();
        System.out.println(size);               //每页显示的数量

        long current = userPage.getCurrent();
        System.out.println(current);             //当前页

        long total = userPage.getTotal();        //总记录数
        System.out.println(total);



    }

底层sql:其实在底层,mybatisPlus已经帮我们构建好了分页对象,我们只需要传入我们想要查询的数据范围就可以了
5.删除操作

 //按照id删除
    @Test
    void deleteTest(){
    
    
        int updateCount = userMapper.deleteById(5l);//返回值是删除后影响的行数
        System.out.println(updateCount);
    }

    //多条件删除 map key:字段名 value:字段值
    @Test
    void deleteMapTest(){
    
    
        HashMap<String, Object> map = new HashMap<>();
        //删除name=user And age=20 的用户
        map.put("name","user");
        map.put("age","20");
        userMapper.deleteByMap(map);//返回值是删除后影响的行数
    }

    //批量删除 deleteBatchIds 方法的参数是一个List数组
    //Arrays.asList() :工具类 将数组转为List集合
    @Test
    void deleteBatch(){
    
    
        //批量删除 id为 13 和 11 的记录
        userMapper.deleteBatchIds(Arrays.asList(13,11));//返回值是删除后影响的行数
    }

逻辑删除:并不是真正的删除掉该记录,而是给该记录增加一个字段deleted字段,用0和1来表示该记录到底有没有被删除掉 0表示为删除,1表示已删除

这样做有什么好处?
好处就是并不是真正的删除掉数据库中的记录,而是通过改变deleted的字段值来判断到底该记录没有没有被删除掉,我们查询的时候就带上条件,如果deleted=1的记录,我们就直接过滤掉不进行查询出来.
1.在数据库表中增加deleted字段(int类型 默认值为0)
2.在实体类中新增deleted字段 并且标注 @TableLogic注解
3.在mybatiPlusConfig配置类中添加该组件
4.测试:
需要注意的是:
1.字段名不能取名为delete 如果取为delete的话会有意想不到的错误,因为这是mysql的关键字嘛,字段名命名尽量不要使用mysql数据库的关键字
2.其实底层执行的时候并不是执行的delete语句,而是update语句

    //逻辑删除 //被删除的记录查询的时候会被直接过滤掉
    @Test //逻辑手粗id为14的记录
    void deleteLogicTest(){
    
    
      userMapper.deleteById(14l);
    }

5.性能插件分析

通过这个插件我们可以很清楚的分析出我们写的sql到底效率高不高,
有时候功能是达到了,但是每个人写的sql不同,sql的执行效率也不同,我们可以给sql执行规定一个时间,如果这条sql执行的时候,超出了我们预计的时间,那么这条sql就属于慢查询,是需要优化的.
1.老规矩,在mybatisPlusConfig中加入该组件
2.在springBoot配置文件中配置: spring.profiles.active=dev

    //性能测试插件
    @Bean
    @Profile({
    
    "dev","test"})
    public PerformanceInterceptor performanceInterceptor(){
    
    
        PerformanceInterceptor performanceInterceptor= new PerformanceInterceptor();
        performanceInterceptor.setMaxTime(100);   // ms(毫秒) 设置sql执行的最大时间 如果超过则不执行 报错
        performanceInterceptor.setFormat(true);  //是否开启格式化支持
        return performanceInterceptor;
    }

6.条件构造器

条件构造器,可以携带条件,写出更加复杂的sql,但也不是完全万能的,根据自己的需求使用,这里只列举了一部分.
具体看官网的文档使用:mybatisPlus官网地址

SpringBootTest
public class WrapperTest {
    
    

    @Autowired
    private UserMapper userMapper;

    //条件构造器测试
    @Test
      void contextLoads(){
    
    
        //查询name不为null的用户 并且邮箱不为null的用户 年龄大于等于18
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        QueryWrapper<User> users = wrapper.isNotNull("name").isNotNull("email").ge("age", 12);
        List<User> userList = userMapper.selectList(wrapper);
        userList.forEach(System.out::println);
    }

    @Test
    void selectOne(){
    
    
        //查询user为admin的用户  查询单挑记录  多条记录使用 selectList 或者使用Map
        QueryWrapper<User> wrapper = new QueryWrapper<>();
         wrapper.eq("name","user");
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

    @Test
    void selectBetweenAnd(){
    
    
        //查询年龄在 30-50的用户有多少人
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",30,50);
        Integer count = userMapper.selectCount(wrapper);
        System.out.println("30岁-50岁之间的用户有"+count+"人");
    }
    @Test
    void queryLike(){
    
    
        //模糊查询 查询name中带有admin的记录
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // wrapper.like("name","admin");                    //查询name字段中包含admin的记录
        //wrapper.notLike("name","admin");                  //查询name字段中不包含admin的记录
        wrapper.likeLeft("name","a");            // %a  :查询以a结尾的记录
       // wrapper.likeRight("name","a");                    // a%  :查询以a开头的记录
        List<Map<String, Object>> list = userMapper.selectMaps(wrapper);
       list.forEach(System.out::println);
    }

    //子查询
    @Test
    void inSqlTest(){
    
    
  //SQL：SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 AND id IN (select id from user where id>5)
        QueryWrapper<User> wrapper = new  QueryWrapper<>();
        wrapper.inSql("id","select id from user where id>5");
        List<Object> objectList = userMapper.selectObjs(wrapper);
        objectList.forEach(System.out::println);

    }
    //排序操作
    @Test
    void selectOrderByTest(){
    
    
        //按照id排序
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.groupBy("name");    //分组查询
        //wrapper.orderByAsc("id");          //按照id升序
        wrapper.orderByDesc("id");  //按照id降序

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

7.自动生成代码插件

这个插件的作用:我们只需要创建好数据库表,在java中配置好数据库的相应信息,就可以通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

具体使用看官网:mybatisPlus官网

1.创建数据库:book

2.创建t_user表(根据自己的业务需求设计数据库表)

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '主键自增id',
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '用户名',
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '密码',
  `email` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '邮箱',
  `phone` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '电话',
  `version` int NULL DEFAULT NULL COMMENT '乐观锁',
  `deleted` int NULL DEFAULT NULL COMMENT '逻辑删除',
  `gmt_create` datetime(0) NULL DEFAULT NULL COMMENT '插入自动填充',
  `gmt_modified` datetime(0) NULL DEFAULT NULL COMMENT '修改自动填充',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 100382 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES (1, 'admin', '123', '[email protected]', '123456789', 1, 0, '2021-02-05 19:32:12', '2021-02-05 19:32:14');

SET FOREIGN_KEY_CHECKS = 1;

3.新建springBoot项目,并且导入一下依赖

    <dependencies>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>3.0.0</version>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- lombok -->
        <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>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>

        <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>
    </dependencies>

4.新建一个类,创建出AutoGenerator 的实例,并且配置我们需要的功能和策略

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

public class AutoCreateCodeTest {
    
    
    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("compass");  //作者注释
        gc.setOpen(false);         //是否打开文件资源管理器
        gc.setFileOverride(false); // 是否覆盖原来的
        gc.setServiceName("%sService"); // 去Service的I前缀
        gc.setIdType(IdType.ID_WORKER); //id为雪花算法的自增长
        gc.setDateType(DateType.ONLY_DATE);//设置日期类型
        gc.setSwagger2(true);   //配置Swagger2
        mpg.setGlobalConfig(gc);   //将配置添加到 GlobalConfig 全局配置中
//2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/book_ctiy?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
         dsc.setDriverName("com.mysql.cj.jdbc.Driver"); //数据连接库驱动
        dsc.setUsername("root");   //数据库密码
        dsc.setPassword("2732195202");  //数据库密码
        dsc.setDbType(DbType.MYSQL);  //数据库为mysql

        mpg.setDataSource(dsc); //将配置添加到 GlobalConfig 全局配置中

//3、包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("book"); //模块名称
        pc.setParent("com.compass"); //包名
        pc.setEntity("bean");//实体类包
        pc.setMapper("mapper");//mapper包
        pc.setService("service");//service层
        pc.setController("controller");//controller层
        mpg.setPackageInfo(pc); //添加到全局配置对象中
//4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("t_user"); // 设置要映射的表名(可以写多张表,用逗号分隔)
        strategy.setNaming(NamingStrategy.underline_to_camel);  //下划线转驼峰命名 表
        strategy.setColumnNaming(NamingStrategy.underline_to_camel); //下划线转驼峰命名 列
        strategy.setEntityLombokModel(true); // 自动lombok；
        strategy.setLogicDeleteFieldName("deleted"); //逻辑删除
// 5.自动填充配置
        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);//Controller驼峰命名
        strategy.setControllerMappingHyphenStyle(true); //请求地址采用下划线命名 

        mpg.setStrategy(strategy); //将配置策略添加到AutoGenerator实例对象中
        mpg.execute(); //执行
    }

}

5.运行main方法,就可以创建出以下的目录结构,具体的业务逻辑当然还得我们自己来写

相关视频学习地址:b站链接