Mybatis-plus终极入门教程,简单上手,适合初学者,快来看看吧

梵高的猪v

已于 2022-05-25 11:57:19 修改

阅读量1k

点赞数

分类专栏： MyBatis 文章标签： Mybatis MybatisPlus

于 2022-05-25 11:57:05 首次发布

本文链接：https://blog.csdn.net/weixin_47303191/article/details/124963485

版权

MyBatis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

重启mysql服务(cmd)

删除当前mysql服务：mysqld --remove 服务名称
查看是否存在data文件夹，有就将里面的文件都删除，没有就新建一个。
注册mysql 服务mysqld -install
初始化mysql：mysqld --initialize
初始化过程中会把登录密码初始化，可以在data文件中找到以.err结尾的文件
启动mysql服务：net start 服务名
登录mysql:mysql -uroot -p密码
修改密码：ALTER USER “root”@“localhost” IDENTIFIED BY “你的新密码”;

持久化框架

hibernate：全自动的ORM框架，实现java object —表的映射。可以通过Java对象的方法，操作表中的数据，开发人员可以不了解或少了解sql语言。可以使用hibernate访问不同的数据库，不需要改变代码，通用不同的数据库。
jpa规范，定义了访问数据库的各种操作，定义了一致的方法操作数据库，jpa有各种是心啊，hibernate，open-jpa，link
mybatis：需要编写xml配置文件，在xml文件中编写sql语句，访问数据库，任何的操作需要使用xml文件。
mybatis-plus：俗称mp，给mybatis又包装了一层，不再使用xml文件配置。

初始demo

创建一个springboot工程，选择mysql模板服务，注意创建完毕后，会出现一个properties文件

# 应用名称
spring.application.name=mp
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
spring.datasource.name=defaultDataSource
# 数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/blue?serverTimezone=UTC
# 数据库用户名&密码：
spring.datasource.username=***
spring.datasource.password=***

该文件用来配置和数据库连接的信息。

但为了方便，可以将其删除，创建一个名字一样，但是后缀是yml的文件，然后配置连接信息

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hyb?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 你的密码

pom.xml文件主要配置

<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>
            <version>8.0.25</version>
        </dependency>

        <!--mybatis-plus-->
        <!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.4</version>
        </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>

字和属性遵循驼峰命名规则，如数据库t_user类的名字就得是tUser。

package com.hyb.bean;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

public class tUser {

    /*
    * mp内置注解，value代表主键字段的名称，如果是id，可以不用写
    * type，表示主键的值是如何生成的，设置为自动增长
    * */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    private String name;

    private Integer age;

    private String email;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

编写Mapper接口实现BaseMapper

package com.hyb.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hyb.bean.tUser;

public interface UserMapper extends BaseMapper<tUser> {
}

给启动类编写扫描注解

package com.hyb.mp;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(value = "com.hyb.mapper")
public class MpApplication {

    public static void main(String[] args) {
        SpringApplication.run(MpApplication.class, args);
    }
LAPTOP-MEE4I0AA\46894
}

编写测试类

package com.hyb.mp;

import com.hyb.bean.tUser;
import com.hyb.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SuppressWarnings("all")
@SpringBootTest
class MpApplicationTests {

    @Autowired
    UserMapper userMapper;

    @Test
    public void test1(){
        tUser user = new tUser();
        user.setAge(20);
        user.setEmail("468949484@qq.com");
        user.setName("hyb");
        int insert = userMapper.insert(user);
        System.out.println(insert);
    }

}

启动测试，可能出错有

Public Key Retrieval is not allowed

表示密码错误

Access denied for user ‘***’@‘localhost’ (using password: YES)

上面的情况一般有很多种错误

1）低版本的springboot才写data-username和data-password，springboot2后都写成username和password

2）password中如果是纯数字，比如00000会别识别成数字，要将用双引号括起来，变成字符串”00000“

3）注意是否存在两个配置文件，如propertites和yml文件，查看文件内是否有重复内容。

4）连接的driver和url可能有版本问题和时区问题

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver //8.0以上要加cj
    url: jdbc:mysql://localhost:3306/hyb?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false //serverTimezone=UTC避免时区的问题
    username: root 
    password: 你的密码 //密码不能错误，一般先自己在软件连接一下试试

5）授权问题，上网查阅。（如果软件能连接上而idea却连接不上，说明不是授权的问题）

6）接口占用问题，可能windows装上另一个版本的mysql，虽然这个版本的mysql没有连接，但是却开启了服务，将这个版本的服务关掉。其次，有可能是虚拟系统，例如你linux系统下mysql服务启动了。因为mysql公用一个端口3306，不能出现占用的情况。

日志输出

在yml文件夹里配置日志，执行方法的可输出日志，查看sql语句的信息

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

CRUD

插入

前面的初始demo已经演示过，这里不在展示，需要知道的一个特性是，insert插入后，会将原来的对象改变，例如：上面我们通过user对象作为参数传入insert方法里，执行后，这个user对象的id便可以获取到，页就是数据库自动生成的id。

更新

@Test
public void  Test2(){
    tUser hyb1 = new tUser(1, "hyb1", null, null);
    int i = userMapper.updateById(hyb1);
    System.out.println(i);
}

删除

按主键删除

@Test
public void Test3(){
    int i = userMapper.deleteById(new tUser(2, null, null, null));
    System.out.println(i);
}

按条件删除

    @Test
    public void test4(){
//        按照map删除，key为字段，value为该字段的某个值
        Map<String,Object> map=new HashMap<>();
        map.put("name","hyb1");
        map.put("age",20);
        int i = userMapper.deleteByMap(map);
        System.out.println(i);//删除为0
    }

批量删除

    @Test
    public void test5(){
//        List<Integer> ids=new ArrayList<>();
//        ids.add(3);
//        ids.add(4);
//        ids.add(5);
        List<Integer> ids= Stream.of(4,5,6).collect(Collectors.toList());
        int i = userMapper.deleteBatchIds(ids);
        System.out.println(i);

    }

查询

按照主键查询

@Test
public void test6(){
    tUser user = userMapper.selectById(8);
    if (user!=null){
        System.out.println(user.toString());
    }
}

按照条件查询

Map<String,Object> map=new HashMap<>();
map.put("name","hyb");
List<tUser> tUsers = userMapper.selectByMap(map);//查询全部传入null
for (tUser list:tUsers) {
    System.out.println(list);
}

批量查询

List<tUser> tUsers = userMapper.selectBatchIds(Stream.of(7, 8).collect(Collectors.toList()));
for (tUser t :
        tUsers) {
    System.out.println(t);
}

ActiveRecord（AR）

mp提供了Model类，只要我们实现这个Model类就能实现数据库表对类的映射。

第一步，编写与数据库表对应的实体类

package com.hyb.bean;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;

public class Employee extends Model<Employee> {

    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;

    private String name;

    private Integer age;

    public Employee() {
    }

    public Employee(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.hyb.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hyb.bean.Employee;

public interface EmployeeMapper extends BaseMapper<Employee> {
}

注意，该Mapper文件还是需要的，但是不用配置任何内容。

下面的例子，集成简单的CURD操作

package com.hyb.mp;

import com.hyb.bean.Employee;
import com.hyb.mapper.EmployeeMapper;
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
@SuppressWarnings("all")
public class ARTest {

//    @Autowired
//    EmployeeMapper employeeMapper;
//    实现Model类的好处是，我们连Mapper都不用自己注入了

    @Test
    public void test1(){
        Employee hyb = new Employee(null, "hyb", 20);
        hyb.insert();
    }

    @Test
    public void Test2(){
        Employee hyb1 = new Employee(1, "hyb1", 20);
        hyb1.updateById();
    }

    @Test
    public void  test3(){
        Employee employee = new Employee();
        boolean b = employee.deleteById(9);
//        若使用不带参的删除方法删除需要给对象的id赋值
        System.out.println(b);
    }

    @Test
    public void test4(){
        Employee employee = new Employee();
        Employee employee1 = employee.selectById(1);
//        List<Employee> employees =
//                employee.selectList(null);
//        System.out.println(employees.size());//传入null查询全部
        if (employee1!=null) {
            System.out.println(employee1.toString());
        }
    }


}

idType

前面在初始化demo中，给id上了一个注解，这个注解里就有代表id类型的type属性，而type属性的值页关系到idType来解释。
该idType除了auto自动增长外，还有多个其他类型的值。
- none，为空，表示非主键，这个一般都用得较少。
- auto，自动增长。
- input，手动输入
- id_worker，实体类用Long int，表中用bigint
- uuid，页代表唯一值，但是比较混乱，id_worker要比这号。
- id_worker_str，实体类用String ，表中用varchar。
- 注意：id_worker是根据雪花算法来计算出的一种比uuid更加有序的唯一id。
- 但从自3.3.0开始,默认使用雪花算法+UUID(不含中划线)，所以mp在新版本中使用ASSIGN_ID代替这三个随机id生成。

逻辑删除

用户产生删除要求，表明的确删除了，但是实际上并没有删除。在数据库中只是标识该行是否删除的字段值改变了。

给指定的列添加逻辑删除的注解

@TableLogic
private Integer delId;

在yml文件进行全局config配置

  global-config: #与之前的configuration同级
    db-config:
      logic-delete-value: 0 #要删除的值
      logic-not-delete-value: 1 #不进行删除的值
#      logic-delete-field:

测试

    @Test
    public void t1(){
        delMapper.deleteById(2);
//        UPDATE del_test SET deld=0 WHERE id=? AND deld=1
//        Del del = delMapper.selectById(1l);
        SELECT id,name,deld AS delId FROM del_test WHERE id=? AND deld=0 查询自动拼接上deld
//        System.out.println(del.toString());

    }

自定义唯一id生成器

package com.hyb.bean;

import com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator;
import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import com.baomidou.mybatisplus.core.incrementer.ImadcnIdentifierGenerator;

import java.util.Date;

public class CustomIdGenerator implements IdentifierGenerator {
    @Override
    public Number nextId(Object entity) {
        DefaultIdentifierGenerator dn = new DefaultIdentifierGenerator();
//        以上是默认的雪花算法，在高并发下会有重复
//        ImadcnIdentifierGenerator dn
//                = new ImadcnIdentifierGenerator(nextUUID(entity));
//        而新的雪花算法则不会重复
        long time = new Date().getTime();
        System.out.println(time);
        Long anx = dn.nextId(entity);
        System.out.println(anx);
        System.out.println(anx.toString()+time+"");
        return time+anx;
    }
}

自定义表名

在mp中，在类的上面用注解TableName来指定数据库表的名称，这样这个类就会自动映射到该表中，类名不用跟表名相等。

@TableName(value = "数据库表的名字")

自定义列名

在mp中，只要在类的属性上加上TableFiled注解便可以自定义表名

@TableField(value = "对应表的列名")

但在开发中尽量使用驼峰命名规则，这样在类中就不用每次都指定列名了。例如：数据表的属性为t_name 在类中对应的属性是tName。

自定义sql语句

在resource目录下，我们可以自定义xml文件，然后写上sql语句。

之后，在yml文件中，配置mp的哪里写上另一个属性。

mybatis-plus:
  mapper-locations: classpath*:/*mapper.xml

表示类路径下（resource）的以mapper结尾的xml文件

自动填充

在数据库表中，一些需要时刻变化的值，为避免我们每次都要手工修改，所以可以对其进行自动填充。例如：表的创建时间和每次的更新时间是随着操作表而变化的，这里我们就可以将其设置成自动填充的字段。

给类对应的字段添加注解

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

@TableField(fill=FieldFill.INSERT_UPDATE)
private java.util.Date updateTime;

实现接口

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

注意，实现该接口的时候，必须加上Component注解，而且，要启动类上加上@Import({MyMetaObjectHandler.class})注解，和乐观锁的配置一个道理，只要在中间加上逗号隔开就行了。

乐观锁

乐观锁的概念不再赘述

在mysql中，我们可以新增一个字段，用来记录该表的版本号。然后在对应的属性名上可以增加@Version注解来表示乐观锁

@Version
private Integer version;

然后需要配置config拦截器，新建Config类，在springboot启动类上加上注解@Import({“Config.class”})

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptorLocker() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    System.out.println("拦截器执行了------------------》锁");
    return interceptor;
}

测试，我们用两个更新操作模拟高并发下的情况，如果一个类要开始更新而又拿到了版本号，此刻如果有另一个人进行插队，且完成了操作，就会修改版本号，这个时候，第一个想要更新的人就不可以再更新了。

    @Test
    public void t2(){
//        查询操作，获取版本号
        Del del = delMapper.selectById(1);
        del.setId(1);
        del.setName("hyb");


//        模拟高并发，其他更新插队，del执行更新操作不会成功，
//        因为被del1修改后版本被改变，del当前的版本与后来的版本不一致
        Del del1 = delMapper.selectById(1);
        del1.setId(1);
        del1.setName("hyb1");
        delMapper.updateById(del1);
//        ==>  Preparing: UPDATE del_test SET name=?, deld=?, version=? WHERE id=? AND version=?
//        ==> Parameters: hyb2(String), 1(Integer), 1(Integer), 1(Integer), 0(Integer)
//        <==    Updates: 1
//         插队成功，更新版本号为1

        delMapper.updateById(del);
//==>  Preparing: UPDATE del_test SET name=?, deld=?, version=? WHERE id=? AND version=?
//==> Parameters: hyb(String), 1(Integer), 1(Integer), 1(Integer), 0(Integer)
//                <==    Updates: 0
//        修改失败，版本更替
    }

Wrapper类

该接口是mp封装的一个抽象类，其继承的类有QueryWrapper，UpdateWrapper用来封装具体的查询和更新条件，在mp3.0后，mp还支持lambda表达式的使用，内置了LambdaQueryWrapper和LambdaUpdateWrapper类来以lambda表达式来封装条件。

QueryWrapper

allEq

/*
* allEq(Map map)
* 封装查询条件的查询方法
* */
@Test
public void test1(){
    QueryWrapper<Employee> wrapper=new QueryWrapper<>();
    Map<String,Object> map=new HashMap<>();
    map.put("name","hyb1");
    map.put("age","20");
    wrapper.allEq(map);//传入空值代表查询全部
    List<Employee> employees = employeeMapper.selectList(wrapper);
    employees.forEach(stu-> System.out.println(stu));
}

但在allEq里还有一个重写的方法allEq(Map<R, V> params, boolean null2IsNull)该方法用来判断当Map条件有key的值为空时做出反应。

如果不指定第二个参数，当Map里存在null值的时候，默认是true，表示不忽略该空值条件，如果指定第二个参数为false，表示忽略Map里为空值的条件。

eq

/*
* eq(key , value)封装单个条件
* */
@Test
public void  test2(){
    QueryWrapper<Employee> e = new QueryWrapper<>();
    e.eq("name","zyl");
    List<Employee> employees = employeeMapper.selectList(e);
    employees.forEach(stu-> System.out.println(stu));
}

ne

和eq使用方法基本一样，表示不等于。

gt

表示某个key的值大于某个值的条件

ge

表示某个key的值大于等于某个值的条件

lt

表示某个key的值小于某个值的条件

le

表示某个key的值小于等于某个值的条件。

between

between（column,v1,v2)表示大于等于v1小于等于v2的条件

notBetween

notBetween（c，v1，v2）表示不在v1和v2范围的条件。

like

like(c,v) 在sql语句中，该方法会在v的值前后都加上%，表示模糊查询

notLIke

和like条件相反。用法一致。

leftLike和likeRight

和like条件一致，但leftLike会在值的前面加上%，likeRight会在值的后面加上%

isNull和isNotNull

(column) 参数传入列名，表示该列是否为空

in和notIn

参数先传入一个列名，然后传入一个或多个的条件，表示该列的值在或不在这些值之中。

inSql和notInSql

先传入一个列名，然后传入一条sql语句。该方法用来嵌套查询。例如：inSql(‘age’,"select age from m where id=1)"代表的sql语句是select * from t where age in (select age form m where id=1)

geSql，gtSql，leSql等

从上面的封装的方法中可以看出规律，这些方法表示封装sql子句，然后条件的谓语是in > < >=等。比如，gtSql(‘age’,"select age from m where id=1)"代表的sql语句是select * from t where age > (select age form m where id=1);

group by

该方法使用有些特殊，需要配合select方法使用

@Test
public void t3(){
    QueryWrapper<tUser> e = new QueryWrapper<>();
    e.select("name,count(*) count");
    e.groupBy("name");//如果传入多个分组条件，需要传入一个集合
    List<tUser> tUsers = userMapper.selectList(e);
    tUsers.forEach(tUser -> System.out.println(tUser));
}

orderByAsc和orderByDesc

直接使用，不用配合select方法使用，传入一个列名和多个列名，或列名的集合便可以。

orderBy

方法是升序和降序排序的结合

Children orderBy(boolean condition, boolean isAsc, R column);

Children orderBy(boolean condition, boolean isAsc, List<R> columns);

传入布尔条件，一般为true，isAsc代表是否升序排序，后者为一列或者多列的集合。

or和and

用来连接多个条件

    @Test
    public void  t4(){
        QueryWrapper<tUser> e = new QueryWrapper<>();
//        e.eq("name","hyb")
//                .or().eq("age",20);
        e.eq("name","hyb")
                .and(new Consumer<QueryWrapper<tUser>>() {
                    @Override
                    public void accept(QueryWrapper<tUser> tUserQueryWrapper) {
                        tUserQueryWrapper.eq("age",20);
                    }
                });
        List<tUser> tUsers = userMapper.selectList(e);
        tUsers.forEach(tUser -> System.out.println(tUsers));
    }

last

该方法可以在原有的sql语句后添加sql语句。直接用链式的方法在各个条件拼接的方法后调用就行了。一般用来拼接分页查询，如果在sql语句后拼接limit 谓语，就可以限定输出结果的数量。

exists和noExists

用来拼接sql语句谓语exists操作，后者跟sql子句查询。

分页

配置带有@Configuration注解的类。


//加上这个注解相当于配置文件
@Configuration
public class Config {

    /*
    * @bean注解会创建出一个对象，注入到容器里
    * */
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        System.out.println("---------------------------------"
        +"拦截器执行了"+"--------------------------------------"
        );
        return interceptor;
    }

}

将此文件放在和Springboot启动文件同目录下。或者另放一个目录，但要在启动类上加上@Import（{Config.class})的注解。

测试。

    public void t1(){
        QueryWrapper<tUser> qw = new QueryWrapper<>();
        Page<tUser> t = new Page<>(1,2);

        Page<tUser> tUserIPage = userMapper.selectPage(t, qw);
//        获取记录
        List<tUser> records =
                tUserIPage.getRecords();
        records.forEach(tUser -> System.out.println(tUser));
    }

获得的tUserIpage包含了多种方法，这些方法可以获取返回的分页信息。如：总页数，总记录数，当前页记录等。

自定义代码生成器

package com.hyb.mp;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class AutoMP {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://localhost/hyb?useUnicode=true&characterEncoding=utf8", "root", "15717747056HYb!")
                // 全局配置
                .globalConfig(builder -> {
                    builder.author("hyb") // 设置作者
                            // .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir(System.getProperty("user.dir") + "/src/main/java"); // 指定输出目录
//                            .commentDate("yyyy-MM-dd"); //调整时间格式
                })
                // 包配置
                .packageConfig(builder -> {
                    builder.parent("com.hyb") // 设置父包名
                            .moduleName("Auto") // 设置父包模块名
//                            .entity("entity")
//                            .service("service")
//                            .serviceImpl("serviceImpl")
//                            .controller("controller")
//                            .mapper("mapper")
//                            .xml("mapper")
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, System.getProperty("user.dir")+"/src/main/resources/mapper")); // 设置mapperXml生成路径
                })
                // 策略配置
                .strategyConfig(builder -> {
                    builder.addInclude(getTables("all")) // 设置需要生成的表名,多个用英文隔开

//                            .addTablePrefix("t_", "c_") // 设置过滤表前缀
                            .serviceBuilder()   // service 配置策略
                            .formatServiceFileName("%sService")
                            .formatServiceImplFileName("%sServiceImpl")
                            .entityBuilder()
                            .idType(IdType.AUTO)//设置主键类型
                            .columnNaming(NamingStrategy.underline_to_camel)//驼峰命名规则
                            .enableActiveRecord() //开启AR模式
//                            .enableLombok() // 开启Lombok
//                            .logicDeleteColumnName("deleted")   // 说明逻辑删除（软删除）是哪个字段
                            .enableTableFieldAnnotation()   // 属性上加说明注解
                            .controllerBuilder()    // controller 策略配置
                            .formatFileName("%sController")
                            .enableRestStyle()  // 开启 RestController
                            .enableHyphenStyle() //驼峰连字符
                            .mapperBuilder()    //mapper 策略配置
                            .superClass(BaseMapper.class)   // 继承哪个父类
                            .formatMapperFileName("%sMapper")
//                            .enableMapperAnnotation()   // @mapper 开启
                            .formatXmlFileName("$sMapper"); // xml 名

                }).execute();
    }

    protected static List<String> getTables(String tables) {
        return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));
    }
}