java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > IDEA搭建SpringBoot多模块聚合工程

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

作者：朱友斌

这篇文章主要是介绍一下，如何在IDEA开发工具下，搭建一个基于SpringBoot的多模块聚合工程项目,本篇文章，将项目模块细分为几个子工程模块,在文中给大家详细介绍过，对IDEA搭建SpringBoot多模块聚合工程感兴趣的朋友一起看看吧

这篇文章主要是介绍一下，如何在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日志依赖。

到此这篇关于IDEA搭建SpringBoot多模块聚合工程详细步骤(多模块聚合工程)的文章就介绍到这了,更多相关IDEA搭建SpringBoot多模块聚合工程内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文