MyBatisPlus

1.简介

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
官网

2.特性

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

3.快速开始

创建数据库mybatis_plus
创建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)
  );
  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');

编写项目，使用 Spring Initializer初始化SpringBoot项目
导入依赖

  <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>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/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>
    </dependencies>

注意：不要同时注入mybatis和mybatis-plus的依赖

在配置文件中编写连接数据库信息，使用idea连接数据库

  #数据库连接，mysql的把呢不能是5.7的
  spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf8
  spring.datasource.username=root
  spring.datasource.password=123456

编写User实体类

  package com.zixin.mybatisplus.pojo;

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

  @Data
  @NoArgsConstructor
  @AllArgsConstructor
  public class User {

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

  }

编写mapper接口

  package com.zixin.mybatisplus.mapper;

  import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  import com.zixin.mybatisplus.pojo.User;
  import org.springframework.stereotype.Repository;

  //在对应的Mapper上面继承基本的类
  @Repository//代表持久层
  public interface UserMapper extends BaseMapper<User> {

  }

编写测试方法，运行得到结果

  package com.zixin.mybatisplus;

  import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  import com.zixin.mybatisplus.mapper.UserMapper;
  import com.zixin.mybatisplus.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 {

      //导入UserMapper
      @Autowired
      private UserMapper userMapper;

      @Test
      void contextLoads() {
      }

      /**
       * 测试获取user列表数据
       */
      @Test
      void getUserListTest(){
          List<User> userList = userMapper.selectList(new QueryWrapper<>());
          userList.forEach(System.out::println);
      }
  }

4.配置日志

在application.properties中配置日志相关的配置

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

再次运行上面的getUserListTest测试方法，可以看到控制台中SQL的详细信息

5.CRUD拓展

5.1插入测试与主键生成策略

插入测试

在测试类MybatisPlusApplicationTests中编写一个插入用户信息的方法InsertUserTest如下所示：

    //插入一条user记录，没有设置id
    @Test
    public void InsertUserTest(){
        User user = new User();

        user.setName("zixin");
        user.setAge(20);
        user.setEmail("3827653657@qq.com");

        int row = userMapper.insert(user);

        System.out.println(user);
        System.out.println("受影响的行数："+row);
    }

运行InsertUserTest测试方法，可以看到控制台中的插入SQL，id原本没有设置，插入的数据也有，还是一长串，这是数据库插入的全局的唯一的id

主键生成策略

默认ID_WORKER全局唯一id
雪花算法
- snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。
- 其核心思想是：使用41bit作为机器的ID(5个bit是数据中心，5个bit的机器ID),12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生4096个ID）,最后还有一个符号位，永远是0.可以保证几乎全球唯一
主键自增
- 修改user表中id的字段为自增
- 在User实体类中的Id字段上面添加@TableId(type=IdType.AUTO)注解
- 再次运行InsertUserTest测试方法，可以看到数据库中新增加的一条数据的id是在上一条数据的id的基础上加一
对@TableId注解源码的分析

  public enum IdType {
    AUTO(0),//数据库id自增
    NONE(1),//未设置主键
    INPUT(2),//手动输入
    ID_WORKER(3),//默认的全局唯一id
    UUID(4),//全局唯一id uuid
    ID_WORKER_STR(5);//ID_WORKER字符串表示法
  }

5.2更新测试

在测试类MybatisPlusApplicationTests中编写一个修改用户信息的方法updateUserTest如下所示：

  //更新测试
    @Test
    public void updateUserTest(){
        User user = new User();
        user.setId(5L);
        user.setName("芋头");

        int row = userMapper.updateById(user);
        System.out.println("更新的行数："+row);
    }

运行测试
在updateUserTest方法中修改age字段，全部代码如下

  //更新测试
    @Test
    public void updateUserTest(){
        User user = new User();
        user.setId(5L);
        user.setName("芋头");
        user.setAge(22);

        int row = userMapper.updateById(user);
        System.out.println("更新的行数："+row);
    }

运行测试

两次结果对比结论：SQL都是自动帮你动态配置的

5.3自动填充

方式一：数据库级别

在表中新增字段create_time,update_time
同步实体类中的字段

    private Date createTime;
    private Date updateTime;

测试InsertUserTest方法,这里运行了两次，所以添加了两条数据

方式二：代码级别

删除数据库中create_time,update_time两个字段的默认值，并把非空的选项去掉
实体类create_time,update_time字段属性上添加注解@TableField

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

编写处理器来处理注解,在com.zixin.mybatisplus包下创建handler文件夹，并在该文件夹中创建MyMetaObjectHandler类，同时实现MetaObjectHandler接口

  package com.zixin.mybatisplus.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;

  @Slf4j
  @Component
  public class MyMetaObjectHandler  implements MetaObjectHandler {
      //插入时的填充策略
      @Override
      public void insertFill(MetaObject metaObject) {
          log.info("-----------fill insert info------");
          this.setFieldValByName("createTime", new Date(), metaObject);
          this.setFieldValByName("updateTime", new Date(), metaObject);
      }

      //修改时的填充策略
      @Override
      public void updateFill(MetaObject metaObject) {
          log.info("-----fill update info-------");
          this.setFieldValByName("updateTime", new Date(), metaObject);
      }
  }

运行insertUserTest方法，可以看到create_time,update_time这两个字段有按自定义的处理类来实现，这里可能不是很明显看出效果
运行updateUserTest方法，可以明显看到update_time这个字段有按自定义的处理类来实现

5.4乐观锁

乐观锁和悲观锁的区别
- 乐观锁：总是认为不会出现问题，无论干什么不去上锁，如果出现了问题，再次更新值测试
- 悲观锁：总是认为总是出问题，无论干什么都会上锁，再去操作
乐观锁的实现方式
- 去除记录时，获取当前version
- 更新时，带上这个version
- 执行更新时，set version = newVersion where version = oldversion
测试MybatisPlus的乐观锁插件
- 给数据库中添加version字段
- 在User实体类中添加version字段

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

注册插件

    package com.zixin.mybatisplus.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;
    import org.springframework.transaction.annotation.EnableTransactionManagement;

    @MapperScan(basePackages = {"com.zixin.mybatisplus.mapper"})//扫描mapper类
    @EnableTransactionManagement//开启事务
    @Configuration//配置类
    public class MybatisPlusConfig {

        //注册乐观锁插件
        @Bean
        public OptimisticLockerInterceptor optimisticLockerInterceptor(){
            return new OptimisticLockerInterceptor();
        }
    }

编写两个测试方法，分别是测试乐观锁成功和失败

    //测试乐观锁成功
  @Test
  public void optimisticLockTest(){
      //查询id为1d为1的用户信息
      User user = userMapper.selectById(1L);
      //修改用户信息
      user.setName("乐观用户");
      user.setAge(18);
      //执行更新操作
      int row = userMapper.updateById(user);
  }


  //测试乐观锁失败
  @Test
  public void optimisticLockTest2(){
      //用户1
      User user1 = userMapper.selectById(1L);
      user1.setName("悲观用户1");
      user1.setAge(12);
      //用户2
      User user2 = userMapper.selectById(1L);
      user2.setName("悲观用户2");
      user2.setAge(20);
      //先修改用户2
      userMapper.updateById(user2);
      //再修改用户1
      userMapper.updateById(user1);

  }

运行optimisticLockTest方法，可以看到id为1的用户version变为2
运行optimisticLockTest2方法，可以看到id为1的用户version变为3，而不是4

5.5查询操作

在测试类MybatisPlusApplicationTests中分别编写三个不同不同方式查询用户信息的测试方法，分别是getUserByIdTest、getUserByBatchId、getUserByMap如下

  //根据id查询用户信息
    @Test
    public void getUserByIdTest(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

    //根据条件查询方式之一batch
    @Test
    public void getUserByBatchId(){
        List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        userList.forEach(System.out::println);
    }

    //根据条件查询方式之一map
    @Test
    public void getUserByMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("name","zixin");

        List<User> userList = userMapper.selectByMap(map);
        userList.forEach(System.out::println);
    }

分别运行getUserByIdTest、getUserByBatchId、getUserByMap方法，得到的结果分别如下

5.6分页查询

分页查询的方式
- 原始的limit进行分页
- pageHelper第三方插件
- MybatisPlus内置的分页插件

使用MybatisPlus内置的分页插件进行分页

在com.zixin.mybatisplus.config包下的MybatisPlusConfig配置类中配置拦截器组件

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

在测试类中编写测试方法

  //分页测试
  @Test
  public void getUserByPageTest(){
      //参数一:当前页；参数二：每页记录数
      Page<User> userPage = new Page<>(1, 5);
      userMapper.selectPage(userPage, null);

      userPage.getRecords().forEach(System.out::println);
      System.out.println("总记录数："+userPage.getTotal());
  }

运行测试方法getUserByPageTest,得到的结果如下

5.7删除操作

在测试类MybatisPlusApplicationTests中编写三种方式删除用户信息的测试方法，分别为deleteUserByIdTest、deleteUserByBatchIdTest、deleteUserByMapTest

  //根据id删除用户信息
    @Test
    public void deleteUserByIdTest(){
        int row = userMapper.deleteById(1L);
        System.out.println("删除的记录数："+row);
    }

    //批量删除用户信息方式之一Batch
    @Test
    public void deleteUserByBatchIdTest(){
        int rows = userMapper.deleteBatchIds(Arrays.asList(1515232144401387523L, 1515232144401387522L));
        System.out.println("Batch方式删除的记录数："+rows);
    }

    //批量删除用户信息方式之一Map
    @Test
    public void deleteUserByMapTest(){
        Map<String, Object> map = new HashMap<>();
        map.put("name", "zixin");

        int rows = userMapper.deleteByMap(map);
        System.out.println("Map方式删除的记录数："+rows);
    }

运行deleteUserByIdTest方法，控制台与数据库中结果如下：
运行deleteUserByBatchIdTest方法，控制台与数据库中结果如下：
运行deleteUserByMapTest方法，控制台与数据库中结果如下：

5.8逻辑删除

物理删除与逻辑删除的区别
- 物理删除：从数据库中直接删除
- 逻辑删除：在数据库中没有被删除，而是通过一个变量来让它失效

测试

在数据表user中增加一个deleted字段,打开表，可以看到全部记录中的deleted字段值都为0
在User实体类中添加deleted属性

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

在配置类 MybatisPlusConfig中配置逻辑删除插件

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

在配置文件中配置逻辑删除的信息

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

修改deleteUserByIdTest测试方法中查询的id为2L，代码如下

  //根据id删除用户信息
  @Test
  public void deleteUserByIdTest(){
      int row = userMapper.deleteById(2L);
      System.out.println("删除的记录数："+row);
  }

运行 deleteUserByIdTest测试方法，控制台和数据表中的结果如下
修改getUserByIdTest测试方法中查询的id为2L，代码如下

//根据id查询用户信息
  @Test
  public void getUserByIdTest(){
      User user = userMapper.selectById(2L);
      System.out.println(user);
  }

运行 getUserByIdTest测试方法，控制台结果如下,可以看到查询的记录为0，说明该数据不存在，而事实上是存在的，只是被逻辑删除了

6.性能分析插件

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

测试

在配置类 MybatisPlusConfig中配置性能分析插件

  //SQL执行效率插件
  @Bean
  @Profile({"dev","test"})
  public PerformanceInterceptor performanceInterceptor(){
      PerformanceInterceptor interceptor = new PerformanceInterceptor();
      //设置SQL执行的最大时间，如果超过了就不执行，单位为ms
      interceptor.setMaxTime(10);
      //是否格式化代码
      interceptor.setFormat(true);
      return interceptor;
  }

在配置文件中配置环境为dev或test

  #运行环境
  spring.profiles.active=dev

运行getUserListTest测试方法，控制台报错，因为在配置性能分析插件是设置了sql的最大执行时间为10ms，而实际执行SQL的时间为17ms,超过了设置的时间

   /**
   * 测试获取user列表数据
   */
  @Test
  void getUserListTest(){
      List<User> userList = userMapper.selectList(new QueryWrapper<>());
      userList.forEach(System.out::println);
  }

修改性能分析插件中sql的最大执行时间为20ms，再次运行getUserListTest测试方法，可以获取到数据

  interceptor.setMaxTime(20);

7.条件查询器Wrapper

编写一个WrapperTest测试类
编写getUserTest1Test测试方法，查询name不为空，邮箱不为空且年龄大于22岁的用户，运行得到结果如下

  @Test
  public void getUserTest1Test(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("name")
                .isNotNull("email")
                .ge("age", 23);
        List<User> userList = userMapper.selectList(wrapper);
        userList.forEach(System.out::println);
    }

编写getUserByNameTest测试方法，查询名字为”Sandy“的用户，运行得到结果如下

    //查询名字为”Sandy“的用户
    @Test
    public void getUserByNameTest(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "Sandy");
        User user = userMapper.selectOne(wrapper);//只有一条数据的前提下
        System.out.println(user);
    }

编写getUserByAgeTest测试方法，查询年龄在20~25之间的用户，运行得到结果如下

    //查询年龄在20~25之间的用户
    @Test
    public void getUserByAgeTest(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age", 20, 25);

        Integer count = userMapper.selectCount(wrapper);
        System.out.println("用户数量为："+count);
    }

编写getUserByLikeTest测试方法，模糊查询，查询name中不包含m,邮箱以t为开头的用户，运行得到结果如下

    //模糊查询，查询name中不包含m,邮箱以t为开头的用户
    @Test
    public void getUserByLikeTest(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name", "m")
                .likeRight("email", "t");

        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

编写getUserByIdTest测试方法，模糊查询，id在子查询中查询出来，运行得到结果如下

    //模糊查询，id在子查询中查询出来
    @Test
    public void getUserByIdTest(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.inSql("id", "select id from user where id<19");

        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

编写getUserByOrderTest测试方法，通过id进行降序排序，运行得到结果如下

    //通过id进行排序
    @Test
    public void getUserByOrderTest(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("id");

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

8.代码自动生成器

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

  package com.zixin.mybatisplus;

  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 zxCode {
      public static void main(String[] args) {
          //构建一个代码生成器对象
          AutoGenerator ag = new AutoGenerator();

          //配置策略

          //1.全局配置
          GlobalConfig gc = new GlobalConfig();
          String projectPath = System.getProperty("user.dir");//获取系统路径
          gc.setOutputDir(projectPath+"/src/main/java");//输出到那个目录
          gc.setAuthor("zixin");//作者
          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

          ag.setGlobalConfig(gc);

          //2.设置数据源
          DataSourceConfig dsc = new DataSourceConfig();
          dsc.setUsername("root");//用户名
          dsc.setPassword("123456");//密码
          dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8");//url
          dsc.setDriverName("com.mysql.cj.jdbc.Driver");//驱动
          dsc.setDbType(DbType.MYSQL);//数据库类型

          ag.setDataSource(dsc);

          //3.包的配置
          PackageConfig pc = new PackageConfig();
          pc.setModuleName("autocode");//生成的代码存放在那个模块
          pc.setParent("com.zixin.mybatisplus");//父级包名
          pc.setEntity("pojo");//实体类存放的包名
          pc.setMapper("mapper");//mapper接口存放的包名
          pc.setService("service");//service类存放的包名
          pc.setController("controller");//controller类存放的包名

          ag.setPackageInfo(pc);

          //4.策略配置
          StrategyConfig strategy = new StrategyConfig();
          strategy.setInclude("user");//设置要映射的表名,只需改这里即可
          strategy.setNaming(NamingStrategy.underline_to_camel);//设置表名下划线转驼峰命名
          strategy.setColumnNaming(NamingStrategy.underline_to_camel);//设置字段名下划线转驼峰命名
          strategy.setEntityLombokModel(true);//是否使用lombok开启注解

          strategy.setLogicDeleteFieldName("deleted");//设置逻辑删除字段名称

          //自动填充配置
          TableFill createTime = new TableFill("createTime", FieldFill.INSERT);//设置创建日期自动填充策略
          TableFill updateTime = new TableFill("updateTime", FieldFill.INSERT_UPDATE);//设置更新日期自动配置策略

          ArrayList<TableFill> tableList = new ArrayList<>();
          tableList.add(createTime);
          tableList.add(updateTime);
          strategy.setTableFillList(tableList);

          //乐观锁配置
          strategy.setVersionFieldName("version");
          strategy.setRestControllerStyle(true);//开启驼峰命名
          strategy.setControllerMappingHyphenStyle(true);//localhost:8080/aaa_id_2(controller类上面映射路径)

          ag.setStrategy(strategy);

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

运行zxCode自动生成代码类时，控制台出现下面错误

原因：缺少了依赖
解决方法：在pom.xml中加入velocity的依赖

  <!-- 模板引擎 -->
  <dependency>
      <groupId>org.apache.velocity</groupId>
      <artifactId>velocity-engine-core</artifactId>
      <version>2.0</version>
  </dependency>

再次运行，可以看到项目目录中有对应的代码，如下所示

posted @ 2022-04-17 17:23 RBAZX 阅读(57) 评论(0) 编辑收藏举报

刷新页面返回顶部

RBAZX