搭建SpringBoot多模块微服务项目脚手架(二)

文章目录

搭建SpringBoot多模块微服务项目脚手架(二)
- 1.概述
- 2.封装 MybatisPlus
- - 2.1.封装MybatisPlus
  - - 1.安装依赖
    - 2.安装lombok插件
    - 3.配置数据库链接信息
  - 2.2.创建公共子模块
  - - 1.创建公共模块common
    - 2.创建common_utils模块
    - 3.创建service_base模块
    - 4.公共层模块结构预览
    - 5.每个模块pom文件内容
  - 2.2.MybatisPlus自动填充
  - - 1.引用mybatisplus依赖
    - 2.引入springbootweb依赖
    - 3.创建自动填充策略
    - 4.使用自动填充模块
  - 2.3.MybatisPlus分页查询
  - - 1.封装分页功能
  - 2.4.MybatisPlus逻辑删除
  - - 1.封装逻辑删除
    - 2.逻辑删除使用
- 3.封装Swagger
- - 3.1.导入Swagger依赖
  - - 1.工程父模块配置Swagger依赖版本
    - 2.common公共模块导入Swagger依赖
  - 3.2.创建Swagger配置类
  - 3.3.修改SpringBoot2.6默认路径策略
  - 3.4.使用Swagger
  - 3.5.启动类添加包扫描注解
- 4.封装自动生成代码工具
- - 4.1.导入依赖
  - - 1.工程父模块配置依赖版本
    - 2.service模块引入依赖
  - 4.2.创建数据库
  - - 1.创建测试数据库和表
  - 4.3.代码生成类
  - - 1.代码生成类介绍
    - 2.代码生成类内容
  - 4.4.查看自动生成的代码结构
  - - 4.5.分页查询添加mapper扫描路径

1.概述

搭建SpringBoot多模块微服务项目脚手架第二篇文章，在搭建本篇文章内容前，先查看搭建SpringBoot多模块微服务项目脚手架一)搭建基础环境。

第一篇文章
https://blog.csdn.net/m0_38039437/article/details/129408124
搭建SpringBoot多模块微服务框架

第二篇文章
封装《MybatisPlus》
封装《Swagger》
封装《自动生成代码工具》

第三篇文章
封装《接口统一返回信息模板》
封装《接口统一请求信息模板》
封装《统一异常信息模板》
封装《统一日志模板》

2.封装 MybatisPlus

2.1.封装MybatisPlus

1.安装依赖

安装的依赖介绍

mybatis-plus-boot-starter：MybatisPlus依赖，使用接口提供的方法操作数据库CURD方业务。
mysql-connector-java：数据库链接
lombok：通过注解为实体类提供get、set方法省去手写这些重复代码。

1.在parent_spring 父模块的pom.xml 文件中properties标签配置管理依赖插件版本，在dependencies标签中添加mybatis-plus依赖

<?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.6.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.bruce</groupId>
    <artifactId>parent_spring</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>parent_spring</name>
    <description>Demo project for Spring Boot</description>
    <packaging>pom</packaging>

    <modules>
        <module>service</module>
    </modules>

    <!-- 管理依赖插件的版本 -->
    <properties>
        <java.version>1.8</java.version>
        <mybatis-plus.version>3.0.5</mybatis-plus.version>
    </properties>

    <!-- 添加包管理标签 <dependencyManagement> -->
    <dependencyManagement>
    <dependencies>
        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

    </dependencies>
    </dependencyManagement>

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

</project>

2.service模块的pom.xml 文件中引入mybatis-plus 和 mysql-connector-java 和 lombok 依赖，这些依赖都是从父模块继承过来，因此不需要写版本号。

    <!-- 2.添加dependencies标签 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

2.安装lombok插件

1.使用lombok除了安装依赖，还要在IDEA 安装lombok插件

在这里插入图片描述

2.设置启用注解
mac系统：点击 IntelliJ IDEA 下拉框点击 Preferences
windows系统：点击 File 下拉框点击Setting

点击 Build Execution Deployment 下拉框点击 Compiler 下拉框点击 Annotation Processors ，勾选 Enable annotation processing

在这里插入图片描述

3.配置数据库链接信息

在微服务业务模块的resources 文件夹中application.properties 配置文件中配置连接数据库信息。
例如在service_user模块的resources 文件夹中application.properties 配置文件中配置连接数据库信息

jdbc驱动名称和旧版本的驱动名称有区别：driver-class-name 使用了 com.mysql.cj.jdbc.Driver ，在 jdbc 8 中建议使用这个驱动，之前的 com.mysql.jdbc.Driver 已经被废弃，否则运行测试用例的时候会有 WARN 信息
设置时区：新版本的jdbc驱动需要在url后面添加时区?serverTimezone=GMT%2B8，我们国家属于东八区。

# 服务端口
server.port=8001
# 服务名
spring.application.name=service-edu

# 环境设置：dev、test、prod
spring.profiles.active=dev

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/my_springboot?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

2.2.创建公共子模块

在项目中有些功能是需要封装后才能使用的，而这些功能在每个微服务模块中都会使用。因此我们把这些公共的功能放到一个公共模块中维护，每个业务的微服务模块只需要将它作为依赖引入即可。
公共模块我们根据封装的功能不同也做了分层设计，比如
common_utils层封装一些不依赖业务的功能模块，能够在所有项目中单独使用。
service_base层封装一些业务基层需要的功能，这些功能和业务有依赖、耦合关系不能在所有项目中使用。

1.创建公共模块common

common模块用来管理所有公共模块，比如common_utils 和 service_base

1.在父模块 parent_spring 右键点击 New 点击 Module 新建模块
2.选择创建Maven 类型模块
3.输入模块信息

Parent：选择它要创建在哪个父模块下。例如 parent_spring
Name: 新建模块的名称。例如 common
Location：新建模块创建的路径，默认即可

4.common模块作为管理层，不写代码因此将src删除
5.修改common模块pom.xml 配置文件

common模块改为pom类型

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent_spring</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common</artifactId>
    <!--设置为pom类型-->
    <packaging>pom</packaging>


</project>

2.创建common_utils模块

1.在模块 common 右键点击 New 点击 Module 新建模块
2.选择创建Maven 类型模块
3.输入模块信息

Parent：选择它要创建在哪个父模块下。例如 common
Name: 新建模块的名称。例如 common_utils
Location：新建模块创建的路径，默认即可

4.打开模块点击src -> main -> java，在java上右键新建包，输入包名例如 com.bruce.commonutils

3.创建service_base模块

1.在模块 common 右键点击 New 点击 Module 新建模块
2.选择创建Maven 类型模块
3.输入模块信息

Parent：选择它要创建在哪个父模块下。例如 common
Name: 新建模块的名称。例如 service_base
Location：新建模块创建的路径，默认即可

4.打开模块点击src -> main -> java，在java上右键新建包，输入包名例如 com.bruce.servicebase

4.公共层模块结构预览

在这里插入图片描述

5.每个模块pom文件内容

1.common模块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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent_spring</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common</artifactId>
    <packaging>pom</packaging>
    <modules>
        <module>common_utils</module>
        <module>service_base</module>
    </modules>
</project>

2.common_utils模块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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>common</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common_utils</artifactId>
</project>

3.service_base模块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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>common</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service_base</artifactId>
</project>

2.2.MybatisPlus自动填充

数据库表设计时都会设计一个创建时间字段和修改时间字段用来记录每一条数据的创建和修改时间，每次操作数据时都需要前端将创建和修改时间传给我们增加了前端的重复工作量。如果是我们自己提供时间，还需要单独获取下时间也比较麻烦。

MybatisPlus自带了自动填充某个字段数据功能，因此我们可以让创建时间和修改时间自动生成，每次操作数据库时就自动带上。

自动填充功能每个业务模块都会使用，因此我们将它放到公共模块中。每个业务模块引入该模块即可，不需要单独配置。

1.引用mybatisplus依赖

mybatisplus依赖只在公共模块的service_base模块中使用，因此在该模块中引入依赖。如果是所有公共模块都是用的依赖则在common模块中引入依赖。

service_base模块在pom.xml文件中引入mybatisplus依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>common</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service_base</artifactId>

    <dependencies>
        <!--mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-core</artifactId>
            <version>3.0.5</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>


</project>

2.引入springbootweb依赖

封装自动填充类的对象要被spring识别并注册到spring容器中，因此需要引入该依赖。这个依赖所有的公共模块都会用到因此在common模块中引入依赖。

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent_spring</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common</artifactId>
    <packaging>pom</packaging>
    <modules>
        <module>common_utils</module>
        <module>service_base</module>
    </modules>

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


</project>

3.创建自动填充策略

1.在service_base公共模块上点击 src -> main -> java，在 com.bruce.servicebase上新建一个包handler
2.在handler包创建一个类MyMetaObjectHandler实现MetaObjectHandler接口，在插入数据时调用insertFill方法自动填充，在更新数据时调用updateFill方法自动填充。

package com.bruce.servicebase.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author bruce
 * @create 2023/3/9 14:42
 */
// 设置为spring bean对象，注册到spring bean 容器中，其他的模块才能调用这个类对象
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    /**
     * gmtCreate: 是实体类中创建时间字段名称，需要和自己实体类中创建时间字段名称一致
     * gmtModified：实体类中修改时间字段名称，需要和自己实体类中创建时间字段名称一致
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("gmtCreate", new Date(), metaObject);
        this.setFieldValByName("gmtModified", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("gmtModified", new Date(), metaObject);
    }
}

4.使用自动填充模块

1.在service模块的pom.xml文件中引入service_base 公共模块，才能在微服务业务模块中使用它的功能。

<dependency>
    <groupId>com.bruce</groupId>
    <artifactId>service_base</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

2.在实体类中使用@TableField 注解加在创建时间和修改时间字段上启用自动填充功能。

@TableField(fill = FieldFill.INSERT)
private Date gmtCreate;

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date gmtModified;

2.3.MybatisPlus分页查询

在查询业务中分页查询是使用频率非常高的一个查询方法，MybatisPlus实现分页在官网手册中已经给出了开发步骤，只需要两个步骤。

配置MybatisPlus分页插件
开发分页查询代码
官网文档：https://mp.baomidou.com/guide/page.html

1.封装分页功能

封装分页插件是在每个微服务业务模块中创建一个配置类封装，因此下面我们就在service_user模块中创建配置类封装分页功能。

1.在用户服务 service_user 模块上点击src -> main -> java，在java上右键新建包，输入包名 com.bruce.service_user
2.在 com.bruce.service_user 包上新建config包，管理所有配置类。
3.在config包中新建MybatisPlusConfig配置类封装分页查询功能

package com.bruce.service_user.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author bruce
 * @create 2023/3/9 15:28
 */


//MapperScan里面填写mapper包地址，扫描到是mapper映射后，mybatisPlus才能通过mapper包下的类对象操作数据库的内容，
// 现在还没有创建mapper先空着，后面创建在添加
@MapperScan("")
//配置类
@Configuration
public class MybatisPlusConfig {
    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

2.4.MybatisPlus逻辑删除

在删除业务中使用逻辑删除的操作非常的普遍，一般不会将数据物理删除。

物理删除：将数据从数据库中删除，不可恢复。
逻辑删除：在数据库中将删除的数据和正常数据做一个状态区分，数据并没有从数据库中删除。

1.封装逻辑删除

封装逻辑删除是在每个微服务业务模块中创建一个配置类封装，因此下面我们就在service_user模块中创建配置类封装分页功能。

1.在用户服务 service_user 模块，config包中MybatisPlusConfig配置类封装逻辑删除功能

//MapperScan里面填写mapper包地址，扫描到是mapper映射后，mybatisPlus才能通过mapper包下的类对象操作数据库的内容，
// 现在还没有创建mapper先空着，后面创建在添加
@MapperScan("")
//配置类
@Configuration
public class MybatisPlusConfig {
    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

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

2.逻辑删除使用

在实体类上添加deleted属性，并在属性上添加@TableLogic注解

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

3.封装Swagger

整合Swagger3插件管理接口文档，包含如下几个步骤

导入Swagger依赖
创建Swagger配置类
修改SpringBoot2.6默认路径策略
使用Swagger

3.1.导入Swagger依赖

在多模块的项目中，Swagger将被多个业务模块调用。因此我们将它放在一个公共模块比较合适，这样只需要配置一次，所有的模块都可以使用。
Swagger在封装时需要配置一些和业务关联的内容，因此将它封装到service_base公共模块中。

1.工程父模块配置Swagger依赖版本

在parent_spring模块的pom.xml 配置文件中添加Swagger依赖版本

<!-- 管理依赖插件的版本 -->
<properties>
    <swagger.version>3.0.0</swagger.version>
</properties>

<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>${swagger.version}</version>
</dependency>

2.common公共模块导入Swagger依赖

在common模块的pom.xml 配置文件中添加Swagger依赖版本

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent_spring</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>common</artifactId>
    <packaging>pom</packaging>
    <modules>
        <module>common_utils</module>
        <module>service_base</module>
    </modules>

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

        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

3.2.创建Swagger配置类

1.在service_base 公共模块 java文件夹下创建config包。例如：com.bruce.servicebase.config
2.在config包下新建SwaggerConfig配置类，配置Swager信息。

package com.bruce.servicebase.config;

import io.swagger.annotations.Api;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.env.Profiles;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.oas.annotations.EnableOpenApi;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

/**
 * @author bruce
 * @create 2023/3/9 15:53
 */
//配置类
@Configuration
//开启Swagger自定义接口文档。@EnableOpenApi可以在Config类中应用，也可以在SpringBoot主启动类上使用（选其一即可），表示启用自定义API接口
@EnableOpenApi
public class SwaggerConfig {
    @Bean
    public Docket createRestApi(Environment environment) {
        //设置Swagger在哪个环境显示
        Profiles p = Profiles.of("dev", "test");
        //通过environment.acceptsProfiles判断是否处在自己设定的环境中
        boolean flag = environment.acceptsProfiles(p);

        return new Docket(DocumentationType.OAS_30)
                //根据flag的true和false两个值自动设置Swagger显示的环境
                .enable(flag)
                //定义接口组名称
                .groupName("bruce-springboot-api")
                //调用下面apiInfo方法获取基本信息
                .apiInfo(apiInfo())
                //通过.select()方法，去配置扫描接口
                .select()
                .apis(RequestHandlerSelectors.withClassAnnotation(Api.class))
                //扫描的路径包,设置basePackage会将包下的所有被@Api标记类的所有方法作为api
                .apis(RequestHandlerSelectors.basePackage("com"))
                //指定路径处理,PathSelectors.any()代表所有的路径
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Swagger3接口文档标题")
                .description("Swagger3接口描述")
                .contact(new Contact("bruce", "作者网站(www.baidu.com)", "286279186@qq.com"))
                .version("1.0")
                .build();
    }

}

3.3.修改SpringBoot2.6默认路径策略

1.在springboot2.6.0版本及以上将SpringMVC 默认路径匹配策略从AntPathMatcher 更改为PathPatternParser，在启动时候就会报一个错误documentationPluginsBootstrapper NullPointerException，具体位置WebMvcPatternsRequestConditionWrapper中的condition为null

2.在微服务业务模块service_user 的application.properties 服务配置文件中修改SpringMVC默认路径

# 服务端口
server.port=8001
# 服务名
spring.application.name=service-edu

# 环境设置：dev、test、prod
spring.profiles.active=dev

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/my_springboot?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

#修改SpringMVC默认路径策略
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

3.4.使用Swagger

Swagger是在service_base 公共模块封装，因此业务模块要使用Swagger公共需要先引入该公共模块。
在service模块的pom.xml 文件中引入service_base 模块，如果已经引入则忽略。

<dependency>
    <groupId>com.bruce</groupId>
    <artifactId>service_base</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

在service模块的pom.xml 文件中引入Swagger依赖，如果已经引入则忽略。

<!--swagger-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
</dependency>

3.5.启动类添加包扫描注解

因为Swagger放到了common模块中，Service模块是跨模块使用Swagger，包扫描路径默认是本模块路径，因此需要在service业务模块的启动类上添加包扫描注解，用来扫描Swagger所在的包，将它的配置类作为对象注入到项目。

1.在service_user模块com.bruce.service_user包上创建启动类UserApplication，并添加ComponentScan注解

package com.bruce.service_user;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author bruce
 * @create 2023/3/9 16:09
 */
//common公共模块创建的路径是com.bruce，因此我们在这个包路径下扫描配置类。
@ComponentScan(basePackages = {"com.bruce"})
@SpringBootApplication
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class, args);
    }
}

4.封装自动生成代码工具

MybatisPlus提供的代码生成器自动创建Controller、Server、Mapper层的代码，每次创建新的业务模块使用工具生成代码后，就可以直接写业务逻辑。

4.1.导入依赖

需要用到的依赖及作用如下

mybatis-plus-boot-starter：MybatisPlus依赖，使用接口提供的方法操作数据库CURD方业务。
mysql-connector-java：数据库链接
lombok：通过注解为实体类提供get、set方法省去重复代码。
velocity-engine-core: 自动生成代码
gson：操作json工具类
junit: 单元测试工具

1.工程父模块配置依赖版本

前面我们已经安装好了一些依赖，这次我们只需要添加velocity-engine-core 和 gson 依赖，下面是所有需要的依赖版本。

<properties>
    <java.version>1.8</java.version>
    <mybatis-plus.version>3.0.5</mybatis-plus.version>
    <swagger.version>3.0.0</swagger.version>
    <velocity.version>2.0</velocity.version>
    <gson.version>2.8.2</gson.version>
    <junit.version>4.12</junit.version>
</properties>

<!-- velocity 模板引擎, Mybatis Plus 代码生成器需要 -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>${velocity.version}</version>
</dependency>

<!--gson-->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>${gson.version}</version>
</dependency>

<!--junit-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
</dependency>

2.service模块引入依赖

在service模块的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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent_spring</artifactId>
        <groupId>com.bruce</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service</artifactId>
    <!-- 1.设置pom类型 -->
    <packaging>pom</packaging>
    <modules>
        <module>service_user</module>
    </modules>

    <!-- 2.添加dependencies标签 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>

        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!-- velocity 模板引擎, Mybatis Plus 代码生成器需要 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
        </dependency>

        <!--gson-->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>
        
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

        <dependency>
            <groupId>com.bruce</groupId>
            <artifactId>service_base</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <!-- 3.设置打包规则 -->
    <build>
        <resources>
            <resource>
                <!--设置的目录-->
                <directory>src/main/java</directory>
                <!--src/main/java目录下的所有后缀是xml文件打包，两个星表示多层目录，一个星表示一层目录下的xml文件-->
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

4.2.创建数据库

自动生成代码是根据数据库表的字段自动创建实体类，然后通过实体类创建mapper映射。因此我们需要先创建好数据库和表。
下面提供一个简单的创建数据库和表的sql语句，创建测试库和表给自动生成代码类使用。

如果业务中已经有了数据库和表，则不用执行创建数据库操作，直接阅读下面代码生成类内容，生成代码。

1.创建测试数据库和表

手动创建一个数据库，例如命名为my_springboot，然后执行下面SQL语句创建表。

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    `id` char(19) 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 '邮箱',
		is_deleted tinyint(1) unsigned NOT NULL DEFAULT '0' COMMENT '逻辑删除 1（true）已删除， 0（false）未删除',
		gmt_create datetime NOT NULL COMMENT '创建时间',
		gmt_modified datetime NOT NULL COMMENT '更新时间',
    PRIMARY KEY (id)
);

4.3.代码生成类

1.代码生成类介绍

MybatisPlus是通过模板设计思想实现代码生成，首先通过代码生成类配置信息，模板实现类读取其配置信息，根据配置信息创建代码。
1.代码生成类配置信息
在业务模块的test文件夹下点击 java 新建包名com.bruce.test , 在该包下新建auto_code包，该包下创建CodeGenerator类配置生成代码内容。这样在部署项目时就不会部署该类的内容

2.代码生成类需要修改的内容
代码生成类的配置信息分成五个部分，每个部分内容的含义已在类中注释描述。这里列出每个项目需要修改的内容。
3.全局配置部分

修改代码输出目录为自己项目实际的地址
修改自动生成类作者的名字
修改主键策略，根据实际表ID的类型修改

4.数据源配置

配置数据库连接信息和账号信息

5.配置包生成的名称

配置项目包的名称为实际项目包名称

6.策略配置，根据数据库表生成代码

配置要读取的数据库表的名称，代码会自动根据表结构创建对应的代码

2.代码生成类内容

package com.bruce.test.auto_code;

import com.baomidou.mybatisplus.annotation.DbType;
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;
import org.junit.Test;

/**
 * @author bruce
 * @create 2023/3/9 16:49
 */
public class CodeGenerator {
    @Test
    public void run() {

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        GlobalConfig gc = new GlobalConfig();
        //得到当前项目路径
        String projectPath = System.getProperty("user.dir");
        //代码输出目录,为了准确起见配置成绝对路径
        gc.setOutputDir("/Users/edy/Documents/javawork/parent_spring/service/service_user" + "/src/main/java");

        //在自动生成的类上创建作者
        gc.setAuthor("bruce");
        //是否自动打开所有创建的文件夹
        gc.setOpen(false);
        //第一次生成代码后当我们修改代码后，如果再次执行自动生成代码是否覆盖我们修改的代码。
        gc.setFileOverride(false);
        //去掉Service接口的首字母I
        gc.setServiceName("%sService");
        //主键策略,根据数据库表ID的类型选择对应的策略，例如表ID类型是lang选择ID_WORKER，表ID类型是String类型选择ID_WORKER_STR
        gc.setIdType(IdType.ID_WORKER_STR);
        //定义生成的实体类中日期类型
        gc.setDateType(DateType.ONLY_DATE);
        //开启Swagger2模式
        gc.setSwagger2(true);

        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        //自动生成代码不能使用项目配置的数据库配置信息，因此需要在这里配置数据库信息
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/my_springboot?serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("12345678");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、配置包生成的名称
        PackageConfig pc = new PackageConfig();
        //配置包名称
        pc.setParent("com.bruce");
        //配置模块名称
        pc.setModuleName("service_user");
        //配置模块下MVC三层结构的包名
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置，根据数据库表生成代码对应的代码
        StrategyConfig strategy = new StrategyConfig();
        //根据哪张表生成代码就配置哪个表的名称，如果是多个表就写多个表名称，用逗号分割
        strategy.setInclude("user");
        //数据库表映射到实体的命名策略
        strategy.setNaming(NamingStrategy.underline_to_camel);
        //生成实体时去掉表前缀
        strategy.setTablePrefix(pc.getModuleName() + "_");

        //数据库表字段映射到实体的命名策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // lombok 模型 @Accessors(chain = true) setter链式操作
        strategy.setEntityLombokModel(true);

        //restful api风格控制器
        strategy.setRestControllerStyle(true);
        //url中驼峰转连字符
        strategy.setControllerMappingHyphenStyle(true);

        mpg.setStrategy(strategy);


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

4.4.查看自动生成的代码结构

在这里插入图片描述

4.5.分页查询添加mapper扫描路径

在《2.3.MybatisPlus分页查询》中封装好了分页查询功能之后，由于还没有创建mapper映射包，因此路径空着没有填写，现在将扫描路径完善。

package com.bruce.service_user.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author bruce
 * @create 2023/3/9 15:28
 */


//MapperScan里面填写mapper包地址，扫描到是mapper映射后，mybatisPlus才能通过mapper包下的类对象操作数据库的内容，
// 将service_user模块中mapper包路径填写
@MapperScan("com.bruce.service_user.mapper")
//配置类
@Configuration
public class MybatisPlusConfig {
    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

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