简介
MyBatis-Plus
(简称 MP)是一个 MyBatis
的增强工具,在 MyBatis
的基础上只做增强不做改变,为简化开发、提高效率而生。
愿景
我们的愿景是成为 MyBatis
最好的搭档,就像 魂斗罗 中的 1P、2P,基友搭配,效率翻倍。
特性
- 无侵入:只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑
- 损耗小:启动即会自动注入基本 CURD,性能基本无损耗,直接面向对象操作
- 强大的 CRUD 操作:内置通用 Mapper、通用 Service,仅仅通过少量配置即可实现单表大部分 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 操作智能分析阻断,也可自定义拦截规则,预防误操作
快速开始
我们将通过一个简单的 Demo 来阐述 MyBatis-Plus 的强大功能,在此之前,我们假设您已经:
- 拥有 Java 开发环境以及相应 IDE
- 熟悉 Spring Boot
- 熟悉 Maven
现有一张 User
表,其表结构如下:
其对应的数据库 Schema 脚本如下:
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)
);
其对应的数据库 Data 脚本如下:
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');
初始化工程
1、创建一个空的 Spring Boot 工程,添加web支持的那种
2、添加依赖pom
<!--数据库驱动-->
<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.3.2</version>
</dependency>
配置
在 application.yml 配置文件中添加数据库的相关配置:
spring:
datasource:
username: root
url: jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&useSSL=true&serverTimezone=UTC
password: Wl123456
driver-class-name: com.mysql.cj.jdbc.Driver
在 Spring Boot 启动类中添加 @MapperScan 注解,扫描 Mapper 文件夹:
package com.wu;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//扫描我们的mapper文件夹
@MapperScan("com.wu.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
public static void main(String[] args) {
SpringApplication.run(MybatisPlusApplication.class, args);
}
}
pojo
package com.wu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
mapper
package com.wu.mapper;
//在对应的Mapper上面继承基本的类 BaseMapper
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wu.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
@Repository//代表持久层
//@Mapper
public interface UserMapper extends BaseMapper<User> {
//所有的简单的CRUD操作babatis-plus已经编写完成了
//你不需要像以前的配置一大堆文件了
}
直接测试
package com.wu;
import com.wu.mapper.UserMapper;
import com.wu.pojo.User;
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
class MybatisPlusApplicationTests {
//继承了BaseMapper,所有的方法都来自父类,我们也可以编写自己的扩展方法
@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
//参数是一个Wrapper,条件构造器,我们这里先不用 ,为null就可以了
//查询全部用户
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}
结果
思考问题
1、SQL谁帮我们写的? Mybatis-Plus
2、方法哪里来的? Mybatis-Plus
日志
启动 mybatis 本身的 log 日志
实现方式比较简单,只需在application.yml中配置即可
#配置日志
#方式一:使用默认的
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 方式二 指定 mapper 文件所在的包
logging:
level:
com.wu.mapper: debug
CRUD扩展
主键生成策略
先插入一条语句测试一下,不设置id
@Test
//测试插入数据
public void testInsert(){
User user = new User();
user.setName("小明").setAge(20).setEmail("2921625957@qq.com");
int i = userMapper.insert(user); //返回一个影响的行数
System.out.println(i);
System.out.println(user);
}
看结果可以发现,它自动帮我们生成了一个id
雪花算法
snowflake是 Twitter开源的分布式ID生成算法,结果是一个long型的ID。其核心思想是:使用41bit作为毫秒数,10bit作为机器的ID(5个bit是数据中心,5个bit的机器ID),12bit作为毫秒内的流水号(意味着每个节点在每毫秒可以产生4096个ID),最后还有一个符号位,永远是0.可以保证几乎全球唯一!
你可以在字段上加上注解:比如
public class User {
//对应数据库中的主键
@TableId(type = IdType.AUTO)
private Long id;
private String name;
private Integer age;
private String email;
}
现在这个主键为自增,但是我们的数据库没有勾选主键自增,我们再次测试下刚刚的插入语句,看看会出现什么
肯定会报错,所以我们先把数据库的id勾选为自增,然后再测试
所以当注解为AUTO时候,数据库的主键也要为自增
其他的类型
public enum IdType {
/**
* 数据库ID自增
*/
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),
/**
* @deprecated 3.3.0 please use {@link #ASSIGN_ID}
*/
@Deprecated
ID_WORKER(3),
/**
* @deprecated 3.3.0 please use {@link #ASSIGN_ID}
*/
@Deprecated
ID_WORKER_STR(3),
/**
* @deprecated 3.3.0 please use {@link #ASSIGN_UUID}
*/
@Deprecated
UUID(4);
}
更新操作
//测试更新
@Test
public void testUpdate(){
//通过条件自动拼接动态sql
User user = new User();
user.setId(6L).setName("小红");
//注意:updateById 所以要传id 但是参数是一个对象
userMapper.updateById(user);
}
看下面的结果可以知道,它是根据你传递给它的参数实现自动配置的
自动填充
自动填充最常用的就是时间,create_time
,update_time
,这两个字段一般不需要我们自己手动的去添加和更新,下面有两种方法可以实现
1、数据库级别(公司一般不允许你修改数据库,所以不推荐使用,看看就好了)
首先在表中添加上面两个字段create_time
,update_time
,然后他们的数据类型为datetime
,然后把update_time
的更新勾上,如果没有这个选项,则把数据类型改为timestamp
,两个的默认值为CURRENT_TIMESTAMP
同步实体类
private Date createTime;
private Date updateTime;
然后测试插入和更新操作,看看时间的变化,我这里就不演示了
2、代码级别
1、在数据库里面删除上面两个字段的默认值,还有更新选项也取消勾选,只留下字段名和字段类型即可
2、然后在实体类字段上添加注解
//字段添加填充内容
//在插入的时候填充
@TableField(fill = FieldFill.INSERT)
private Date createTime;
//在插入和更新的时候填充
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;
参数参考
public enum FieldFill {
/**
* 默认不处理
*/
DEFAULT,
/**
* 插入时填充字段
*/
INSERT,
/**
* 更新时填充字段
*/
UPDATE,
/**
* 插入和更新时填充字段
*/
INSERT_UPDATE
}
3、然后我们需要自己编写一个处理器来处理这个注解
package com.wu.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;
@Component //一定不要忘记把处理器加到IOC容器中
@Slf4j
public class MyMetaObjectHandler implements MetaObjectHandler {
//插入时候的填充策略
@Override
public void insertFill(MetaObject metaObject) {
log.info("start insert fill ....");
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不对,就更新失败
这是个什么意思呢?
假如现在某条信息的version
为1
,A想要更新这条记录,它会先拿到它的oldversion
也就是1
,然后当A正准备更新这条记录的时候发现它的verison
变成2
了,肯定是被人插队了,然后A就取消更新,如果没有插队,A就会更新成功,version
加1
特别说明:
- 支持的数据类型只有:
int
,Integer
,long
,Long
,Date
,Timestamp
,LocalDateTime
- 整数类型下 newVersion = oldVersion + 1
- newVersion 会回写到 entity 中
- 仅支持 updateById(id) 与 update(entity, wrapper) 方法
- 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
1、先在数据库添加一个字段version
,类型为int
,默认值为1
2、然后在同步实体类的时候加上@Version
注解
@Version //乐观锁Version注解
private Integer version;
3、注册组件
package com.wu.config;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//扫描我们的mapper文件夹
@MapperScan("com.wu.mapper")
@Configuration
public class MybatisPlusConfig {
//注册乐观锁插件
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
}
4、测试成功和模拟失败
//测试乐观锁(成功)
@Test
public void testOptimisticLocker(){
//1、查询用户信息
User user = userMapper.selectById(1L);
//2、修改用户的信息
user.setName("小王").setEmail("44541545@qq.com");
//3、执行更新操作
userMapper.updateById(user);
}
//测试乐观锁(失败)
@Test
public void testOptimisticLocker2(){
//线程 1
User user = userMapper.selectById(1L);
user.setName("小王11").setEmail("44541545@qq.com");
//模拟另外一个线程执行了插队操作
User user2 = userMapper.selectById(1L);
user2.setName("小王22").setEmail("44541545@qq.com");
userMapper.updateById(user2);
userMapper.updateById(user); //如果没有乐观锁就会覆盖插队线程的值
}
看看失败后的结果
查询操作
前面在快书开始的时候已经写过一个查询全部用户了,下面还来写几个简单的查询
//单个查询
@Test
public void testSeleteById() {
User user = userMapper.selectById(1L);
System.out.println(user);
}
//批量查询
@Test
public void testselectBatchIds() {
List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
users.forEach(System.out::println);
}
//条件查询 map , 这个会返回所有age为20的人
@Test
public void testselectByMap() {
HashMap<String, Object> map = new HashMap<>();
//自定义查询
map.put("age", 20);
List<User> users = userMapper.selectByMap(map);
users.forEach(System.out::println);
}
分页查询
分页在网站使用的十分之多!
- 原始的mit进行分页
- pageHelper第三方插件
- Mybatis-Plus其实也内置了分页插件!
1、使用:配置拦截器组件即可!!
//分页插件
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
2、直接使用Page对象测试
//测试分页查询
@Test
public void testPage() {
//参数一:当前页
//参数二:页面大小
//使用了分页插件之后,所有的分页操作也变得简单的了
Page<User> page = new Page<>(1, 5);
userMapper.selectPage(page, null);
//得到记录然后输出
page.getRecords().forEach(System.out::println);
}
这个page对象还有很多方法
删除操作
//测试删除
//单个
@Test
public void testDelete(){
//这个里面的参数是一个主键,也就是id
userMapper.deleteById(6L);
}
//批量删除
@Test
public void testdeleteBatchIds(){
userMapper.deleteBatchIds(Arrays.asList(1,2,3));
}
//通过条件删除
@Test
public void testdeleteByMap() {
HashMap<String, Object> map = new HashMap<>();
map.put("age", "20");
userMapper.deleteByMap(map);
}
逻辑删除
说明:
只对自动注入的sql起效:
- 插入: 不作限制
- 查找: 追加where条件过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
- 更新: 追加where条件防止更新到已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段
- 删除: 转变为 更新
这是个什么意思呢?
- 就是说,现在还要添加一个字段
deleted
,默认值为0
,当你删除了这条信息的时候,deleted
变为1
,你是查询不出来这条被删除的记录的,但是它还存在,只是你看不到了,这好比回收站!
使用步骤也很简单:
1、在数据库中添加字段deleted
,int
类型,默认值为0
2、同步实体类并加上注解@TableLogic
@TableLogic//逻辑删除注解
private Integer deleted;
3、在application.yml中配置即可
mybatis-plus:
global-config:
db-config:
logic-delete-field: deleted # 全局逻辑删除的实体字段名,如果你的版本为3.3.+,加了这个后上面的注解可以不要,二选一
logic-delete-value: 1 # 逻辑已删除值(默认为 1)
logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)
4、测试
小红原来为 0
进行删除后
@Test
public void testDelete() {
userMapper.deleteById(6L);
}
当你想直接查询小红
@Test
public void testSeleteById() {
User user = userMapper.selectById(6L);
System.out.println(user);
}
如果你想要查出来,就要自己和mybatis一样自己写sql,想偷懒的话无非就是在mapper里面写一个接口,然后直接一个注解
//测试自定义sql查询以删除用户
@Test
public void testMySql(){
User user = userMapper.selectUserByIDAndDeleted(6L, 1);
System.out.println(user);
}
性能分析插件
性能分析建议使用druid
我们在平时的开发中,会遇到一些慢sql。
作用:性能分析拦截器,用于输出每条SQL语句及其执行时间MP提供性能分析插件,如果超过这个时间就停止运行
版本为3.3.2的被官方移除了,如果你想测试请将版本降为3.0.5
1、设置自己的环境为dev、或者test
spring:
profiles:
active: dev
2、在自己的配置中导入插件
@Bean
@Profile({"dev","test"})// 设置 dev test 环境开启
public PerformanceInterceptor performanceInterceptor() {
performanceInterceptor.setMaxTime(100);//ms 设置执行sql语句的最大毫秒数,超出这个时间则会报错
performanceInterceptor.setFormat(true);//是否开启格式化支持,就是说在你测试的时候,可以看到你的sql语句非常有条理
return performanceInterceptor;
}
3、我是3.3.2版本的,我就不贴测试结果了
使用性能分析插件,可以帮助我们提高效率!
条件构造器Wrapper
十分重要:wrapper
我们写一些复杂的sql就可以使用它来替代!
有点小多,可以去Mybatis-Plus官网查看
我这里只举几个例子参考参考
package com.wu;
@SpringBootTest
public class WrapperTest {
@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
//查询name不为空的用户,并且邮箱不为空的用户,年龄大于等于12岁的
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper
.isNotNull("name")
.isNotNull("email")
.ge("age", 12);
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
@Test
public void test2() {
//查询name等于小红的
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("name", "小红");
User user = userMapper.selectOne(wrapper); //selectOne查询一个数据,出现多个结果使用List,或者Map
System.out.println(user);
}
@Test
public void test3() {
//查询年龄在20~30岁之间的用户
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.between("age", 20, 30); //区间
Integer count = userMapper.selectCount(wrapper);//根据 Wrapper 条件,查询总记录数
System.out.println(count);
}
@Test
public void test4() {
//查询名字中不包含 e 的用户 ,并且邮件已t开头
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.notLike("name", "e").likeRight("email", "t");
List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
maps.forEach(System.out::println);
}
@Test
public void test5() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//id在子查询中查出来的
wrapper.inSql("id", "select id from user where age >= 18");
List<Object> objects = userMapper.selectObjs(wrapper);
objects.forEach(System.out::println);
}
@Test
public void test6() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//通过id进行降序排序
wrapper.orderByDesc("id");
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
}
代码自动生成器
AutoGenerator 是 MyBatis-Plus 的代码生成器,通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码,极大的提升了开发效率。
1、为了更好的看效果,重新创建一个springboot带web支持的空项目
2、导入要用到的依赖
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.0.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.21</version>
</dependency>
3、配置数据库
spring:
datasource:
username: root
url: jdbc:mysql://127.0.0.1:3306/kuangstudy?useUnicode=true&characterEncoding=UTF-8&useSSL=true&serverTimezone=UTC
password: Wl123456
driver-class-name: com.mysql.cj.jdbc.Driver
4、我的项目的目录结构,里面啥都没有
5、我想让它自动生成我们以前写的pojo、mapper、service、controller这些代码
6、随便在一个位置写一个类,名字随便
下面这段代码可以仔细的观察观察,以后可以直接拿过去用
package com.wu;
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 WuCode {
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("作者的名字");
gc.setOpen(false); //是否打开资源管理器,就是打开你的文件夹
gc.setFileOverride(false); // 是否覆盖原来生成的目录
gc.setServiceName("%sService"); // 去Service的I前缀
gc.setIdType(IdType.ID_WORKER); //主键的雪花算法
gc.setDateType(DateType.ONLY_DATE); //日期类型
gc.setSwagger2(true); //自动配置Swagger文档
mpg.setGlobalConfig(gc); //把全局配置丢到自动生成器里面
//2、设置数据源
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://127.0.0.1:3306/kuangstudy?useUnicode=true&characterEncoding=UTF-8&useSSL=true&serverTimezone=UTC");
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("Wl123456");
dsc.setDbType(DbType.MYSQL); //数据库的类型
mpg.setDataSource(dsc); //把设置数据源配置丢到自动生成器里面
//3、包的配置
PackageConfig pc = new PackageConfig();
pc.setModuleName("blog"); //src/main/java/blog
pc.setParent("com.wu"); //src/main/java/blog/com.wu
pc.setEntity("entity"); //pojo
pc.setMapper("mapper"); //mapper
pc.setService("service"); //service
pc.setController("controller"); //controller
mpg.setPackageInfo(pc); //把包的配置丢到自动生成器里面
//4、策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setInclude("ks_blog", "ks_blog_category", "ks_comment", "ks_download", "ks_invite", "ks_question", "ks_question_category"); // 设置要映射的表名,可以写多个
strategy.setNaming(NamingStrategy.underline_to_camel); //设置包的一些命名规则 下划线转驼峰命名
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
strategy.setEntityLombokModel(true); // 是否使用lombok开始注解
strategy.setLogicDeleteFieldName("deleted"); // 设置逻辑删除的名字
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); //开启Restful的驼峰命名格式
strategy.setControllerMappingHyphenStyle(true); // 链接请求会变成:localhost:8080/hello_id_2
mpg.setStrategy(strategy); //把策略配置丢到自动生成器里面
mpg.execute(); //代码生成器执行
}
}
7、执行代码看效果
这些自动生成的家伙里面的代码内容比我们自己写的都还要规范,我就不一一展示了,自己可以连接数据库玩玩