Mybatis-Plus介绍
简介
MyBatis-Plus (opens new window)
（简称 MP）是一个
MyBatis (opens new window)
的增强工具，在 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 操作智能分析阻断，也可自定义拦截规则，预防误操作
快速开始
基本思路
1、导入对应的依赖
2、研究依赖的配置
3、代码如何编写
4、提高扩展技术
实现步骤
1、创建数据库
myBatis-plus
myBatis-plus
2、创建user表插入数据
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)
);
-- 真实开发中，version(乐观锁)、deleted(逻辑删除)、gmt_create(创建时间)、gmt_modified(修改时间)
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');
3、初始化项目
新建一个
springboot
，
maven
项目,详略
4、引入对应依赖
<!-- 数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- lombok 简化set get toString -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- mybatis-plus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3.1</version>
</dependency>
注意：使用mybatis-plus可以节省大量代码，不要同时导入mybatis和mybatis-plus，可能存在版本冲突
5、链接数据库(同mybatis)
注意，mysql 8 的驱动不同，而且需要加上时区的配置
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: root
password: 123456
#其中url中，数据库名称？是否使用安全链接，字符集编码，是否使用解码，设置时区
#mysql数据库用的是gbk编码，而项目数据库用的是utf-8编码。这时候如果添加了useUnicode=true&characterEncoding=UTF-8
#存数据时：
#数据库在存放项目数据的时候会先用UTF-8格式将数据解码成字节码，然后再将解码后的字节码重新使用GBK编码存放到数据库中。
#取数据时：
#在从数据库中取数据的时候，数据库会先将数据库中的数据按GBK格式解码成字节码，然后再将解码后的字节码重新按UTF-8格式编码数据，最后再将数据返回给客户端。
6.使用mybatis-plus
6.传统方式pojo层 dao层(链接mybatis, 配置mapper.xml文件) service层 controller层很繁琐
-
创建pojo类
@Data @AllArgsConstructor #有参构造器 @NoArgsConstructor #无参构造器 public class User { //常见的数据库中主键自动设置方法有（uuid、自增id、雪花算法、redis生成、zookeeper生成） private Long id; private String name; private Integer age; private String email; } -
在启动类加上
@mapper
注解,扫描
mapper
文件夹@SpringBootApplication @MapperScan("com.jdw.mapper") -
mapper接口
//在对应的Mapper 接口上 基础基本的 BaseMapper<T> T是对应的pojo类 @Repository //告诉容器你是持久层的 @Repository是spring提供的注释，能够将该类注册成Bean public interface UserMapper extends BaseMapper<User> { //所有的crud都编写完成了 }支持，
mybatis-plus
已经配置完成，可以直接使用，
CRUD
。 -
使用测试类
@Test
测试//继承了BaseMapper ,所有方法来自父类，可扩展 @Autowired private UserMapper userMapper; @Test void contextLoads() { System.out.println(("----- selectAll method test 测试查询所有用户方法 ------")); //selectList 的参数wrapper 是条件构造器，可以先写null List<User> userList = userMapper.selectList(null); //forEach 的参数是 Consumer类型的 语法糖 userList.forEach(System.out::println); }思考,我们没有写sql就查询了结果，那么，sql谁写的，方法哪来的？答案都是mybatis-plus.
日志配置
使用yml添加日志配置项
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
执行查询方法查看分析日志
执行上面的查询所有用户的方法查看日志
插入测试
插入及日志分析
//测试插入
@Test
public void testInsert(){
User user = new User();
user.setName("小蒋");
user.setAge(3);
user.setEmail("2474950959@qq.com");
//没有设置ID却自动生成的ID
int result = userMapper.insert(user);
System.out.println("result = " + result);
System.out.println("user = " + user);
}
日志分析
我们可以看到，并没有给user设置id，数据库自动插入了id=1453311479846608897，
注意，数据库插入的默认值是全局唯一的id,这个id看起来也太奇怪了，到底是怎么生成的呢？
主键生成策略
因为在最开始建表的sql语句中就指明了，id是数据库的主键，主键不能唯一，
常见的数据库中主键自动设置方法有（uuid、自增id、雪花算法、redis生成、zookeeper生成）
详情见：
分布式系统唯一ID生成方案
雪花算法
这里生成的id默认采用的是
雪花算法
：
snowflake是Twitter开源的分布式ID生成算法，结果是一个
long型的ID
。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter/snowflake。雪花算法支持的TPS可以达到419万左右（2^22*1000）,几乎保证全球唯一。雪花算法在工程实现上有单机版本和分布式版本。单机版本如下，分布式版本可以参看美团leaf算法：https://github.com/Meituan-Dianping/Leaf
可以在User类的id属性上加入注解TableId更改和查看策略
type = IdType.ASSIGN_ID，全局唯一id，雪花算法
public class User {
@TableId(type = IdType.ASSIGN_ID,value = "id")//枚举注解,使用ID_WORKER策略,全局唯一ID，数据库设置自增也没用
private Long id;
private String name;
private Integer age;
private String email;
}
进入这个注解
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD}) //枚举注解
public @interface TableId {
//可以设置以下两个参数
String value() default "";
IdType type() default IdType.NONE; //ID策略
}
主键自增策略
要是自增策略，在id上加入下列代码
@TableId(type = IdType.AUTO)
private Long id;
同时数据库设计时，一定要将id设计为自增，这样自增id会设置在最大值上加1
其他策略
public enum IdType {
/**
* 数据库ID自增
* <p>该类型请确保数据库设置了 ID自增 否则无效</p>
*/
AUTO(0),
/**
* 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
*/
NONE(1),
/**
* 用户输入ID
* <p>该类型可以通过自己注册自动填充插件进行填充</p>
*/
INPUT(2),
/* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
/**
* 分配ID (主键类型为number或string）,
* 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
*
* @since 3.3.0
*/
ASSIGN_ID(3),
/**
* 分配UUID (主键类型为 string)
* 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
*/
ASSIGN_UUID(4);
private final int key;
IdType(int key) {
this.key = key;
}
}
更新测试
更新及日志分析
//更新测试
@Test
public void testUpdateByID() {
User user = new User();
user.setId(7L);
user.setName("小小");
user.setAge(18);//这一行后加
int i = userMapper.updateById(user);//受影响的行数,参数是一个user不是id,点击看源码
System.out.println("i = " + i);
}
我可以发现，先只更新了名字，后面更新名字和年龄。mybatis-plus通过条件自动把我们进行了动态sql拼接，
自动填充
创建时间、更新时间！这个操作是自动化完成的，不要手动更新！
gmt_create、gmt_modified几乎在所有表都要配置上，而且自动化填充。gmt是时间时间的意思
方式一、数据库级别（不建议）
在数据库种添加字段gmt_create、gmt_modified，然后在pojo类中添加这两个属性，下次就可以查看了.(博主使用的是Navigat)
private Data gmtCreate;
private Data gmtModified;
方式二、代码级别
1、在数据库中删除掉根据当前时间戳更新的选项
2、在实体类的成员变量上添加注解
@TableField
//字段添加填充内容
@TableField(fill = FieldFill.INSERT ,value = "create_time")
private LocalDateTime createTime;
@TableField(fill = FieldFill.INSERT_UPDATE ,value = "update_time")
private LocalDateTime updateTime;
public @interface TableField { //源码
.....
/**
* 字段自动填充策略
* <p>
* 在对应模式下将会忽略 insertStrategy 或 updateStrategy 的配置,等于断言该字段必有值
*/
FieldFill fill() default FieldFill.DEFAULT;
...
}
//填充策略
public enum FieldFill {
/**
* 默认不处理
*/
DEFAULT,
/**
* 插入时填充字段
*/
INSERT,
/**
* 更新时填充字段
*/
UPDATE,
/**
* 插入和更新时填充字段
*/
INSERT_UPDATE
}
3、编写处理器来处理这个注解
@Slf4j //日志
@Component//以组件的形式把这个处理器注册到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
//插入时启动 第三个参数 LocalDateTime 一定要和 createTime成员变量的值的类型一致，不然是null 如果是date就都设置date
@Override
public void insertFill(MetaObject metaObject) {
log.info("start insert fill ....");
this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
}
//更新时候启动
@Override
public void updateFill(MetaObject metaObject) {
log.info("start update fill ....");
this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
}
}
4、接下来的代码执行插入、更新时都会自动设置时间了
乐观锁
乐观锁原理
乐观锁：顾名思义十分乐观，他总是认为不会出现问题，无论干什么都不会上锁！如果出现了问题，就再次更新值加锁处理
悲观锁：顾名思义十分悲观，他总是认为无论干什么都会出现问题，所以都会上锁，再操作！
乐观锁（OptimisticLockerInnerInterceptor）机制:
当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：
- 取出记录时，获取当前version
- 更新时，带上这个version
- 执行更新时， set version = newVersion where version = oldVersion
- 如果version不对，就更新失败
相当于给每一个记录都加一个version字段。当我们要改记录时，把version字段拿出来看一看，对比一下这个version 有没有在你操作数据时被其他线程更改，如果依然等于oldVersion，你就对数据进行操作同时把 version = newVersion 更新（比如+1），以此你在改数据的途中告诉其他线程不要读了
脏数据
。
--A 线程
update user set name = "jdw" ,version = version + 1 --version = newVersion version有默认值比如1
where id = 2 and version = 1 -- version = oldVersion
--B 线程 抢先完成，此时version=2,导致A线程的 version = oldVersion 不匹配A的oldVersion A将会修改失败,防止数据库产生脏数据
update user set name = "jdw" ,version = version + 1 --version = newVersion version有默认值比如1
where id = 2 and version = 1 -- version = oldVersion
乐观锁的应用
测试更新
1、在数据库添加version字段，int型,默认0,长度10,不自增
2、在User类中添加对应属性：
@Version //乐观锁注解
private int version;
说明: Version
支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
- 整数类型下
newVersion = oldVersion + 1
newVersion
会回写到
entity
中- 仅支持
updateById(id)
与
update(entity, wrapper)
方法
在
update(entity, wrapper)
方法下,
wrapper
不能复用!!!
3、在config下注册组件，开启乐观锁拦截器
@EnableTransactionManagement //开启事务
@Configuration //配置类注解
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());//乐观锁插件拦截器OptimisticLockerInnerInterceptor
return mybatisPlusInterceptor;
}
}
4.测试乐观锁
@Test
public void testOptimisticLocker(){
//1、查询用户信息
User user = userMapper.selectById(1L);
//2、修改用户信息
user.setEmail("123@qq.com");
user.setName("小垃圾");
//3、更新操作
userMapper.updateById(user);
}
在测试代码中我们并没有更新version数据库的version已经变成2了，下面是日志分析：
5.模拟多线程下乐观锁失败案例
@Test
public void testOptimisticLocker2(){
//模拟多线程
User user = userMapper.selectById(3L);
user.setEmail("123jdw@qq.com");
user.setName("帅小伙111");//我们在这里对线程1修改值
//线程2插队
User user2 = userMapper.selectById(3L);
user2.setEmail("321jdw@qq.com");
user2.setName("帅小伙222");
userMapper.updateById(user2); //线程2抢先提交
userMapper.updateById(user);//线程1失败，乐观锁在这种情况下防止了脏数据存在，没有乐观锁就会有覆盖掉线程2的操作
}
测试查询
1、查询单用户
//查询单用户
@Test
public void testSelectBatchId(){
User user = userMapper.selectById(1L);
System.out.println(user);
}
2、多用户查询
//查询指定多用户
@Test
public void testSelectBatchIds() {
//Arrays.asList()创建了一个固定大小的集合
List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));//参数Collection的集合
users.forEach(System.out::println);
}
// selectBatchIds 源码
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
日志分析：内部解析的是一个 IN 条件
3、条件查询
//条件查询，-- HashMap
@Test
public void testSelectByMap() {
HashMap<String, Object> map = new HashMap<>();
//定义查询条件
map.put("name", "小蒋"); //where k = v
map.put("age",3);
List<User> users = userMapper.selectByMap(map);
users.forEach(System.out::println);
}
日志分析
分页查询
1、配置拦截器
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());//创建乐观锁拦截器 OptimisticLockerInnerInterceptor
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); //插件分页拦截器，我的是mysql
return mybatisPlusInterceptor;
}
}
2、使用page对象即可
//测试分页查询
@Test
public void testPage() {
Page<User> page = new Page<>(1,5); //开启拦截器后，会注册一个page对象 当前页，每页条数
//方法源码： <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
userMapper.selectPage(page,null); //分页查询
page.getRecords().forEach(System.out::println); //获取分页后的数据 打印
System.out.println(page.getTotal()); //获取记录总数
}
/**源码
* 分页构造函数
*
* @param current 当前页
* @param size 每页显示条数
*/
public Page(long current, long size) {
this(current, size, 0);
}
日志分析
底层也是把他转化成limit
删除测试
常见删除
//删除测试
@Test
public void testDeleteById(){
userMapper.deleteById(1453324799370616833L);
// userMapper.delete(null); //全部删除
}
从上往下分别是：根据id删除，根据 entity 条件删除记录，通过多个id批量删除，根据map条件删除
逻辑删除
物理删除：在数据库中移除
逻辑删除：数据库中没有移除，而是在代码中使用一个变量来使他失效！(如：delete = 0 => delete = 1; )
就比如，管理员可以查看被删除的记录！防止数据丢失。类似于回收站。用户就没法查看删除记录。
1、在数据库添加deleted字段
2、同步实体类中，同时添加
@TableLogic//逻辑删除
注解
@TableLogic//逻辑删除
private Integer deleted;
3、在配置文件yml中配置
mybatis-plus:
global-config:
db-config:
logic-delete-field: flag # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以不加步骤2的注解)
logic-delete-value: 1 # 逻辑已删除值(默认为 1)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
4、测试删除
执行删除操作，实际上是执行更新操作，把deleted字段改为1了
@Test
public void testDeleteById(){
userMapper.deleteById(1L);
// userMapper.delete(null); //全部删除
}
数据库中也是没被上，改了值而已
如果我们再去查询这个id=1的用户发现，查不到，mybatis-plus 自动拼接了deleted字段在where中判断。
@Test
public void testSelectBatchId() {
User user = userMapper.selectById(1L);
System.out.println(user);
}
性能分析插件
官方使用的
p6spy
性能有损耗，推荐使用其他第三方性能分析插件，比如阿里巴巴的Druid。
条件构造器Wrapper（重点）
之前我们写crud时候经常碰到一个参数叫做
wrapper
，我们写的都是null，他到底是什么。
我们之前一直是增删改查，没有一个是带条件的，而这个条件构造器就相当于sql中加了一个where,
QueryWrapper和 UpdateWrapper,分别是用于生成查和改 的 sql 的 where 条件
例如, 查询多条记录与单条记录
@Test
void contextLoads() {
//----------查询多个
//查询一个复杂的，比如查询用户name、邮箱不为空，年龄大于20的用户
QueryWrapper<User> wrapper = new QueryWrapper<>(); //首先新建一个 QueryWrapper
//链式编程 添加查询条件
wrapper.isNotNull("name")
.eq("email","2455555659@qq.com")
.ge("age",12);
userMapper.selectList(wrapper).forEach(System.out::println);
//----------查询单个
User user = userMapper.selectOne(wrapper); //出现多个结果会报错，查询一个
System.out.println("user = " + user);
}
// eq相等 ne不相等， gt大于， lt小于 ge大于等于 le 小于等于
// equal/ not equal/ greater than/ less than/ less than or equal/ great than or equal/
日志分析，就是在where中添加了多个条件
区间查询与计数，between()，selectCount()
@Test
void test2() {
//查询区间内的记录
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.between("age",20,30);
Integer count = userMapper.selectCount(wrapper);
System.out.println("count = " + count);
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z14L81qV-1635498303245)(C:/Users/Dell/AppData/Roaming/Typora/typora-user-images/image-20211028220327420.png)]
模糊查询
@Test
void test3() {
//模糊查询
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.like("name",99) // 名字中 存在 99
.notLike("name",6) // 名字中 不存在 6
.likeRight("email",2) // 邮箱 最右边是m %m
.likeLeft("email","m"); // 邮箱 最左边是2 2%
userMapper.selectMaps(wrapper);
}
子查询（多表查询）
void test4() {
//子查询
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.inSql("id","select id from table where id <2");
userMapper.selectObjs(wrapper).forEach(System.out::println);
}
排序
@Test
void test5() {
//排序
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.orderByAsc("id"); //根据id升序排列 降序orderByDesc()略
userMapper.selectList(wrapper).forEach(System.out::println);
}
分组，条件
@Test
void test7() {
//分组排序
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.groupBy("version").having("version = 1");
userMapper.selectList(wrapper).forEach(System.out::println);
}
其他warpper条件见官网
官方链接，条件构造器
代码自动生成器（重点）
AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
使用步骤
配置依赖，添加如下依赖，当然，不要忘记还要 快速开始第一章节的依赖
<!-- mp 代码生成器 依赖 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.4.1</version>
</dependency>
<!-- 导入swagger -->
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>1.5.20</version>
</dependency>
<!-- 添加模板引擎，thymeleaf 还有freemarker都是模板引擎 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
在任意文件夹新建立一个类进行配置
类的代码如下
package com.jdw;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
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;
import java.util.List;
import java.util.Scanner;
// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {
/**
* <p>
* 读取控制台内容
* </p>
*/
public static String scanner(String tip) {
Scanner scanner = new Scanner(System.in);
StringBuilder help = new StringBuilder();
help.append("请输入" + tip + "：");
System.out.println(help.toString());
if (scanner.hasNext()) {
String ipt = scanner.next();
if (StringUtils.isNotBlank(ipt)) {
return ipt;
}
}
throw new MybatisPlusException("请输入正确的" + tip + "！");
}
public static void main(String[] args) {
// 代码生成器
//构建一个代码自动生成器对象
AutoGenerator mpg = new AutoGenerator();
// 1、创建全局配置类的对象
GlobalConfig gc = new GlobalConfig();
//获取当前项目路径
String projectPath = System.getProperty("user.dir");
System.out.println("projectPath = " + projectPath);
//自动生成代码存放的路径
gc.setOutputDir(projectPath + "/src/main/java");
//设置 --作者注释
gc.setAuthor("jdw");
//是否打开文件夹
gc.setOpen(false);
//是否覆盖已有文件
gc.setFileOverride(false);
//各层文件名称方式，例如： %sAction 生成 UserAction %s占位符
gc.setServiceName("%sService");
//设置日期策略 date类型
gc.setDateType(DateType.ONLY_DATE);
//设置主键策略 雪花算法
gc.setIdType(IdType.ASSIGN_ID);
//设置开启 swagger2 模式
gc.setSwagger2(true);
//把全局配置放入代码生成器
mpg.setGlobalConfig(gc);
// 2、数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://localhost:3306/vueblog?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai");
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("123456");
dsc.setDbType(DbType.MYSQL);
mpg.setDataSource(dsc); //把数据源配置加入到代码生成器
// 3、包配置
PackageConfig pc = new PackageConfig();
pc.setParent("com.jdw");
pc.setEntity("entity");
pc.setMapper("mapper");
pc.setService("service");
pc.setController("controller");
// ... 有默认值，点击查看源码
mpg.setPackageInfo(pc);//包加入代码生成器
// 4、策略配置
StrategyConfig strategy = new StrategyConfig();
//下划线转驼峰命名 表
strategy.setNaming(NamingStrategy.underline_to_camel);
// 下划线转驼峰命名字段
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
//实体类是否加上lombok注解
strategy.setEntityLombokModel(true);
//控制层采用RestControllerStyle注解
strategy.setRestControllerStyle(true);
// RequestMapping中 驼峰转连字符 -
strategy.setControllerMappingHyphenStyle(true);
//要映射的数据库表名 （重点）
strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
//添加表名前缀
//strategy.setTablePrefix("m_"); //自动拼接上m_
//逻辑删除字段名
strategy.setLogicDeleteFieldName("deleted");
//乐观锁字段名
strategy.setVersionFieldName("version");
// -------自动填充策略
ArrayList<TableFill> fillList = new ArrayList<>();
fillList.add(new TableFill("createTime", FieldFill.INSERT));
fillList.add(new TableFill("updateTime",FieldFill.INSERT_UPDATE));
// 参数是 List<TableFill> 的链表
strategy.setTableFillList(fillList);
mpg.setStrategy(strategy);
//---------------------------------
// 自定义配置
InjectionConfig cfg = new InjectionConfig() {
@Override
public void initMap() {
// to do nothing
}
};
// 如果模板引擎是 freemarker
String templatePath = "/templates/mapper.xml.ftl";
// 如果模板引擎是 velocity
// String templatePath = "/templates/mapper.xml.vm";
// 自定义输出配置
List<FileOutConfig> focList = new ArrayList<>();
// 自定义配置会被优先输出
focList.add(new FileOutConfig(templatePath) {
@Override
//输出了 静态资源下的 Mapper
public String outputFile(TableInfo tableInfo) {
// 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
+ "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
}
});
cfg.setFileOutConfigList(focList);
mpg.setCfg(cfg);
// FreemarkerTemplateEngine模板引擎
mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}
写在后面
感谢你看到这篇博客，博主目前是一名大四的在校生，目前也是处于学习阶段，希望我们一起进步。
对于mybatis plus的使用，如果各位有什么疑问欢迎骚扰，有时间我会回复，你的支持是我学习最大的动力，谢谢!
代码已经开源GitHub：
本博客全部代码地址