代码驿站移动版

当前位置：主页 > 软件编程 > JAVA代码 >

IDEA搭建SpringBoot多模块聚合工程过程详解(多模块聚合工程)

时间：2022-10-26 09:57:16 | 栏目：JAVA代码 | 点击：次

这篇文章主要是介绍一下，如何在IDEA开发工具下，搭建一个基于SpringBoot的多模块聚合工程项目。

多模块聚合工程：按照MVC的思想，将应用分成三层web、service、mapper/dao这三个主要模块。

本篇文章，将项目模块细分为如下几个子工程模块：

app-common：通用工具类模块，专门用于项目中使用的一些工具类。

app-pojo：实体类模块，专门存放实体类对象，例如：DTO、BO、AO、VO等等对象。

app-mapper：dao接口模块，专门存放操作数据库的dao接口。

app-service：业务逻辑模块，专门进行业务逻辑的处理。

app-web：控制器模块，用于页面请求控制模块。

下面正式开始搭建聚合工程。

一、搭建环境

（1）IDEA创建maven工程

通过IDEA创建一个maven的quickstart类型项目，然后删除里面的src目录，保留pom.xml文件即可，如下图所示：

（2）修改pom依赖

修改父工程项目中的pom.xml文件，添加【springboot】依赖。

<?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">
    <modelVersion>4.0.0</modelVersion>
    <name>app-spboot</name>
    <groupId>com.gitee.app</groupId>
    <artifactId>app-spboot</artifactId>
    <version>1.0.0</version>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <!-- SpringBoot父工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
    </parent>
    <!-- 统一依赖管理 -->
    <dependencyManagement>
    </dependencyManagement>
</project>

（3）创建app-common子模块

 在弹出界面中，选择【quickstart】类型的项目，然后下一步，填入子工程信息即可。

 在子工程中，删除多余的【test】目录和【App】启动类，修改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">
    <modelVersion>4.0.0</modelVersion>
    <!-- 引入父工程依赖 -->
    <parent>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-spboot</artifactId>
        <version>1.0.0</version>
    </parent>
    <name>app-common</name>
    <artifactId>app-common</artifactId>
    <version>1.0.0</version>
 
    <dependencies>
    </dependencies>
 
</project>

（4）创建app-pojo子工程

（5）创建app-mapper子工程

（6）创建app-service子工程

 （7）创建app-web子工程

 （8）统一依赖管理

通过前面的七个步骤，我们已经将父工程和子工程都搭建完成了，并且引入了【springboot】父工程依赖。这里，我们为了方便管理每个子工程的依赖，以及其他第三方依赖，我们可以选择在父工程中的【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">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <name>app-spboot</name>
    <modules>
        <module>app-common</module>
        <module>app-pojo</module>
        <module>app-mapper</module>
        <module>app-service</module>
        <module>app-web</module>
    </modules>
    <groupId>com.gitee.app</groupId>
    <artifactId>app-spboot</artifactId>
    <version>1.0.0</version>
    <!-- SpringBoot父工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
    </parent>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- 统一版本管理 -->
        <app.spboot.version>1.0.0</app.spboot.version>
    </properties>
    <!-- 统一依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <!-- common 子工程依赖 -->
            <dependency>
                <groupId>com.gitee.app</groupId>
                <artifactId>app-common</artifactId>
                <version>${app.spboot.version}</version>
            </dependency>
            <!-- pojo 子工程依赖 -->
                <artifactId>app-pojo</artifactId>
            <!-- mapper 子工程依赖 -->
                <artifactId>app-mapper</artifactId>
            <!-- service 子工程依赖 -->
                <artifactId>app-service</artifactId>
            <!-- web 子工程依赖 -->
                <artifactId>app-web</artifactId>
        </dependencies>
    </dependencyManagement>
</project>

（9）添加web依赖

在子工程【app-web】的pom文件中，添加【web】依赖，并且创建【Application】启动类。

<?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">
    <modelVersion>4.0.0</modelVersion>
    <!-- 引入父工程依赖 -->
    <parent>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-spboot</artifactId>
        <version>1.0.0</version>
    </parent>
    <name>app-web</name>
    <artifactId>app-web</artifactId>
    <version>1.0.0</version>
 
    <dependencies>
        <!-- 引入 web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

创建【Application】启动类。

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

创建【TestController】测试类。

@RestController
public class TestController {
    @GetMapping("/")
    public String demo() {
        return "<h3>恭喜你，聚合工程创建成功（别高兴，还没完事呢）</h3>";
    }
}

创建【src/main/resources】目录，新增【application.yml】配置文件。

server:
  port: 6250 # 项目启动端口

启动项目，打开浏览器，访问测试路径。

 到这里，SpringBoot聚合项目已经创建好了，并且能够启动访问了。

（10）关联子工程依赖

上面几个子工程虽然创建好了，但是每个子工程之间并没有依赖关系，现在我们就将这几个子工程进行依赖关联。

我个人将上面几个子工程的依赖关系进行如下关联：

app-web----->app-service（---->表示依赖）

app-service----->app-mapper，app-common

app-mapper----->app-pojo

依次给每个子工程添加上面的依赖即可。

app-mapper子工程引入app-pojo依赖

<dependencies>
    <!-- 引入 pojo 依赖 -->
    <dependency>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-pojo</artifactId>
    </dependency>
</dependencies>

app-service子工程引入app-mapper依赖

<dependencies>
    <!-- 引入 mapper 依赖 -->
    <dependency>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-mapper</artifactId>
    </dependency>
</dependencies>

app-web子工程引入app-service依赖

<dependencies>
    <!-- 引入 service 依赖 -->
    <dependency>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-service</artifactId>
    </dependency>
</dependencies>

（11）测试子工程依赖是否成功

在app-service中添加测试类，然后在app-web中调用app-service中的方法。

注意：这里为了能够在app-service子工程中，能够使用web的注解，我们将原先app-web中的【web】依赖移到【app-service】中去，【app-service】模块中pom文件，如下所示：

<dependencies>
    <!-- 引入 web 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 引入 mapper 依赖 -->
    <dependency>
        <groupId>com.gitee.app</groupId>
        <artifactId>app-mapper</artifactId>
    </dependency>
</dependencies>

【TestService】测试接口

public interface TestService {
    String findAll();
}

【TestServiceImpl】实现类

@Service
public class TestServiceImpl implements TestService {
    @Override
    public String findAll() {
        return "调用app-service子工程中的findAll()方法";
    }
}

【TestController】测试类中，调用【app-service】模块的方法。

@RestController
public class TestController {
    @Autowired
    private TestService testService;
 
    @GetMapping("/findAll")
    public String findAll() {
        return testService.findAll();
    }
}

重新启动工程，打开浏览器，访问findAll路径。

 如果能够，出现上面的结果，则说明，app-web能够调用到app-service中的方法了。

二、集成MyBatis

（1）父工程中添加MyBatis依赖管理

在【app-spboot】父工程对应的pom文件中，添加【MyBatis】的依赖管理，如下所示：

    <properties>
        <!-- 统一版本管理 -->
        <mybatis.version>2.2.2</mybatis.version>
    </properties>
 
    <!-- 统一依赖管理 -->
    <dependencyManagement>
        <dependencies>
            <!-- 引入 mybatis 依赖 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

（2）app-mapper子工程引入MyBatis

在【app-mapper】子工程中，引入【MyBatis】依赖、【mysql】驱动依赖，因为【MyBatis】是专门用于操作数据库的，所以需要引入mysql数据库驱动。

<dependencies>
    <!-- 引入 mybatis 依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <!-- 引入 mysql 依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

（3）创建测试mapper接口 在【app-pojo】子工程中，创建一个【TestUser】实体类。

public class TestUser implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
 
    // setter and getter
}

在【app-mapper】子工程中，创建一个【TestUserMapper】接口。

public interface TestUserMapper {
    List<TestUser> findAll();
}

在【app-mapper】子工程中，创建【src/main/resources/mapper】目录，并且在目录下，新增【TestUserMapper.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.gitee.app.mapper.test.TestUserMapper">
    <!-- 查询数据 -->
    <select id="findAll" resultType="com.gitee.app.pojo.test.TestUser">
        select * from mybatis_test
    </select>
</mapper>

到这里，mapper接口就创建完成了，继续下一步操作。

（4）配置mybatis和mysql数据源

在【app-web】子工程中的【application.yml】配置文件里面，添加mybatis的相关配置信息、mysql数据源信息。

server:
  port: 6250 # 项目启动端口
# 配置 mysql 数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
# mybatis 配置
mybatis:
  mapper-locations: classpath:mapper/**/*.xml # 指定mapper映射文件位置

（5）service调用mapper接口方法

在【app-service】子工程中，注入【TestUserMapper】对象，然后调用【findAll】方法，查询数据库中的数据。

@Service
public class TestServiceImpl implements TestService {
    @Autowired
    private TestUserMapper testUserMapper;
 
    @Override
    public List<TestUser> getAll() {
        return testUserMapper.findAll();
    }
}

（6）启动类添加mapper扫描

@MapperScan(value = "com.gitee.app.mapper.*") // 扫描mapper接口
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

（7）添加测试方法

在原先的【TestController】类中，添加一个【query】方法，用于查询数据库数据。

@RestController
public class TestController {
    @Autowired
    private TestService testService;
    @GetMapping("/")
    public String demo() {
        return "<h3>恭喜你，聚合工程创建成功（别高兴，还没完事呢）</h3>";
    }
    @GetMapping("/findAll")
    public String findAll() {
        return testService.findAll();
    }
    @GetMapping("/query")
    public List<TestUser> query() {
        List<TestUser> list = testService.getAll(); // 访问不报错,映射文件存在方法
        System.out.println(list);
        return list;
    }
}

（8）启动工程测试

启动项目，然后访问query路径，查看是否能够查询到数据库数据。

 到这里，SpringBoot聚合工程，集成MyBatis就完成啦。

三、集成Druid数据源

（1）引入druid依赖

在【app-spboot】父工程的pom依赖中，添加druid统一依赖管理。

<properties>
    <!-- 统一版本管理 -->
    <druid.version>1.2.6</druid.version>
</properties>
 
<!-- 统一依赖管理 -->
<dependencyManagement>
    <dependencies>
        <!-- 引入 druid 依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

在【app-mapper】子工程中，引入【druid-spring-boot-starter】依赖

<dependencies>
    <!-- 引入 druid 依赖 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
    </dependency>
</dependencies>

（2）添加druid配置

在【app-web】子工程【application.yml】配置文件中，添加druid相关配置

server:
  port: 6250 # 项目启动端口
# 配置 mysql 数据源
spring:
  datasource:
    # druid 相关配置
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/zblog_test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      initial-size: 5 # 初始化连接数量
      min-idle: 5 # 最小数量
      max-active: 20 # 最多数量
      max-wait: 60000 # 获取连接最大超时等待时间，单位毫秒ms
      time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒ms
      min-evictable-idle-time-millis: 300000 # 配置一个连接在池中最小生存的时间，单位是毫秒ms
      # 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用
      validation-query: SELECT 1 FROM DUAL # 用来检测连接是否有效的sql，要求是一个查询语句
      # 建议配置为true，不影响性能，并且保证安全性。
      # 获取连接的时候检测，若空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      test-while-idle: true
      # 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      test-on-borrow: true
      # 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      test-on-return: true
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      # configuration of druid plugin
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall
      use-global-data-source-stat: true
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # configuration of druid control server
      stat-view-servlet:
        enabled: true # 开启druid监控页面,false则访问出现404
        login-username: root # druid监控登录用户
        login-password: root # druid监控登录密码
        reset-enable: false
        url-pattern: /druid/* # druid监控界面访问路径
      web-stat-filter:
        url-pattern: /* # 添加过滤规则
        # 对以下类型，忽略过滤格式
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
 
# mybatis 配置
mybatis:
  mapper-locations: classpath:mapper/**/*.xml # 指定mapper映射文件位置

（3）启动工程测试

启动工程，访问【http://localhost:6250/druid】，此时如果配置成功，则会跳转到Druid监控的登录界面。

 到这里，SpringBoot集成Druid数据源就完成啦。。。。

四、集成Log4j2日志

（1）添加Log4j2依赖

<!-- 引入 web 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 排除SpringBoot自带的日志依赖 -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 引入 log4j2 依赖, 版本和SpringBoot一致 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

（2）编写Log4j2配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--
    配置 log4j2 日志输出相关内容
    日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL
-->
<!-- status 定义 log4j2 内部日志级别 -->
<configuration status="INFO">
    <!-- 自定义全局变量 -->
    <Properties>
        <!-- 日志输出的格式 -->
        <property name="pattern" value="%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%-5thread] %logger{36}: %msg%n"/>
        <!-- 日志文件输出路径 -->
        <property name="filePath" value="/app_spboot/logs"/>
        <!-- 日志文件输出名称 -->
        <property name="fileName" value="app.log"/>
    </Properties>
    <!--  -->
    <appenders>
        <!-- 控制台日志输出 -->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${pattern}"/>
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>
        <!-- 文件日志输出 -->
        <File name="File" fileName="${filePath}/${fileName}" append="false">
            <PatternLayout pattern="${pattern}"/>
        </File>
        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${filePath}/info.log" filePattern="${filePath}/${fileName}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${pattern}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>
 
        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${filePath}/warn.log" filePattern="${filePath}/${fileName}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${pattern}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>
        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${filePath}/error.log" filePattern="${filePath}/${fileName}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${pattern}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>
    </appenders>
 
    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>
        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="File"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

（3）配置Log4j2日志

# 日志配置
logging:
  config: classpath:log4j2.xml # 指定log4j2配置文件

（4）测试日志输出功能

在【TestController】类中，添加如下测试代码

@RestController
public class TestController {
    // 日志输出对象
    private static final Logger LOG = LoggerFactory.getLogger(TestController.class);
    @Autowired
    private TestService testService;
    @GetMapping("/query")
    public List<TestUser> query() {
        LOG.info("======>>>: 开始查询数据库");
        List<TestUser> list = testService.getAll();
        LOG.info("======>>>: 数据库查询完成");
        System.out.println(list);
        return list;
    }
}

注意：上面日志引入的包是slf4j里面的。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

启动项目，访问查询方法，查看控制台和日志文件是否有日志输出即可，有日志输出，则表示Log4j2配置成功啦。

以上，就是SpringBoot搭建多模块聚合工程，并且集成了MyBatis框架、Druid数据源、Log4j2日志依赖。

您可能感兴趣的文章:

相关文章