MybatisPlus

目录

config

MybatisPlusConfig.java

package com.bijian.mybatisplus.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//可以将主类中的注解移到此处
@MapperScan("com.bijian.mybatisplus.mapper")
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 添加乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

enums

SexEnum.java

package com.bijian.mybatisplus.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.Getter;

@Getter
public enum SexEnum {
    MALE(1, "男"),
    FEMALE(2, "女");

    @EnumValue // 将注解所标识的属性的值存储到数据库中
    private Integer sex;
    private String sexName;

    SexEnum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }
}

java/mapper

ProductMapper.java

package com.bijian.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.bijian.mybatisplus.pojo.Product;
import org.springframework.stereotype.Repository;

@Repository
public interface ProductMapper extends BaseMapper<Product> {

}

UserMapper.java

package com.bijian.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.bijian.mybatisplus.pojo.User;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

import java.util.Map;

@Repository
public interface UserMapper extends BaseMapper<User> {
    /**
     * 根据id查询用户信息为map集合
     * @param id
     * @return
     */
    Map<String,Object> selectMapById(Long id);

    /**
     * 通过年龄查询用户信息并分页
     * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位
     * @param age
     * @return
     */
    Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);

}

pojo

Product.java

package com.bijian.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    @Version // 标识乐观锁版本号字段
    private Integer version;
}

User.java

package com.bijian.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.bijian.mybatisplus.enums.SexEnum;
import lombok.Data;

@Data
//在实体类类型上添加@TableName("t_user")，标识实体类对应的表，即可成功执行SQL语句
//@TableName("t_user")
public class User {
    /*
    * 1. MyBatis-Plus没有将uid作为主键赋值，在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句
    * 2. 若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解@TableId，
    *    则抛出异常Unknown column 'id' in 'field list'，即MyBatis-Plus仍然会将id作为表的主键操作，
    *    而表中表示主键的是字段uid此时需要通过@TableId注解的value属性，指定表中的主键字段，
    *    @TableId("uid")或@TableId(value="uid")
    * 3. type属性用来定义主键策略
    *    IdType.ASSIGN_ID（默认）:基于雪花算法的策略生成数据id，与数据库id是否设置自增无关
    *    IdType.AUTO: 使用数据库的自增策略，注意，该类型请确保数据库设置了id自增，否则无效
    * 4. 雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性。
    * */
    @TableId(value = "id")
    private Long id;

    /*
    * 1. 若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格例如实体类属性userName，
    *    表中字段user_name此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格
    * 2. 若实体类中的属性和表中的字段不满足情况1，例如实体类属性name，表中字段username，
    *    此时需要在实体类属性上使用@TableField("username")设置属性所对应的字段名
    * */
    @TableField("name")
    private String name;

    private Integer age;

    private String email;

    private SexEnum sex;

    /*
    * @TableLogic:逻辑删除(使用场景：可以进行数据恢复),真正执行的是修改
    * 逻辑删除:假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
    * */

}

service

UserService.java

package com.bijian.mybatisplus.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.bijian.mybatisplus.pojo.User;

public interface UserService extends IService<User> {

}

UserServiceImpl.java

package com.bijian.mybatisplus.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.bijian.mybatisplus.mapper.UserMapper;
import com.bijian.mybatisplus.pojo.User;
import com.bijian.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

resources/mapper

UseMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bijian.mybatisplus.mapper.UserMapper">

    <!--Map<String, Object> selectMapById(Long id);-->
    <select id="selectMapById" resultType="map">
        select id,name,age,email from t_user where id = #{id}
    </select>

<!--    Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);-->
    <select id="selectPageVo" resultType="User">
        select id,name,age,email from t_user where age > #{age}
    </select>

</mapper>

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=UTC
    username: root
    password: 123456

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      # 配置MyBatis-Plus操作表的默认前缀
      table-prefix: t_
      # 配置MyBatis-Plus的主键策略
#      id-type: auto
  # 配置类型别名所对应的包
  type-aliases-package: com.bijian.mybatisplus.pojo
  # 配置扫描通用枚举
  type-enums-package: com.bijian.mybatisplus.enums

test

MybatisPlusTest

package com.bijian.mybatisplus;

import com.bijian.mybatisplus.mapper.UserMapper;
import com.bijian.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.lang.reflect.Array;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList() {
        //selectList()根据MP内置的条件构造器查询一个list集合，null表示没有条件，即查询所有
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }

    @Test
    public void testInsert() {
        //INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
        User user = new User();

//        user.setName("张三");
//        user.setAge(18);
//        user.setEmail("zhangsan@qq.com");

        user.setName("李四");
        user.setAge(20);
        user.setEmail("lisi@qq.com");

        int result = userMapper.insert(user);
        System.out.println("result:" + result);
    }

    @Test
    public void testDeleteById(){
        //DELETE FROM user WHERE id=?
        int result = userMapper.deleteById(1680044786809073666L);
        System.out.println(result);
    }

    @Test
    public void testDeleteByMap(){
        //DELETE FROM user WHERE name = ? AND age = ?
        Map<String,Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("age",18);
        int result = userMapper.deleteByMap(map);
        System.out.println(result);
    }

    @Test
    public void testDeleteBatchIds(){
        //DELETE FROM user WHERE id IN ( ? , ? , ? )
        List<Long> list = Arrays.asList(1680047446052380674L, 1680047702899019777L);
        int result = userMapper.deleteBatchIds(list);
        System.out.println("受影响行数："+result);
    }

    @Test
    public void testUpdate(){
        // UPDATE user SET name=?, age=?, email=? WHERE id=?
        User user = new User();
        user.setId(4L);
        user.setName("admin");
        user.setAge(50);
        user.setEmail("admin@qq.com");
        int result = userMapper.updateById(user);
        System.out.println("result:" + result);
    }

    @Test
    public void testSelectById(){
        // SELECT id,name,age,email FROM user WHERE id=?
        User user = userMapper.selectById("1L");
        System.out.println(user);
    }

    @Test
    public void testSelectBatchIds(){
        // SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
        List<Long> list = Arrays.asList(1L, 2L, 3L);
        List<User> users = userMapper.selectBatchIds(list);
        users.forEach(System.out::println);
    }

    @Test
    public void testSelectByMap(){
        // SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
        Map<String,Object> map = new HashMap<>();
        map.put("name","admin");
        map.put("age",50);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

    @Test
    public void testSelectMapById(){
        // select id,name,age,email from user where id = ?
        Map<String, Object> map = userMapper.selectMapById(1L);
        System.out.println(map); // {name=Jone, id=1, age=18, email=test1@baomidou.com}
    }
}

MyBatisPlusServiceTest

package com.bijian.mybatisplus;

import com.bijian.mybatisplus.pojo.User;
import com.bijian.mybatisplus.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;

@SpringBootTest
public class MyBatisPlusServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testGetCount() {
        // SELECT COUNT( * ) FROM user
        int count = userService.count();
        System.out.println("总记录数：" + count);
    }

    @Test
    public void testSaveBatch() {
        // SQL长度有限制，海量数据插入单条SQL无法实行，
        // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
        // INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
        ArrayList<User> users = new ArrayList<>();
        for (int i = 0; i < 25; i++) {
            User user = new User();
            user.setName("sjt" + i);
            user.setAge(30 + i);
            user.setEmail("sjt" + i + "@qq.com");
            users.add(user);
        }
        boolean result = userService.saveBatch(users);
        System.out.println(result);
    }
}

MyBatisPlusWrapperTest

package com.bijian.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.bijian.mybatisplus.mapper.UserMapper;
import com.bijian.mybatisplus.pojo.User;
import org.junit.jupiter.api.Test;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;
import java.util.Map;

@SpringBootTest
public class MyBatisPlusWrapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void test01() {
        // 查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
        // SELECT id,name,age,email FROM t_user WHERE (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "a").between("age", 20, 30).isNotNull("email");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void test02() {
        // 按年龄降序查询用户，如果年龄相同则按id升序排列
        // SELECT id,name,age,email FROM t_user ORDER BY age DESC,id ASC
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("age").orderByAsc("id");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void test03() {
        // 删除email为空的用户
        // DELETE FROM t_user WHERE (email IS NULL)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("email");
        int result = userMapper.delete(queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

    @Test
    public void test04() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        // 将（年龄大于40并且用户名中包含有a）或邮箱为null的用户信息修改
        // UPDATE t_user SET age=? WHERE (age > ? AND name LIKE ? OR email IS NULL)
//        queryWrapper.gt("age",40).like("name","a").or().isNull("email");

        // 将用户名中包含有a并且（年龄大于30或邮箱为null）的用户信息修改
        // lambda表达式内的逻辑优先运算
        // UPDATE t_user SET age=? WHERE (name LIKE ? AND (age > ? OR email IS NULL))
        queryWrapper.like("name", "a").and(i -> i.gt("age", 30).or().isNull("email"));
        User user = new User();
        user.setAge(55);
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

    @Test
    public void test05() {
        // 查询用户信息的username和age字段
        // SELECT name,age FROM t_user
        // //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值为null
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name", "age");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

    @Test
    public void test06() {
        // 查询id小于等于3的用户信息
        // SELECT id,name,age,email FROM t_user WHERE (id IN (select id from t_user where id <= 3))
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("id", "select id from t_user where id <= 3");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void test07() {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        // 将（年龄大于40或邮箱为null）并且用户名中包含有a的用户信息修改
        // UPDATE t_user SET age=? WHERE (name LIKE ? AND (age >= ? OR email IS NULL))
        updateWrapper.set("age", 55).like("name", "a").and(i -> i.ge("age", 40).or().isNull("email"));
        // 这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null
        int result = userMapper.update(null, updateWrapper);
        System.out.println(result);
    }

    @Test
    public void test08() {
        // 定义查询条件，有可能为null（用户未输入或未选择）
        // SELECT id,name,age,email FROM t_user WHERE (age >= ? AND age <= ?)
        String name = null;
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        if (StringUtils.isNotBlank(name)) {
            queryWrapper.like("name", "a");
        }
        if (ageBegin != null) {
            queryWrapper.ge("age", ageBegin);
        }
        if (ageEnd != null) {
            queryWrapper.le("age", ageEnd);
        }

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

    @Test
    public void test08_2() {
        String name = null;
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(name), "name", "a")
                    .ge(ageBegin != null, "age", ageBegin)
                    .le(ageEnd != null, "age", ageEnd);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void test09() {
        String name = null;
        Integer ageBegin = 10;
        Integer ageEnd = 24;
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //避免使用字符串表示字段，防止运行时错误
        queryWrapper.like(StringUtils.isNotBlank(name),User::getName,name)
                    .ge(ageBegin != null,User::getAge,ageBegin)
                    .le(ageEnd!=null,User::getAge,ageEnd);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    @Test
    public void test10() {
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(User::getAge, 55)
                     .like(User::getName, "a")
                      .and(i -> i.ge(User::getAge, 40).or().isNull(User::getEmail));
        int result = userMapper.update(null, updateWrapper);
        System.out.println(result);
    }
}

MybatisPlusEnumTest

package com.bijian.mybatisplus;

import com.bijian.mybatisplus.enums.SexEnum;
import com.bijian.mybatisplus.mapper.UserMapper;
import com.bijian.mybatisplus.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MybatisPlusEnumTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSexEnum() {
        User user = new User();
        user.setName("Enum");
        user.setAge(20);
        //设置性别信息为枚举项，会将@EnumValue注解所标识的属性值存储到数据库
        user.setSex(SexEnum.MALE);
        int result = userMapper.insert(user);
        System.out.println("result:" + result);
    }

}

MybatisPlusPluginsTest

package com.bijian.mybatisplus;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.bijian.mybatisplus.mapper.ProductMapper;
import com.bijian.mybatisplus.mapper.UserMapper;
import com.bijian.mybatisplus.pojo.Product;
import com.bijian.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
public class MybatisPlusPluginsTest {
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private ProductMapper productMapper;

    @Test
    public void testPage(){
        //设置分页参数
        Page<User> page = new Page<>(2,5);
        userMapper.selectPage(page,null);
        //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }

    @Test
    public void testSelectPageVo(){
        Page<User> page = new Page<>(1,5);
        userMapper.selectPageVo(page,30);
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }

    @Test
    public void testConcurrentUpdate(){
        //1、小李
        Product p1 = productMapper.selectById(1L);
        System.out.println("小李取出的价格：" + p1.getPrice());
        //2、小王
        Product p2 = productMapper.selectById(1L);
        System.out.println("小王取出的价格：" + p2.getPrice());
        //3、小李将价格加了50元，存入了数据库 UPDATE t_product SET name=?, price=?, version=1 WHERE id=? AND version=0
        p1.setPrice(p1.getPrice()+50);
        int result1 = productMapper.updateById(p1);
        System.out.println("小李修改结果：" + result1);
        //4、小王将商品减了30元，存入了数据库 UPDATE t_product SET name=?, price=?, version=? WHERE id=? AND version=0
        p2.setPrice(p2.getPrice() - 30);
        int result2 = productMapper.updateById(p2);
        System.out.println("小王修改结果：" + result2);
        //最后的结果
        Product p3 = productMapper.selectById(1L);
        //价格覆盖，最后的结果：70
        System.out.println("最后的结果：" + p3.getPrice());
    }

    @Test
    public void testConcurrentUpdate2(){
        //1、小李
        Product p1 = productMapper.selectById(1L);
        System.out.println("小李取出的价格：" + p1.getPrice());
        //2、小王
        Product p2 = productMapper.selectById(1L);
        System.out.println("小王取出的价格：" + p2.getPrice());
        //3、小李将价格加了50元，存入了数据库
        p1.setPrice(p1.getPrice()+50);
        int result1 = productMapper.updateById(p1);
        System.out.println("小李修改结果：" + result1);
        //4、小王将商品减了30元，存入了数据库
        p2.setPrice(p2.getPrice() - 30);
        int result2 = productMapper.updateById(p2);
        System.out.println("小王修改结果：" + result2);
        //5、失败重试，重新获取version并更新
        if (result2==0){
            p2 = productMapper.selectById(1L);
            p2.setPrice(p2.getPrice()-30);
            result2 = productMapper.updateById(p2);
        }
        System.out.println("小王修改重试的结果：" + result2);
        //6、老板看价格
        Product p3 = productMapper.selectById(1L);
        System.out.println("老板看价格：" + p3.getPrice());
    }
}

FastAutoGeneratorTest

package com.bijian.mybatisplus;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.Collections;

public class FastAutoGeneratorTest {

    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus?serverTimezone=UTC", "root", "123456")
                .globalConfig(builder -> {
                    builder.author("bijian") // 设置作者
                            //.enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("D://IdeaProjects//mybatis_plus"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.bijian") // 设置父包名
                            .moduleName("mybatisplus") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "D://IdeaProjects//mybatis_plus")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }

}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.bijian</groupId>
    <artifactId>mybatisplus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatisplus</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</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.4.0</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>