IDEA搭建SpringBoot多模組聚合工程過程詳解(多模組聚合工程)

2022-04-07 13:02:40

這篇文章主要是介紹一下，如何在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資料來源

Druid是阿里巴巴開源的一款資料庫連線池。
Druid提供了和SpringBoot整合的starter，叫做：【druid-spring-boot-starter】。

（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依賴

SpringBoot的依賴中，預設有紀錄檔相關依賴，我們如果要使用Log4j2紀錄檔依賴，需要將SpringBoot自帶的依賴剔除。
在【app-service】子工程中，將【spring-boot-starter-web】依賴中剔除【spring-boot-starter-logging】依賴，並且引入【spring-boot-starter-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組態檔

Log4j2有兩種組態檔，第一種是【properties】，第二種是【xml】，一般都採用【xml】的格式來定義Log4j2紀錄檔資訊。
在【src/main/resources】目錄下，建立【log4j2.xml】組態檔。

<?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紀錄檔

在【application.yml】組態檔中，指定【log4j2.xml】組態檔的路徑。
通過步驟(2)，我們已經編寫好了log4j2.xml組態檔，但是SpringBoot還不知道log4j2.xml組態檔在哪裡，需要我們手動進行設定，告訴SpringBoot去哪裡載入log4j2.xml組態檔。

# 紀錄檔設定
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紀錄檔依賴。

到此這篇關於IDEA搭建SpringBoot多模組聚合工程詳細步驟(多模組聚合工程)的文章就介紹到這了,更多相關IDEA搭建SpringBoot多模組聚合工程內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！