广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >IDEA搭建SpringBoot多模块聚合工程过程详解(多模块聚合工程)
  • 316

0
分享到

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

2024-04-02 19:04:59 316人浏览 八月长安

Python 官方文档：入门教程 => 点击学习

摘要

目录一、搭建环境（1）idea创建Maven工程（2）修改pom依赖（4）创建app-pojo子工程（5）创建app-mapper子工程（6）创建app-service子工程&nbs

这篇文章主要是介绍一下，如何在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*.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多模块聚合工程内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: IDEA搭建SpringBoot多模块聚合工程过程详解(多模块聚合工程)

本文链接: https://www.lsjlt.com/news/145207.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作