mybatisPlus学习

最新推荐文章于 2024-08-08 18:02:39 发布

软工小白_1123

最新推荐文章于 2024-08-08 18:02:39 发布

阅读量464

点赞数

分类专栏：笔记文章标签：学习 mybatis java

本文链接：https://blog.csdn.net/qq_57237780/article/details/127798723

版权

笔记专栏收录该内容

10 篇文章 1 订阅

订阅专栏

什么是mybatisPlus

是什么？ MyBatis 本来就是简化 JDBC 操作的！

官网：https://baomidou.com/pages/bab2db/#release

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速开始

mybatis与mybatis-plus的对比

mybatis开发：

导入依赖jar包
编写工具类
编写核心配置文件
编写实体类
编写实体类接口
编写mapper.xml

mybatis-plus开发

导入依赖jar包
编写实体类
编写实体类接口
实体类接口继承BaseMapper<实体类> //到这里已经可以使用了
接口类继承Iservice<实体类>
实现类继承ServiceImpl<接口，实体类>

步骤

1，导入相关依赖

		 <!--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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

注意：我们使用 mybatis-plus 可以节省我们大量的代码，尽量不要同时导入 mybatis 和 mybatis

plus！版本的差异！

2，创建实体类

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

3，链接mysql

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatisplus? useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

4，编写实体类接口

@Repository
@Mapper
public interface UserMapper extends BaseMapper<User> {
    //核心：继承这个BaseMapper（泛型就传递具体的实体类）
}

5，测试

// 继承了BaseMapper，所有的方法都来自己父类 
// 我们也可以编写自己的扩展方法！
	@Autowired
    UserMapper userMapper;
    @Test
    void contextLoads() {
        // 参数是一个 Wrapper ，条件构造器，这里我们先不用 null 
        // 查询全部用户
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

6，结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XLpcrbT4-1668096374927)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006181327013.png)]

配置日志

这里使用自带的日志，因为其他日志需要导包

#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

insert插入

只需要调insert方法即可

传递一个对应的实体类即可

 //测试插入
    @Test
    void  testInsert(){
        User user=new User();
        //这里并没有给主键赋值，发现mybatis-plus会自动回填主键
        //测试发现他只能回填一次将主键写为0,
        //可能是新版取消了这个功能
        user.setName("lis");
        user.setAge(12);
        user.setEmail("aaaaa");
        userMapper.insert(user);//调insert方法，发现需要传递一个实体类对象，就是你添加的数据
        System.out.println(user);
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JWqzRv0h-1668096374929)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006190344201.png)]

查看源码果然现在已经不会默认回填主键了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBUyQOjW-1668096374929)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006190828244.png)]

主键生成策略

雪花算法：

snowflflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为

毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味

着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。可以保证几乎全球唯

一！

主键自增

//1、实体类主键字段上 @TableId(type = IdType.AUTO) 
	//type指定主键自增方式
			//AUTO(0),  数据库id自增
			//NONE(1), 未设置主键 
			//INPUT(2),  手动输入
  			/* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
			//ID_WORKER(3),  默认的全局唯一id 
			//UUID(4),  全局唯一id uuid
			//ID_WORKER_STR(5); ID_WORKER 字符串表示法

//2、数据库字段一定要是自增！

update更新

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gMs4M2pc-1668096374930)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006192930483.png)]

直接调方法即可

@Test
    void testUpdate(){
        // 通过条件自动拼接动态sql
        User user=new User();
        user.setId(3);
        user.setName("lis");
        user.setAge(12);
        user.setEmail("aaaaa");
        userMapper.updateById(user);
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qvjkIoqw-1668096374930)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006193105214.png)]

自动填充

创建时间、修改时间！这些个操作一遍都是自动化完成的，我们不希望手动更新！

阿里巴巴开发手册：所有的数据库表：gmt_create、gmt_modifified几乎所有的表都要配置上！而且需

要自动化！

方式一：数据库级别（工作中不允许你修改数据库）

1、在表中新增字段 create_time, update_time

字段名无所谓

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AmRAZnrc-1668096374931)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006195236192.png)]

2、再次测试插入方法，我们需要先把实体类同步

private Date createTime; 
private Date updateTime;

3、再次更新查看结果即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YTF8HArf-1668096374931)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006195311946.png)]

方式二：代码级别

1、删除数据库的默认值、更新操作！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-asNZEkGG-1668096374931)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006195353020.png)]

2，实体类字段属性上需要增加注解

// 字段添加填充内容 
@TableField(fill = FieldFill.INSERT)//fill指代的是什么时候进行操作
private Date createTime; 
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

3，编写处理器来处理这个注解即可！

一个组件实现MetaObjectHandler接口

@Component // 一定不要忘记把处理器加到IOC容器中！ 
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); 
    } 
}

乐观锁

什么是乐观锁？

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

再次更新值测试

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

乐观锁实现方式：

取出记录时，获取当前 version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败

实现步骤：

1、给数据库中增加version字段！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kv6RsmQq-1668096374932)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006202349137.png)]

2、我们实体类加对应的字段

@Version //乐观锁Version注解
private Integer version;

3，注册组件（需要mybatis的配置类）

// 扫描我们的 mapper 文件夹
@MapperScan("com.kuang.mapper") 
@EnableTransactionManagement 
@Configuration // 配置类
public class MyBatisPlusConfig {
    // 注册乐观锁插件 
    @Bean 
    public OptimisticLockerInterceptor optimisticLockerInterceptor() { 
        return new OptimisticLockerInterceptor(); 
    }
}

4、测试一下！

@Test public void testOptimisticLocker2(){
    // 线程 1 
    User user = userMapper.selectById(1L); 
    user.setName("kuangshen111"); 
    user.setEmail("24736743@qq.com"); 
    // 模拟另外一个线程执行了插队操作 
    User user2 = userMapper.selectById(1L); 
    user2.setName("kuangshen222");
    user2.setEmail("24736743@qq.com"); 
    userMapper.updateById(user2); //他们操作同一个数据，他插队执行了，导致线程1无法执行
    
    userMapper.updateById(user);// 如果没有乐观锁就会覆盖插队线程的值！ 
    
}

select查询

// 测试查询 
@Test 
public void testSelectById(){ 
User user = userMapper.selectById(1L); //根据主键查询
System.out.println(user); 
List<User> users = userMapper.selectList(null);// 查询全部用户
    
}

// 测试批量查询！ 
@Test 
public void testSelectByBatchId(){ 
List<User> users = userMapper.selectBatchIds(1,2,3); //根据主键批量查询
users.forEach(System.out::println); 
}

// 按条件查询之一使用map操作 
@Test 
public void testSelectByBatchIds(){ 
HashMap<String, Object> map = new HashMap<>(); 
    
// 自定义要查询 
map.put("name","狂神说Java"); 
map.put("age",3); 
List<User> users = userMapper.selectByMap(map); //自定义条件查询类似之前的map
users.forEach(System.out::println); 

}

分页查询

步骤：

1、配置拦截器组件即可

在mybatis的配置类中

// 分页插件 
@Bean 
public PaginationInterceptor paginationInterceptor() { 
    return new PaginationInterceptor(); }

2，直接使用Page对象即可！

// 测试分页查询 
@Test 
public void testPage(){ 
// 参数一：当前页 （都不用计算了，只需要当前页号即可）
// 参数二：页面大小 
// 使用了分页插件之后，所有的分页操作也变得简单的！ 
Page<User> page = new Page<>(2,5); //核心，表示分页的细节

userMapper.selectPage(page,null); //利用分页查询，第二个参数为条件选择器
page.getRecords().forEach(System.out::println); //
System.out.println(page.getTotal()); //查询总的数据条数

}

delete删除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TRE3Cry9-1668096374932)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006223746955.png)]

// 测试删除 
@Test 
public void testDeleteById(){ 
userMapper.deleteById(1240620674645544965L); 
}

// 通过id批量删除 
@Test 
public void testDeleteBatchId(){ 
userMapper.deleteBatchIds(Arrays.asList(1240620674645544961L,124062067464554496 
2L)); 
}

// 通过map删除 
@Test 
public void testDeleteMap(){ 
HashMap<String, Object> map = new HashMap<>(); 
map.put("name","狂神说Java"); 
userMapper.deleteByMap(map);

逻辑删除

物理删除：从数据库中直接移除

逻辑删除：再数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1

核心：添加一个字段，删除操作时实际上是进行修改操作这个字段，然后查询的时候条件带上这个字段

1、在数据表中增加一个 deleted 字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pCDnqtbM-1668096374933)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006230149656.png)]

2、实体类中增加属性

@TableLogic //逻辑删除
private Integer deleted;

3、配置！

// 逻辑删除组件
@Bean 
public ISqlInjector sqlInjector() { 
return new LogicSqlInjector(); 
}

# 配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1 #删除后的标识
mybatis-plus.global-config.db-config.logic-not-delete-value=0 #删除前的标识

4、测试一下删除！

还是使用delete方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OLWdEipx-1668096374933)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006230410707.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UhjutY3C-1668096374933)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006230423415.png)]

性能分析插件

作用：性能分析拦截器，用于输出每条 SQL 语句及其执行时间

MP也提供性能分析插件，如果超过这个时间就停止运行！

使用方法：

1、导入插件

/** 
* SQL执行效率插件 
*/ 
@Bean 
@Profile({"dev","test"})// 设置 dev test 环境开启，保证我们的效率 
public PerformanceInterceptor performanceInterceptor() { 
PerformanceInterceptor performanceInterceptor = new 
PerformanceInterceptor(); //插件对象

performanceInterceptor.setMaxTime(100); // 单位ms  设置sql执行的最大时间，如果超过了则不执行 
performanceInterceptor.setFormat(true); // 是否格式化代码 

return performanceInterceptor; //返回这个对象
}

记住，要在SpringBoot中配置环境为dev或者 test 环境！

如何配置SpringBoot的运行环境?

spring.profiles.active=dev

2、测试使用！

@Test 
void contextLoads() { 
// 参数是一个 Wrapper ，条件构造器，这里我们先不用 null 
// 查询全部用户 
List<User> users = userMapper.selectList(null); 
users.forEach(System.out::println); 

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eKHS0hYo-1668096374934)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20221006232303389.png)]

条件构造器（Wrapper）

十分重要：Wrapper

我们写一些复杂的sql就可以使用它来替代！

AbstractWrapper：QueryWrapper 和 UpdateWrapper的父类

QueryWrapper ：他还有一个lambda的类，猜测是和查询有关的复杂SQL

UpdateWrapper：他还有一个lambda的类，猜测是和更新（增删改）有关的复杂SQL

主要是使用里面的方法

其他方法查看官网：https://baomidou.com/pages/10c804/#abstractwrapper

测试一部分方法：

@Test 
void contextLoads() { 
// 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12 
//Wrapper是一个对象，需要实例化
QueryWrapper<User> wrapper = new QueryWrapper<>(); //泛型类，参数是对应实体类
//可以链式编程
wrapper 
.isNotNull("name") //某个属性不为空
.isNotNull("email") 
.ge("age",12); //某个属性大于12
    
userMapper.selectList(wrapper).forEach(System.out::println);
// 和map对比一下 
//有点类似，map是传递map集合 ，wrapper是传递对象
}

@Test 
void test2(){ 
// 查询名字狂神说 
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
wrapper.eq("name","狂神说"); //指定查询条件
User user = userMapper.selectOne(wrapper); // 查询一个数据，出现多个结果使用List或者 Map 
System.out.println(user); 
}

@Test 
void test3(){ 
// 查询年龄在 20 ~ 30 岁之间的用户 
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
    
wrapper.between("age",20,30); // 区间 
Integer count = userMapper.selectCount(wrapper);// 查询结果数 
System.out.println(count); 
}

// 模糊查询 
@Test 
void test4(){ 
// 查询年龄在 20 ~ 30 岁之间的用户 
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
// 左和右 t% 
wrapper 
.notLike("name","e") 
.likeRight("email","t"); 
List<Map<String, Object>> maps = userMapper.selectMaps(wrapper); //返回一个maps的list集合
maps.forEach(System.out::println); 

}

// 子查询
@Test 
void test5(){ 

QueryWrapper<User> wrapper = new QueryWrapper<>(); 
// id 在子查询中查出来 
wrapper.inSql("id","select id from user where id<3"); //子查询 insql in关键字的子查询
List<Object> objects = userMapper.selectObjs(wrapper); 
objects.forEach(System.out::println); 
}

//测试六 
@Test 

void test6(){ 
QueryWrapper<User> wrapper = new QueryWrapper<>(); 
// 通过id进行排序 
wrapper.orderByAsc("id"); 
List<User> users = userMapper.selectList(wrapper); 
users.forEach(System.out::println); 
}

代码生成器（旧）

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Pojo、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

案例代码：

package com.kuang; 

import com.baomidou.mybatisplus.annotation.DbType; 
import com.baomidou.mybatisplus.annotation.FieldFill; 
import com.baomidou.mybatisplus.annotation.IdType; 
import com.baomidou.mybatisplus.annotation.TableField; 
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; 

// 代码自动生成器 (随便写一个类即可，有点像mybatis逆向工程)
public class KuangCode {
    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); //是否配置swagger2文档
        
mpg.setGlobalConfig(gc);//全局配置放到自动生产器中 

//2、设置数据源 
DataSourceConfig dsc = new DataSourceConfig(); //数据源配置对象
        
dsc.setUrl("jdbc:mysql://localhost:3306/kuang_community? 
useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8"); 
dsc.setDriverName("com.mysql.cj.jdbc.Driver"); 
dsc.setUsername("root"); 
dsc.setPassword("123456"); 
dsc.setDbType(DbType.MYSQL); //驱动类型，mysql驱动就是.mysql
           
mpg.setDataSource(dsc); //数据源放到自动生产器中 

//3、包的配置 
PackageConfig pc = new PackageConfig(); //包的配置对象
pc.setModuleName("blog"); //模块名字
pc.setParent("com.kuang"); //存放的路径  com.kuang.blog这样一个模块
pc.setEntity("entity"); //实体类包名
pc.setMapper("mapper"); //持久层包名
pc.setService("service"); //业务层包名
pc.setController("controller"); //控制层包名
           
mpg.setPackageInfo(pc); //将包配置放到自动生产器中 

//4、策略配置 
StrategyConfig strategy = new StrategyConfig();//策略配置对象 
           
strategy.setInclude("blog_tags","course","links","sys_settings","user_record"," 
user_say"); // 设置要映射的表名【包含的全部都是表名】 
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); //controller层的请求参数可以用下划线传递
                    							// localhost:8080/hello_id_2 
mpg.setStrategy(strategy); //将策略配置放到自动生产器中

mpg.execute(); //执行 
} 
}

结果：

代码生成器（新）

需要导入一个jar包

<!--代码生成器引入包-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>

package com.example.conf;

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.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

/**
 * @Author xsh
 * @Date 2021/4/9 9:47
 */
public class CodeGenerate {
    public static void main(String[] args) {
        // Step1：代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // Step2：全局配置
        GlobalConfig gc = new GlobalConfig();

        String projectPath = "E:\\item-study\\studentproject02\\studentproject02";// 填写代码生成的目录(需要修改)
        gc.setOutputDir(projectPath + "/src/main/java");// 拼接出代码最终输出的目录
        gc.setAuthor("qinlun");// 配置开发者信息（可选）（需要修改）
        gc.setOpen(false);// 配置是否打开目录，false 为不打开（可选）
        gc.setSwagger2(false);// 实体属性 Swagger2 注解，添加 Swagger 依赖，开启 Swagger2 模式（可选）
//        gc.setFileOverride(true); //重新生成文件时是否覆盖，false 表示不覆盖（可选）
        gc.setIdType(IdType.ASSIGN_ID);// 配置主键生成策略，此处为 ASSIGN_ID（可选）
        gc.setDateType(DateType.ONLY_DATE);// 配置日期类型，此处为 ONLY_DATE（可选）
        // 默认生成的 service 会有 I 前缀
        gc.setServiceName("%sService"); // 去掉可以默认IService
        mpg.setGlobalConfig(gc);

        // Step3：数据源配置（需要修改）
        DataSourceConfig dsc = new DataSourceConfig();
        // 配置数据库 url 地址
        dsc.setUrl("jdbc:mysql://10.255.84.12:3306/xsh_test?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false");
        // dsc.setSchemaName("testMyBatisPlus"); // 可以直接在 url 中指定数据库名
        dsc.setDriverName("com.mysql.jdbc.Driver");// 配置数据库驱动
        dsc.setUsername("root");// 配置数据库连接用户名
        dsc.setPassword("Syx@1234qwer");// 配置数据库连接密码
        mpg.setDataSource(dsc);

        // Step:4：包配置
        PackageConfig pc = new PackageConfig();

        pc.setParent("com.example");// 配置父包名（需要修改）
        pc.setModuleName("");// 配置模块名（需要修改）
        pc.setEntity("entity");// 配置 entity 包名
        pc.setMapper("mapper");// 配置 mapper 包名
        pc.setService("service");// 配置 service 包名
        pc.setController("controller");// 配置 controller 包名
        mpg.setPackageInfo(pc);

        // Step5：策略配置（数据库表配置）
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//指定表名（可以同时操作多个表，使用 , 隔开）（需要修改）

        strategy.setNaming(NamingStrategy.underline_to_camel);// 配置数据表与实体类名之间映射的策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);// 配置数据表的字段与实体类的属性名之间映射的策略
        strategy.setLogicDeleteFieldName("is_deleted");//配置逻辑删除字段
        strategy.setEntityBooleanColumnRemoveIsPrefix(true); //去掉布尔值的is_前缀
        strategy.setEntityLombokModel(true);// 配置 lombok 模式
        strategy.setRestControllerStyle(true);// 配置 rest 风格的控制器（@RestController）
        strategy.setControllerMappingHyphenStyle(true);// 配置驼峰转连字符
        mpg.setStrategy(strategy);

        // Step6：执行代码生成操作
        mpg.execute();
    }
}