SpringBoot&MP学习

SpringBoot学习

1、创建项目

1. 选择SpringBoot创建

   • 选择Java、Maven

   • 选择jdk1.8和24

     • 进入后在pom文件中更改springboot的版本为2.7.18

     • jdk更改为1.8

     • 在设置中把maven的库以及jdk进行更改

2. 只需要一个BookController类

   • 编写只需要两个注解

     • @RestController

     • @RequestMapping("/books")

   •  @RestController
      @RequestMapping("/books")
      public class BookContorller {
          @GetMapping("/{id}")
          public String getById(@PathVariable Integer id) {
              System.out.println("id ==>  " + id);
              return "hello , spring boot !";
          }
      }

3. 直接可以进行测试

4. 使用postman访问路径，可以在控制台展示结果

2、需要再补充深入学习的内容

1. 集合框架（List、Map、Set 的用法与区别）

2. 基础 SQL（多表联查）

3. 索引、事务（ACID 特性）

4. 了解 Vue.js 或 React 的基本数据绑定（因项目可能涉及前后端分离）

5. Ajax 请求原理（axios 库的使用）

6. 浏览器开发者工具调试（Network 面板查看接口）

7. 版本控制：Git（clone、commit、push 基础命令）

8. Linux 基础：

   • 常用命令（ls、cd、vim、systemctl）

   • 项目部署流程（JAR 包运行）

9. 消息队列：

   • RabbitMQ 或 Kafka 的基本概念（如订单超时处理可能用到）

10. 缓存：

    • Redis 的 String、Hash 数据类型操作

Mybatis-Plus学习

1、简单的CRUD

domain类，此处可以注入lombok简化开发

 package com.mao.domain;
 ​
 public class User {
     private Integer id;
     private String name;
     private Short age;
     private Short gender;
     private String phone;
 ​
     @Override
     public String toString() {
         return "User{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
                 ", age=" + age +
                 ", gender=" + gender +
                 ", phone='" + phone + '\'' +
                 '}';
     }
 ​
     public Integer getId() {
         return id;
     }
 ​
     public void setId(Integer id) {
         this.id = id;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public Short getAge() {
         return age;
     }
 ​
     public void setAge(Short age) {
         this.age = age;
     }
 ​
     public Short getGender() {
         return gender;
     }
 ​
     public void setGender(Short gender) {
         this.gender = gender;
     }
 ​
     public String getPhone() {
         return phone;
     }
 ​
     public void setPhone(String phone) {
         this.phone = phone;
     }
 }

此处的重点：

1. 继承了BaseMapper

2. 使用了@Mapper注解，使其可以为Spring容器调用

 @Mapper
 public interface UserDao extends BaseMapper<User> {
 }

此处为数据源的相关信息编写，前提是需要导入pom文件，比如最开始导入的mybatis-plus以及druid

 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid-spring-boot-starter</artifactId>
     <version>1.2.24</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
 <dependency>
     <groupId>com.baomidou</groupId>
     <artifactId>mybatis-plus-boot-starter</artifactId>
     <version>3.5.11</version>
 </dependency>

 spring:
   datasource:
     druid:
       db-type: mysql
       url: jdbc:mysql://localhost:3306/mybatis_db
       username: root
       password: 123456

测试类

测试了CRUD的集中情况

• 重要信息

  • 导入注解@SpringBootTest

  • 自动注入对象

    • @Autowired private UserDao userDao;

  • @Test测试类的注解

    • 调用CRUD的方法

      • userDao.insert(user);

      • userDao.deleteById(1166528513);

      • userDao.updateById(user);

      • User user = userDao.selectById(1);

      • List<User> userList = userDao.selectList(null);

 package com.mao;
 ​
 import com.mao.dao.UserDao;
 import com.mao.domain.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 MybatisPlus00QuickstartApplicationTests {
 ​
     @Autowired
     private UserDao userDao;
 ​
 ​
     @Test
     void testInsert() {
         User user = new User();
         user.setId(7);
         user.setName("Tom");
         user.setAge((short) 18);
         user.setGender((short) 1);
         user.setPhone("123456789");
         userDao.insert(user);
     }
     @Test
     void testDeleteById(){
         userDao.deleteById(1166528513);
     }
     @Test
     void testUpdate(){
         User user = new User();
         user.setId(7);
         user.setName("Tom888");
         user.setAge((short) 38);
         user.setGender((short) 0);
         userDao.updateById(user);
     }
     @Test
     void testSelectById(){
         User user = userDao.selectById(1);
         System.out.println(user);
     }
 ​
     @Test
     void testGetAll() {
         List<User> userList = userDao.selectList(null);
         System.out.println(userList);
     }
 ​
 }

2、分页查询

(1) Page<T> 的典型用法

 // 创建分页对象（当前页=1，每页10条）
 Page<User> page = new Page<>(1, 10); 
 ​
 // 执行分页查询（返回值仍是 Page 对象）
 Page<User> result = userMapper.selectPage(page, queryWrapper);
 ​
 // 获取分页数据
 List<User> records = result.getRecords(); // 当前页数据
 long total = result.getTotal();          // 总记录数

(2) IPage<T> 的用法

通常用于 自定义 SQL 分页（在 XML 或注解中）：

 // Mapper 接口方法
 IPage<User> selectUserByPage(IPage<User> page, @Param("name") String name);
 ​
 // XML 中实现分页逻辑
 <select id="selectUserByPage" resultType="User">
     SELECT * FROM user 
     WHERE name = #{name}
     LIMIT #{page.offset}, #{page.size}
 </select>
 ​
 // 调用时传入 Page 对象（Page 是 IPage 的实现）
 IPage<User> page = new Page<>(1, 10);
 userMapper.selectUserByPage(page, "Alice");

• Page：开箱即用的分页工具，适合大部分场景。

• IPage：扩展分页能力的接口，用于高级定制。

如果只是做基础分页查询，无脑用 Page 即可！

1. 核心区别

2. 分页配置

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

    //    分页功能
    @Test
    void testGetByPage() {
//        当前页面，当前页面条数
        IPage page = new Page(1, 2);
        userDao.selectPage(page, null);
        System.out.println("当前页码值：" + page.getCurrent());
        System.out.println("每页显示数：" + page.getSize());
        System.out.println("一共多少页：" + page.getPages());
        System.out.println("一共多少条数据：" + page.getTotal());
        System.out.println("数据：" + page.getRecords());
    }

要求mybatis-plus的版本为3.5.6 3.5.11报错了，导致PaginationInnerInterceptor不能导入包

<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.6</version>
</dependency>

3、按条件查询

最常用的是：Lambda格式进行查询，此处需要使用User:: getAge进行动态获取，而不是“”，双引号引入字符的形式，易出错

在 Java 的 Lambda 表达式或方法引用中，User::getAge 是一种 方法引用（Method Reference） 的语法格式，属于 类名::实例方法名 的形式。

User::getAge 属于 类名::非静态方法（ClassName::InstanceMethod）的格式，它的实际含义是：

• 两个冒号相当于引用，引用这个类里的方法

• 等价于 Lambda：(User user) -> user.getAge()

• 使用场景：需要从一个类的实例中提取某个值（通常用于 Stream.map()、Comparator.comparing() 等操作）。

   @Test
//  方式一：按条件查询，利用Wrapper的实现类进行查询
    void testGetBy1(){
        QueryWrapper queryWrapper = new QueryWrapper();
//        添加查询条件    lt() => less than   gt() => greater than
//        字段，属性值    =>  查询年龄小于10岁的字段    但是有个缺点，字段名写错则查询错误，故引入lambda格式
        queryWrapper.gt("age",10);
        queryWrapper.lt("age",30);
        List list = userDao.selectList(queryWrapper);
        System.out.println(list);
    }
    @Test
    //  方式二：按条件查询，利用lambda格式进行查询
    void testGetBy2(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//        此处用lambda格式，另外需要加泛型   需要多条件查询 直接链式查询，在后面加点
        queryWrapper.lambda().lt(User::getAge,10).gt(User::getAge,5);
        List list = userDao.selectList(queryWrapper);
        System.out.println(list);
    }
    @Test
    //  方式三：按条件查询，利用lambda格式进行查询
    void testGetBy3(){
        //直接引入lambda的抽象类
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<User>();
//      方式二是并且的关系，方式三则是或者的关系，直接加.or()即可
        queryWrapper.lt(User::getAge,10).or().gt(User::getAge,30);
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

在 Java 中，queryWrapper 通常是 MyBatis-Plus 提供的一个工具类，用于构建动态查询条件。lt（小于）和 gt（大于）是用来设置数值范围的条件操作符。除了 lt 和 gt，MyBatis-Plus 的 QueryWrapper 还提供了很多其他常用的条件查询方法，常见的有：

1. eq（等于）：equal

   • 用于等于某个值的查询条件。

   queryWrapper.eq("field", value);  // field = value

2. ne（不等于）：not equal

   • 用于不等于某个值的查询条件。

   queryWrapper.ne("field", value);  // field != value

3. gt（大于）：greater than

   • 用于大于某个值的查询条件。

   queryWrapper.gt("field", value);  // field > value

4. lt（小于）：less than

   • 用于小于某个值的查询条件。

   queryWrapper.lt("field", value);  // field < value

5. ge（大于等于）：greater equal

   • 用于大于等于某个值的查询条件。

   queryWrapper.ge("field", value);  // field >= value

6. le（小于等于）：less equal

   • 用于小于等于某个值的查询条件。

   queryWrapper.le("field", value);  // field <= value

7. like（模糊查询）：

   • 用于模糊匹配查询。

   queryWrapper.like("field", value);  // field LIKE value

8. notLike（不匹配）：

   • 用于模糊查询时的不匹配。

   queryWrapper.notLike("field", value);  // field NOT LIKE value

9. isNull（字段为 NULL）：

   • 用于查询字段值为 NULL 的数据。

   queryWrapper.isNull("field");  // field IS NULL

10. isNotNull（字段不为 NULL）：

    • 用于查询字段值不为 NULL 的数据。

    queryWrapper.isNotNull("field");  // field IS NOT NULL

11. in（包含在某个范围内）：

    • 用于查询某字段的值在一个集合中的数据。

    queryWrapper.in("field", list);  // field IN (value1, value2, ...)

12. notIn（不包含在某个范围内）：

    • 用于查询某字段的值不在一个集合中的数据。

    queryWrapper.notIn("field", list);  // field NOT IN (value1, value2, ...)

13. between（范围查询）：

    • 用于查询某字段在一个范围内的值。

    queryWrapper.between("field", value1, value2);  // field BETWEEN value1 AND value2

14. notBetween（不在范围内）：

    • 用于查询某字段不在一个范围内的值。

    queryWrapper.notBetween("field", value1, value2);  // field NOT BETWEEN value1 AND value2

15. or（或条件）：

    • 用于在多个条件之间增加“OR”关系。

    queryWrapper.or(qw -> qw.eq("field1", value1).eq("field2", value2));  // (field1 = value1 OR fie

4、各种测试

@SpringBootTest
class MybatisPlus00QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;


    @Test
    void testInsert() {
        User user = new User();
//        user.setId(888);
        user.setName("CDM");
        user.setAge(23);
        user.setGender((short) 0);
        user.setPhone("123456");
        user.setPassword("123456");
        userDao.insert(user);
    }

    @Test
    void testDeleteById() {
        userDao.deleteById(1166528513);
    }

    @Test
    void testUpdate() {
        User user = new User();
        user.setName("Tom888");
        user.setAge(38);
        user.setGender((short) 0);
        userDao.updateById(user);
    }

    @Test
    void testSelectById() {
        User user = userDao.selectById(1);
        System.out.println(user);
    }

    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }

    //    分页功能
    @Test
    void testGetByPage() {
//        当前页面，当前页面条数
        IPage page = new Page(2, 2);
        userDao.selectPage(page, null);
        System.out.println("当前页码值：" + page.getCurrent());
        System.out.println("每页显示数：" + page.getSize());
        System.out.println("一共多少页：" + page.getPages());
        System.out.println("一共多少条数据：" + page.getTotal());
        System.out.println("数据：" + page.getRecords());
    }

    @Test
//  方式一：按条件查询，利用Wrapper的实现类进行查询
    void testGetBy1() {
        QueryWrapper queryWrapper = new QueryWrapper();
//        添加查询条件    lt() => less than   gt() => greater than
//        字段，属性值    =>  查询年龄小于10岁的字段    但是有个缺点，字段名写错则查询错误，故引入lambda格式
        queryWrapper.gt("age", 10);
        queryWrapper.lt("age", 30);
        List list = userDao.selectList(queryWrapper);
        System.out.println(list);
    }

    @Test
        //  方式二：按条件查询，利用lambda格式进行查询
    void testGetBy2() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//        此处用lambda格式，另外需要加泛型   需要多条件查询 直接链式查询，在后面加点
        queryWrapper.lambda().lt(User::getAge, 10).gt(User::getAge, 5);
        List list = userDao.selectList(queryWrapper);
        System.out.println(list);
    }

    @Test
        //  方式三：按条件查询，利用lambda格式进行查询
    void testGetBy3() {
        //直接引入lambda的抽象类
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<User>();
//      方式二是并且的关系，方式三则是或者的关系，直接加.or()即可     ge.()   =>  是大于等于
        queryWrapper.gt(User::getAge, 50).or().eq(User::getAge, 1);
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    @Test
//    测试判断条件查询
    void testGetByNotNull() {
        UserQuery userQuery = new UserQuery();
//        静态设置两个变量值，看效果
//        userQuery.setAge(18);
        userQuery.setAge2(38);
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<User>();
//        若有空值则无法正常判断，故需要引入新的方法 => 有状态码判断的
/*        queryWrapper.gt(User::getAge, userQuery.getAge());
        queryWrapper.lt(User::getAge, userQuery.getAge2());*/
        queryWrapper.lt(null != (userQuery.getAge()), User::getAge, userQuery.getAge());
        queryWrapper.gt(null != (userQuery.getAge2()), User::getAge, userQuery.getAge2());
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
//        queryWrapper.lt()
    }

    //查询投影，查全集
    @Test
    void testgetByWrapper1() {
//        方式一：使用lambda格式，一定要记得加上泛型
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
//        筛选的条件
        lambdaQueryWrapper.select(User::getName, User::getAge, User::getPhone);
//        把条件传入userdao进行调用,将结果返回给userList
        List<User> userList = userDao.selectList(lambdaQueryWrapper);
        System.out.println(userList);
    }

    @Test
    void testgetByWrapper2() {
//        方式二：不使用lambda格式，改为使用QueryWrapper
        QueryWrapper queryWrapper = new QueryWrapper();
//        筛选的条件
        queryWrapper.select("name", "age", "phone");
//        把条件传入userdao进行调用,将结果返回给userList,使用selectList
        List<User> userList = userDao.selectList(queryWrapper);
        System.out.println(userList);
    }

    @Test
    void testgetByWrapper3() {
//        方式三：不使用lambda格式，改为使用QueryWrapper，查询总数 select函数就是简化版的select语句
        QueryWrapper queryWrapper = new QueryWrapper();
//        筛选的条件 相当于SELECT count(*) as count FROM user
        queryWrapper.select("count(*) as count");
//        需要把条件结果改成Map对象才可以实现打印，使用selectMaps
//        把条件传入userdao进行调用,将结果返回给userList
        List<Map<String, Object>> userList = userDao.selectMaps(queryWrapper);
        System.out.println(userList);
    }

    @Test
    void testLogin() {
        User user = new User();
        //使用eq取等
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
        lambdaQueryWrapper.eq(null != user.getName(), User::getName, "Tom")
                .eq(null != user.getPassword(), User::getPassword, "Tom");
        User user1 = userDao.selectOne(lambdaQueryWrapper);
        System.out.println(user1);
    }

    @Test
    void testBetween() {
        User user = new User();
        //使用eq取等
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
        lambdaQueryWrapper.between(User::getAge, 30, 60);
        List<User> userList = userDao.selectList(lambdaQueryWrapper);
        System.out.println(userList);
    }

    @Test
    void testLike() {
        //使用eq取等
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
        lambdaQueryWrapper.likeLeft(User::getName, "王");
//        ==>  Preparing: SELECT id,name,age,gender,phone,password FROM user WHERE (name LIKE ?)
//        ==> Parameters: %王(String)
/*      lambdaQueryWrapper.likeRight(User::getName, "王");
        ==>  Preparing: SELECT id,name,age,gender,phone,password FROM user WHERE (name LIKE ?)
        ==> Parameters: 王%(String)
*/
        List<User> userList = userDao.selectList(lambdaQueryWrapper);
        System.out.println(userList);
    }

    //    字段映射,全查询，但是在实体类中设置限制
    @Test
    void testReflect() {
        LambdaQueryWrapper<User> userLambdaQueryWrapper = new LambdaQueryWrapper<>();
        List<User> userList = userDao.selectList(userLambdaQueryWrapper);
        System.out.println(userList);
    }
    //    多数据删除，新API，但是需要一个新的数组接收处理
    @Test
    void testSeriesDelete() {
//        需要一个List集合接收处理
        ArrayList<Integer> list = new ArrayList<>();
//        添加两个id，进行删除操作
        list.add(9);
        list.add(10);
//        deleteBatchIds会将list集合中存放的id，查询后进行删除
        userDao.deleteBatchIds(list);
        /*
        * ==>  Preparing: DELETE FROM tbl_user WHERE id IN ( ? , ? )
          ==> Parameters: 9(Integer), 10(Integer)
        * */
    }
    //    多数据查询，新API，但是需要一个新的数组接收处理
    @Test
    void testSeriesSelect() {
//        需要一个List集合接收处理
        ArrayList<Integer> list = new ArrayList<>();
//        添加两个id，进行删除操作
        list.add(11);
        list.add(12);
//        deleteBatchIds会将list集合中存放的id，查询后进行删除
        userDao.selectBatchIds(list);
        /*
            ==>  Preparing: SELECT id,name,age,gender,phone FROM tbl_user WHERE id IN ( ? , ? )
            ==> Parameters: 11(Integer), 12(Integer)
            <==    Columns: id, name, age, gender, phone
            <==        Row: 11, MFC, 23, 1, 666888888
            <==        Row: 12, CDM, 23, 0, 123456
        * */
    }
    //    逻辑删除，实则是修改
    @Test
    void testLogicDelete() {
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        System.out.println(userDao.deleteById(2));
        System.out.println(userDao.selectList(lambdaQueryWrapper));
    }
    //    乐观锁，更改值，以免同一数据被再次访问，比如秒杀订单，8个人抢一个东西，抢到了就更改信息，不让别人抢
    @Test
    void testVersion() {
//        先将数据查出来，后面再进行修改，再进行更新操作
        User user = userDao.selectById(8);
        user.setName("Jerry888");
        userDao.updateById(user);
    }
    //    乐观锁，更改值，以免同一数据被再次访问，比如秒杀订单，8个人抢一个东西，抢到了就更改信息，不让别人抢
    @Test
    void testVersion1() {
//        先将数据查出来，后面再进行修改，再进行更新操作，模拟两个人抢同一东西的操作
        User user1 = userDao.selectById(8);
        User user2 = userDao.selectById(8);
        user1.setName("Jerry333");
        userDao.updateById(user1);
        user2.setName("Jerry666");
        userDao.updateById(user1);
    }

4.1 测试所需的yml配置

spring:
  datasource:
    druid:
      db-type: mysql
      url: jdbc:mysql://localhost:3306/mybatis_db
      username: root
      password: 123456
#      spring的控制台开关
  main:
    banner-mode: off
#      开启MP的日志，输出到控制台
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 控制日志文件开关
  global-config:
    banner: false
    db-config:
      table-prefix: tbl_
      id-type: assign_id
#      逻辑删除字段是哪个
      logic-delete-field: deleted
      logic-not-delete-value: 0
      logic-delete-value: 1

4.2 实体类

package com.mao.domain;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
//@TableName("tbl_user")
public class User {
    //    @TableId(type = IdType.ASSIGN_UUID)
    private Integer id;
    private String name;
    private Integer age;
    private Short gender;
    private String phone;
    //    查询映射
    @TableField(value = "pwd", select = false)
    private String password;
    @TableField(exist = false)
    private String online;
////    表示为逻辑字段，0为未删除，1为删除
//    @TableLogic(value = "0", delval = "1")    在yml中被代替
    private Integer deleted;
//    乐观锁
    @Version
    private Integer version;
}

@Data
//用于测试age是否存在上下限
public class UserQuery extends User {
    private Integer age2;
}

4.3 拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //1. 定义拦截器
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //2. 添加具体地拦截器，这里是分页查询的拦截器
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        //3. 添加乐观锁的拦截器
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

5、代码生成器

package com.itheima;

import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;

public class Generator {
    public static void main(String[] args) {
        AutoGenerator autoGenerator = new AutoGenerator();
    DataSourceConfig dataSource = new DataSourceConfig();
    dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    autoGenerator.setDataSource(dataSource);

    autoGenerator.execute();
}
    }

package com.itheima;

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;

public class CodeGenerator {
    public static void main(String[] args) {
        //1.获取代码生成器的对象
        AutoGenerator autoGenerator = new AutoGenerator();    
//设置数据库相关配置
    DataSourceConfig dataSource = new DataSourceConfig();
    dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://192.168.120.20:3306/mybatisplus_db?serverTimezone=UTC");
    dataSource.setUsername("root");
    dataSource.setPassword("z!cGnFq9YSvS$yop02*#pKUN5^ja$NpASIZjf&Vr");
    autoGenerator.setDataSource(dataSource);

    //设置全局配置
    GlobalConfig globalConfig = new GlobalConfig();
    globalConfig.setOutputDir(System.getProperty("user.dir")+"/mybatisplus_04_generator/src/main/java");    //设置代码生成位置
    globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
    globalConfig.setAuthor("shuhongfan");    //设置作者
    globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
    globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
    globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
    autoGenerator.setGlobalConfig(globalConfig);

    //设置包名相关配置
    PackageConfig packageInfo = new PackageConfig();
    packageInfo.setParent("com.shf");   //设置生成的包名，与代码所在位置不冲突，二者叠加组成完整路径
    packageInfo.setEntity("domain");    //设置实体类包名
    packageInfo.setMapper("dao");   //设置数据层包名
    autoGenerator.setPackageInfo(packageInfo);

    //策略设置
    StrategyConfig strategyConfig = new StrategyConfig();
//        strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
        strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称，模块名 = 数据库表名 - 前缀名  例如： User = tbl_user - tbl_
        strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
        strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
        strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
        strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
        autoGenerator.setStrategy(strategyConfig);
        //2.执行生成操作
        autoGenerator.execute();
    }
}

需要添加两个pom依赖