Mybatis-Plus笔记

目录

Mybatis-Plus

特性

快速入门

1.导入Pom配置文件

2.连接数据库配置

3.编写实体类

4.编写实体类对应的mapper接口

5.在主启动类添加@MapperScan注解

6.进行Test测试

结果

配置日志

CRUD扩展

1.Insert

主键生成策略

1.默认 : ID_WORKER 全局唯一Id

2.主键自增：AUTO 我们需要配置主键自增

3.手动输入：INPUT 就需要自己写id

Update

自动填充

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

方式二：代码级别

乐观锁&悲观锁

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

2、实体类加对应的字段

3、注册组件

4、测试一下：单线程情况下

Select

通过id查询单个用户

通过多个id查询多个用户

条件查询 通过map封装

分页查询

1、配置拦截器组件

2、直接使用page对象即可

Delete

1.id删除

2.批量删除

3.自定义map删除

逻辑删除

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

2、实体类中添加对应属性

3、配置！

性能分析插件

1、导入插件

条件构造器

1、测试一

测试二

测试三

测试四：模糊查询

测试五：子查询

测试六：排序

代码自动生成器

---

Mybatis-Plus

特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速入门

官方链接：https://baomidou.com/guide/MyBatis-Plushttps://baomidou.com/guide/

1.导入Pom配置文件

1.     <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
   
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
   
           <!--1.数据库驱动-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <scope>runtime</scope>
           </dependency>
           <!--2.lombok-->
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
           </dependency>
   
           <dependency>
               <groupId>com.baomidou</groupId>
               <artifactId>mybatis-plus-boot-starter</artifactId>
               <version>3.5.1</version>
           </dependency>
   
   
       </dependencies>

2.连接数据库配置

1. #数据库连接配置
   spring.datasource.username=root
   spring.datasource.password=root
   #mysql5~8 驱动不同driver-class-name 8需要增加时区的配置serverTimezone=UTC
   #useSSL=false 安全连接
   spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

3.编写实体类

package com.kuang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Long id;
    private String name;
    private Integer age;
    private String email;

}

4.编写实体类对应的mapper接口

1. package com.kuang.mapper;
   
   import com.baomidou.mybatisplus.core.mapper.BaseMapper;
   import com.kuang.pojo.User;
   import org.springframework.stereotype.Repository;
   
   //在对应的接口上面继承一个基本的接口 BaseMapper
   @Repository//代表持久层
   public interface UserMapper extends BaseMapper<User> {
   //所有CRUD操作都编写完成了，不用像以前一样配置一大堆文件
   
   }

5.在主启动类添加@MapperScan注解

1. package com.kuang;
   
   import org.mybatis.spring.annotation.MapperScan;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   //扫描mapper包下的所有接口
   @MapperScan("com.kuang.mapper")
   public class MybatisPlusApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(MybatisPlusApplication.class, args);
       }
   
   }
   

6.进行Test测试

1. package com.kuang;
   
   import com.kuang.mapper.UserMapper;
   import com.kuang.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> userList = userMapper.selectList(null); //查询全部的用户
           userList.forEach(user -> {
               System.out.println(user);
           });
       }
   
   }

7.结果

思考问题

• SQL谁帮我们写的? MyBatis-Plus都写好了
• 方法哪里来的? MyBatis-Plus都写好了

配置日志

我们所有的sql是不可见的，我们希望知道他们是怎么执行的，所以要配置日志知道

1. #配置日志 log-impl:日志实现
2. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

CRUD扩展

1.Insert

1.    @Test//测试插入
       public void insertTest(){
           User user = new User();
           user.setName("文静");
           user.setAge(18);
           user.setEmail("2803708553@qq.com");
   
           Integer result = userMapper.insert(user); //会帮我们自动生成id
           System.out.println(result); //受影响的行数
           System.out.println(user); //通过日志发现id会自动回填
   
       }

数据库插入的id的默认值为:全局的唯—id

主键生成策略

源码解释

1. public enum IdType {
2. AUTO, //数据库id自增
3. INPUT, //手动输入
4. ID_WORKER, //默认的全局唯一id
5. UUID, //全局唯一id uuid
6. NONE;//未设置主键
7. **
8. }

1.默认 : ID_WORKER 全局唯一Id

分布式系统唯一Id生成：分布式系统唯一ID生成方案汇总 - nick hao - 博客园

• Twitter的snowflake算法（雪花算法）

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心（北京、香港···），5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。

• 具体实现的代码可以参看https://github.com/twitter/snowflake。

2.主键自增：AUTO 我们需要配置主键自增

我们需要配置主键自增

• 在实体类字段上配置@TableId(type = IdType.AUTO)

• 数据库字段一定是自增
   

  

3.手动输入：INPUT 就需要自己写id

• 在实体类字段上配置@TableId(type = IdType.INPUT)

Update

1.     @Test//测试更新
       public void updateTest(){
           User user = new User();
           user.setId(2L);//怎么改id？？
   //通过条件自动拼接动态Sql
           user.setName("root");
           user.setAge(12);
           user.setEmail("root@qq.com");
   
           int i = userMapper.updateById(user);//updateById，但是参数是个user
           System.out.println(i);
   
       }
   

自动填充

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

阿里巴巴开发手册︰几乎所有的表都要配置 gmt_create、gmt_modified ！而且需要自动化

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

1、在表中增加字段：create_time,update_time

2、再次测试插入或更新方法，我们需要在实体类中同步！

1. private Date createTime;//驼峰命名
   private Date updateTime;

3、查看结果

方式二：代码级别

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

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

1. //字段 字段添加填充内容
   @TableField(fill = FieldFill.INSERT)//value = ("create_time"),
   private Date createTime;
   @TableField(fill = FieldFill.INSERT_UPDATE)
   private Date updateTime;

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

1. @Slf4j//日志
   @Component//丢到springboot里 一定不要忘记把处理器加到Ioc容器中!
   public class MyMetaObjectHandler implements MetaObjectHandler {//extends??
   
       @Override//插入时的填充策略
       public void insertFill(MetaObject metaObject) {
           log.info("==start insert ······==");
   //setFieldValByName(java.lang.String fieldName, java.lang.Object fieldVal, org.apache.ibatis.reflection.MetaObject metaObject)
           this.setFieldValByName("createTIme",new Date(),metaObject);
           this.setFieldValByName("updateTime",new Date(),metaObject);
   
       }
   
       @Override//更新时的填充策略
       public void updateFill(MetaObject metaObject) {
           log.info("==start update ······==");
           this.setFieldValByName("updateTime",new Date(),metaObject);
       }
   }

4、测试插入/更新，观察时间

1. 
       @Test//测试插入
       public void insertTest1(){
           User user = new User();
           user.setName("live");
           user.setAge(22);
           user.setEmail("1314@qq.com");
   
           Integer result = userMapper.insert(user); //会帮我们自动生成id
           System.out.println(result); //受影响的行数
           System.out.println(user); //通过日志发现id会自动回填
   
       }
       @Test//测试更新
       public void updateTest1(){
           User user = new User();
           user.setId(1359495921613004803L);
           user.setName("test3");
           user.setAge(18); //通过条件自动拼接动态Sql
           user.setEmail("test3@qq.com");
   
           int i = userMapper.updateById(user);//updateById，但是参数是个user
           System.out.println(i);
   
       }

乐观锁&悲观锁

在面试过程中经常被问到乐观锁/悲观锁，这个其实很简单

乐观锁：顾名思义十分乐观,他总是认为不会出现问题,无论干什么都不上锁!如果出现了问题,再次更新值测试

悲观锁：顾名思义十分悲观,他总是认为出现问题,无论干什么都会上锁!再去操作!

我们这里主要讲解 乐观锁机制!

乐观锁实现方式:

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

1. 乐观锁：先查询，获得版本号
2. -- A
3. update user set name = "wsk",version = version+1 where id = 1 and version = 1
4. -- B （B线程抢先完成，此时version=2，会导致A线程修改失败！）
5. update user set name = "wsk",version = version+1 where id = 1 and version = 1

测试一下Mybatis-Plus乐观锁插件

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

2、实体类加对应的字段

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

3、注册组件

1. //扫描mapper包下的所有接口
   @MapperScan("com.kuang.mapper")
   @Configuration
   public class MybatisPlusConfig {
       /**
        * 旧版
        */
       @Bean
       public MybatisPlusInterceptor mybatisPlusInterceptor() {
           MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
           mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
           return mybatisPlusInterceptor;
       }
   }

4、测试一下：单线程情况下

• 成功

1.     @Test//测试乐观锁成功
       public void testOptimisticLocker1(){
   //1、查询用户信息
           User user = userMapper.selectById(1l);
   //2、修改用户信息
           user.setAge(18);
           user.setEmail("2803708553@qq.com");
   //3、执行更新操作
           userMapper.updateById(user);
   
       }

• 失败，多线程，插队

1.     @Test//测试乐观锁失败 多线程下
       public void testOptimisticLocker2(){
   //线程1
           User user1 = userMapper.selectById(1L);
           user1.setAge(1);
           user1.setEmail("2803708553@qq.com");
   
   //模拟另外一个线程执行了插队操作
           User user2 = userMapper.selectById(1L);
           user2.setAge(5);
           user2.setEmail("2803708553@qq.com");
           userMapper.updateById(user2);
   
   //自旋锁来多次尝试提交！
           userMapper.updateById(user1);//如果没有乐观锁就会覆盖插队线程的值
       }

Select

• 通过id查询单个用户

1.     @Test//通过id查询单个用户
       public void testSelectById(){
           User user = userMapper.selectById(1L);
           System.out.println(user);
       }

• 通过多个id查询多个用户

1.     @Test//通过id查询多个用户
       public void testSelectBatchIds(){
           List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
           users.forEach(System.out::println);
   //System.out.println(users);
       }

• 条件查询 通过map封装

1.     @Test//通过条件查询之一 map
       public void testMap(){
           HashMap<String, Object> map = new HashMap<>();
   //自定义要查询的
           map.put("name","www");
           map.put("age",18);
   
           List<User> users = userMapper.selectByMap(map);
           users.forEach(System.out::println);
       }

分页查询

分页在网站的使用十分之多！

1、原始的limit分页

2、pageHelper第三方插件

3、MybatisPlus其实也内置了分页插件！

如何使用：

1、配置拦截器组件

//扫描mapper包下的所有接口
@MapperScan("com.kuang.mapper")
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//      分页查询
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
//      乐观锁
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }

}

2、直接使用page对象即可

1.     @Test//测试分页查询
       public void testPage(){
   //参数一current：当前页 参数二size：页面大小
   //使用了分页插件之后，所有的分页操作都变得简单了
           Page<User> page = new Page<>(2,5);
           userMapper.selectPage(page,null);
   
           page.getRecords().forEach(System.out::println);
           System.out.println("总页数==>"+page.getTotal());
       }

Delete

基本的删除任务：

1.id删除

2.批量删除

3.自定义map删除

1.     @Test
       public void testDeleteById(){
           userMapper.deleteById(1359507762519068681L);
       }
   
       @Test
       public void testDeleteBatchIds(){
           userMapper.deleteBatchIds(Arrays.asList(1359507762519068675L,1359507762519068676L));
       }
   
       @Test
       public void testD(){
           HashMap<String, Object> map = new HashMap<>();
   
           map.put("age","18");
           map.put("name","lol");
   
           userMapper.deleteByMap(map);
       }

我们在工作中会遇到一些问题：逻辑删除！

逻辑删除

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

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

管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！

测试一下：

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

2、实体类中添加对应属性

1.     @TableLogic//逻辑删除注解
       private Integer deleted;

3、配置！

1. #配置逻辑删除 没删除的为0 删除的为1

1. mybatis-plus.global-config.db-config.logic-delete-value=1
   mybatis-plus.global-config.db-config.logic-not-delete-value=0

4、测试一下删除

发现： 记录还在，deleted变为1

再次测试查询被删除的用户，发现查询为空

以上所有的CRUD及其扩展操作，我们都必须精通掌握！会大大提高工作写项目的效率！

性能分析插件

我们在平时的开发中，会遇到一些满Sql。测试、druid···

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

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

1、导入插件

1. //性能分析插件
       @Bean
       @Profile({"dev","test"})//设置dev开发、test测试 环境开启 保证我们的效率
       public PerformanceInterceptor performanceInterceptor(){
           PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
           performanceInterceptor.setMaxTime(100);//设置sql最大执行时间*ms，如果超过了则不执行
           performanceInterceptor.setFormat(true);//开启sql格式化
   
           return performanceInterceptor;
       }
   

注意： 要在SpringBoot中配置环境为dev或test环境！

1. #设置开发环境
2. spring.profiles.active=dev

2、测试使用

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

使用性能分析插件，可以帮助我们提高效率！、

条件构造器

十分重要：Wrapper 记住查看输出的SQL进行分析

1、测试一

    @Test
    public void testWrapper1() {

//参数是一个wrapper ，条件构造器，和刚才的map对比学习！
//查询name不为空，email不为空，age大于18的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNotNull("name")
                .isNotNull("email")
                .ge("age",18);

        List<User> userList = userMapper.selectList(wrapper);
        userList.forEach(System.out::println);

    }

2.测试二

1.     @Test
       public void testWrapper2() {
   
   //查询name=wsk的用户
           QueryWrapper<User> wrapper = new QueryWrapper<>();
           wrapper.eq("name","wsk");
   //查询一个数据selectOne，若查询出多个会报错
   //Expected one result (or null) to be returned by selectOne(), but found: *
   //若出现多个结果使用list或map
           User user = userMapper.selectOne(wrapper);//查询一个数据，若出现多个结果使用list或map
           System.out.println(user);
       }

3.测试三

1.     @Test
       public void testWrapper3() {
   
   //查询age在10-20之间的用户
           QueryWrapper<User> wrapper = new QueryWrapper<>();
           wrapper.between("age", 10, 20);//区间
   
           Long count = userMapper.selectCount(wrapper);//输出查询的数量selectCount
           System.out.println(count);
       }
   
   

4.测试四：模糊查询

1.     @Test
       public void testWrapper4() {
   
   //模糊查询
           QueryWrapper<User> wrapper = new QueryWrapper<>();
           wrapper
                   .notLike("name","s")
                   .likeRight("email","t");//qq% 左和右？
   
           List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
           maps.forEach(System.out::println);
       }
   

5.测试五：子查询

1.     @Test
       public void testWrapper5() {
   
   //模糊查询
   // SELECT id,name,age,email,version,deleted,create_time,update_time
   //FROM user
   //WHERE deleted=0 AND id IN
   //(select id from user where id<5)
           QueryWrapper<User> wrapper = new QueryWrapper<>();
   //id 在子查询中查出来
           wrapper.inSql("id","select id from user where id<5");
   
           List<Object> objects = userMapper.selectObjs(wrapper);
           objects.forEach(System.out::println);
   
       }

6.测试六：排序

1.     @Test
       public void testWrapper6() {
   
           QueryWrapper<User> wrapper = new QueryWrapper<>();
   //通过id进行降序排序
           wrapper.orderByDesc("id");
   
           List<User> userList = userMapper.selectList(wrapper);
           userList.forEach(System.out::println);
   
       }

Mysql => JDBC => Mybatis => MybatisPlus

代码自动生成器

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

1. package com.wsk;
3. import com.baomidou.mybatisplus.annotation.DbType;
4. import com.baomidou.mybatisplus.annotation.FieldFill;
5. import com.baomidou.mybatisplus.annotation.IdType;
6. import com.baomidou.mybatisplus.generator.AutoGenerator;
7. import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
8. import com.baomidou.mybatisplus.generator.config.GlobalConfig;
9. import com.baomidou.mybatisplus.generator.config.PackageConfig;
10. import com.baomidou.mybatisplus.generator.config.StrategyConfig;
11. import com.baomidou.mybatisplus.generator.config.po.TableFill;
12. import com.baomidou.mybatisplus.generator.config.rules.DateType;
13. import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
15. import java.util.ArrayList;
17. //代码自动生成器
18. public class WskCode {
20. public static void main(String[] args) {
22. //我们需要构建一个代码生成器对象
23. AutoGenerator mpg = new AutoGenerator();
24. //怎么样去执行，配置策略
27. //1、全局配置
28. GlobalConfig gc = new GlobalConfig();
29. String projectPath = System.getProperty("user.dir");//获取当前目录
30. gc.setOutputDir(projectPath+"/src/main/java");//输出到哪个目录
31. gc.setAuthor("wsk");
32. gc.setOpen(false);
33. gc.setFileOverride(false);//是否覆盖
34. gc.setServiceName("%sService");//去Service的I前缀
35. gc.setIdType(IdType.ID_WORKER);
36. gc.setDateType(DateType.ONLY_DATE);
37. gc.setSwagger2(true);
39. mpg.setGlobalConfig(gc);
41. //2、设置数据源
42. DataSourceConfig dsc = new DataSourceConfig();
43. dsc.setUsername("root");
44. dsc.setPassword("root");
45. dsc.setUrl("jdbc:mysql://localhost:3306/wuye?useSSL=false&serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8");
46. dsc.setDriverName("com.mysql.cj.jdbc.Driver");
47. dsc.setDbType(DbType.MYSQL);
49. mpg.setDataSource(dsc);
51. //3、包的配置
52. PackageConfig pc = new PackageConfig();
53. pc.setModuleName("study");
54. pc.setParent("com.wsk");
55. pc.setEntity("pojo");
56. pc.setMapper("mapper");
57. pc.setService("service");
58. pc.setController("controller");
60. mpg.setPackageInfo(pc);
62. //4、策略配置
63. StrategyConfig strategy = new StrategyConfig();
64. strategy.setInclude("admin","danyuan","building","room");//设置要映射的表名,只需改这里即可
65. strategy.setNaming(NamingStrategy.underline_to_camel);
66. strategy.setColumnNaming(NamingStrategy.underline_to_camel);
67. strategy.setEntityLombokModel(true);//是否使用lombok开启注解
69. strategy.setLogicDeleteFieldName("deleted");
71. //自动填充配置
72. TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
73. TableFill gmtUpdate = new TableFill("gmt_update", FieldFill.INSERT_UPDATE);
74. ArrayList<TableFill> tableFills = new ArrayList<>();
75. tableFills.add(gmtCreate);
76. tableFills.add(gmtUpdate);
77. strategy.setTableFillList(tableFills);
79. //乐观锁配置
80. strategy.setVersionFieldName("version");
82. strategy.setRestControllerStyle(true);//开启驼峰命名
84. strategy.setControllerMappingHyphenStyle(true);//localhost:8080/hello_id_2
86. mpg.setStrategy(strategy);
88. mpg.execute();//执行
90. }
92. }

1. <!--模板引擎 依赖:mybatis-plus代码生成的时候报异常-->
2. <dependency>
3. <groupId>org.apache.velocity</groupId>
4. <artifactId>velocity-engine-core</artifactId>
5. <version>2.0</version>
6. </dependency>
7. <!--配置ApiModel在实体类中不生效-->
8. <dependency>
9. <groupId>com.spring4all</groupId>
10. <artifactId>spring-boot-starter-swagger</artifactId>
11. <version>1.5.1.RELEASE</version>
12. </dependency>
13. <!--freemarker-->
14. <dependency>
15. <groupId>org.freemarker</groupId>
16. <artifactId>freemarker</artifactId>
17. <version>2.3.30</version>
18. </dependency>
19. <!--beetl-->
20. <dependency>
21. <groupId>com.ibeetl</groupId>
22. <artifactId>beetl</artifactId>
23. <version>3.3.2.RELEASE</version>
24. </dependency>