mybatis-plus(释放双手,告别高重复sql)
mybatis-plus
-
- 1.mybatisPlus简介
- 2.快速入门
- 3.主键自增策略
- 4.分页查询
- 5.性能插件分析
- 6.条件构造器
- 7.自动生成代码插件
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>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.0.5version>
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.springfoxgroupId>
<artifactId>springfox-swagger2artifactId>
<version>3.0.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.0.5version>
dependency>
<dependency>
<groupId>org.apache.velocitygroupId>
<artifactId>velocityartifactId>
<version>1.7version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
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站链接