需求背景：
公司有个springboot单体项目，日志框架采用log4j2，是maven聚合工程，运行在Windowsserver服务器（不是Linux，哈哈.. log4j2框架2.13.3 左右的版本有严重漏洞，这个要升级哦，这里就不多说了）
yml文件的配置就是：
1、主配置文件application.yml
2、子配置文件：application-dev.yml （用于开发环境）
3、子配置文件：application-prod.yml （用于生产环境）
然而，这个项目卖给多个客户时，配置文件就会变得非常多，比如：
需求1：
那么，部署到某个客户服务器时，其他客户的配置文件是不是得删掉？如果不删就暴露了其他客户的配置信息，这是不妥的！所以在maven打包的时候，就要去掉其他客户的配置文件！
需求2：
A客户的springboot项目部署到 X服务器后，为节约成本，B客户的springboot项目也部署到X服务器。那么就会有个问题，log4j2.xml的保存目录要改，比如
A客户的日志文件改成：
<property name="LOG_FILE_PATH" value="/A客户/mylog" />B客户的日志文件改成：
<property name="LOG_FILE_PATH" value="/B客户/mylog" />这样每次手动改，就很烦，所以要做成变量形式！
其他：
项目是springboot 2.3.4.RELEASE 版本的，网上的一些解决方案在此版本是无效的，虽然可以通过升级springboot版本解决一些问题，但是公司jdk是1.8的，如果升级springboot版本，那也得升级jdk，那么多个客户，能用就行，谁吃饱撑着浪费时间去升级，除非公司要求
需求1解决方案
打包前，修改主配置文件application.yml为
spring.profiles.active: qx
（ 以上的修改也可以通过maven配置来实现，比如定义<profiles> ）
在子pom.xml文件中增加插件：gmavenplus-plugin、maven-antrun-plugin、maven-resources-plugin
原理：先获取springboot主配置文件中spring.profiles.active的值，然后删除其他yml文件，最后把主配置文件和客户的配置文件打包进来
<?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>YMRoot</artifactId>
<groupId>com.yema</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ym-terminal-boot</artifactId>
<dependencies>
<dependency>
<groupId>com.yema</groupId>
<artifactId>ym-common</artifactId>
</dependency>
</dependencies>
<build>
<finalName>ym-terminal-boot</finalName>
<plugins>
<plugin>
<!--该插件主要用途：可执行的 JAR / WAR -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- 过滤掉无关的yml配置文件步骤如下： -->
<!-- 1、 获取springboot主配置文件spring.profiles.active的值并设置为pom文件的属性值springActive，springActive为客户的配置文件 -->
<plugin>
<groupId>org.codehaus.gmavenplus</groupId>
<artifactId>gmavenplus-plugin</artifactId>
<version>2.1.0</version>
<dependencies>
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy</artifactId>
<version>3.0.20</version>
</dependency>
</dependencies>
<executions>
<execution>
<id>read-application-yml</id>
<!--Maven 生命周期阶段 validate → initialize → generate-sources → process-resources → compile → ...-->
<phase>initialize</phase>
<goals>
<goal>execute</goal>
</goals>
<configuration>
<scripts>
<script><![CDATA[
// 安全处理Windows路径
def baseDir = project.basedir.toString().replace('\\', '/')
def ymlPath = baseDir + "/src/main/resources/application.yml"
// 调试输出
println "Attempting to load YML from: " + ymlPath
// 读取文件
def ymlFile = new File(ymlPath)
if (!ymlFile.exists()) {
throw new RuntimeException("YML配置文件未找到: " + ymlPath)
}
// 解析YML
def config = new org.yaml.snakeyaml.Yaml().load(ymlFile.newInputStream())
// 多层级尝试获取profile
def activeProfile = config?.get('spring')?.get('profiles')?.get('active') ?:
config?.get('spring.profiles.active') ?: 'dev'
// 设置Maven属性
project.properties.springActive = activeProfile
println "成功设置激活的profile: " + activeProfile
]]></script>
</scripts>
</configuration>
</execution>
</executions>
</plugin>
<!-- 2、清理掉无关的yml文件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<id>clean-unwanted-ymls</id>
<phase>prepare-package</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<target>
<!-- 删除 target/classes 下不需要的 YML -->
<delete>
<fileset dir="${project.build.outputDirectory}">
<!-- 删除下面的文件 -->
<include name="application-*.yml"/>
<!-- 删除但不包括下面的文件 -->
<exclude name="application-${springActive}.yml"/>
</fileset>
</delete>
</target>
</configuration>
</execution>
</executions>
</plugin>
<!-- 3、把主配置文件和客户的springActive的yml文件打包进来 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.3.0</version>
<executions>
<execution>
<id>filter-resources</id>
<!--Maven 生命周期阶段，要比gmavenplus插件阶段迟才能拿到${springActive}的值。
validate → initialize → generate-sources → process-resources → compile → ...-->
<phase>prepare-package</phase>
<goals>
<goal>resources</goal>
</goals>
<configuration>
<!-- 覆盖之前的资源配置 -->
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
<includes>
<include>application.yml</include>
<include>application-${springActive}.yml</include>
</includes>
</resource>
</resources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>好处：
需求2解决方案
log4j2-spring.xml (必须叫这个名字，如果是log4j2.xml启动会有报错信息，虽然不关紧要，但看着报错就难受) ，log4j2.xml的配置如下，基本上不用动什么，有日期能压缩，满足生产需求了。要变动的就是增加了变量${sys:ACTIVE_PROFILE} ，这个ACTIVE_PROFILE变量实际上是spring.profiles.active的值，要在启动springboot的main方法中去设置下。原理就是：在启动springboot前，解析application.yml主配置文件获取active的值(因为看active 就知道是哪个客户了)，设置为系统属性，然后日志文件中用${sys:} 来获取（网上说的${spring:} 这些都不行）
<?xml version="1.0" encoding="UTF-8"?>
<!--
configuration 节点的属性:
status:用来指定log4j本身的打印日志的级别.
monitorinterval:用于指定log4j自动重新配置的监测间隔时间，单位是s,最小是5s.
-->
<!--
日志级别以及优先级排序（由高到低）: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL
-->
<configuration status="DEBUG" monitorinterval="60">
<!--声明属性-->
<Properties>
<!--这里的log.path是定义日志存放的地方，此处是存放于项目根路径下的/sf.xlogs文件夹中-->
<!-- <Property name="log.path">/sf.xlogs</Property>-->
<!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
<!-- %logger{36} 表示 Logger 名字最长36个字符 -->
<property name="LOG_PATTERN" value="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36}(%F:%L) - %msg%n" />
<!-- 定义日志存储的路径 -->
<property name="LOG_FILE_PATH" value="/XLogs/terminal-${sys:ACTIVE_PROFILE}" />
<property name="FILE_NAME" value="terminalFile" />
</Properties>
<!--声明日志输出位置-->
<Appenders>
<!--
Console节点用来定义输出到控制台的Appender
name : 指定Appender的名字，用于Logger节点引用
target : SYSTEM_OUT 或 SYSTEM_ERR,一般设置为:SYSTEM_OUT
PatternLayout : 指定日志输出格式，默认为%m%n
-->
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="${LOG_PATTERN}"/> <!--[%d{HH:mm:ss:SSS}] [%p] [%t] - %l - %m%n-->
</Console>
<!--
File节点用来定义输出到指定位置的文件
name:指定Appender的名字.
fileName:指定输出日志的目的文件带全路径的文件名.
PatternLayout:输出格式，不设置默认为:%m%n.
-->
<File name="XLogs" fileName="${LOG_FILE_PATH}/xlogs.log" append="false">
<PatternLayout pattern="${LOG_PATTERN}"/> <!--[%d{HH:mm:ss:SSS}] [%p] [%t] - %l - %m%n-->
<!-- 控制台只输出info其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
</File>
<!--
RollingFile 节点用来定义超过指定大小自动删除旧的创建新的的Appender
name:指定Appender的名字.
fileName:指定输出日志的目的文件带全路径的文件名.
PatternLayout:输出格式，不设置默认为:%m%n.
filePattern:指定新建日志文件的名称格式.
Policies:指定滚动日志的策略，就是什么时候进行新建日志文件输出日志.
ThresholdFilter : 日志过滤器（如果存在多个日志过滤器，则使用<Filters></Filters>包含住）
TimeBasedTriggeringPolicy:Policies子节点，基于时间的滚动策略，interval属性用来指定多久滚动一次，默认是1 hour。modulate=true用来调整时间：比如现在是早上3am，interval是4，那么第一次滚动是在4am，接着是8am，12am...而不是7am.
SizeBasedTriggeringPolicy:Policies子节点，基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小.
DefaultRolloverStrategy:用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，创建新的(通过max属性)。
只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch） DENY(拒绝)，NEUTRAL(中立)，ACCEPT(允许)
该RollingFile的Filters 代表的意思是，只输出info级别的日志,【先拒绝日志，后接受日志】顺序不能颠倒
<RollingFile name="RollingFile" fileName="${log.path}/spring-trade-rolling.log"
filePattern="${log.path}/logs/${date:yyyy-MM}/info-%d{yyyy-MM-dd}.log.zip">
<Filters>
<ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
</Filters>
<PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] [%t] - %l - %m%n"/>
<Policies>
<TimeBasedTriggeringPolicy modulate="true" interval="1"/>
</Policies>
</RollingFile>-->
<!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
<RollingFile name="RollingFileInfo" fileName="${LOG_FILE_PATH}/info.log" filePattern="${LOG_FILE_PATH}/logs/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.zip">
<!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
<PatternLayout pattern="${LOG_PATTERN}"/>
<Policies>
<!--interval属性用来指定多久滚动一次，默认是1 hour-->
<TimeBasedTriggeringPolicy modulate="true" interval="1"/>
<SizeBasedTriggeringPolicy size="10MB"/>
</Policies>
<!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
<DefaultRolloverStrategy max="15"/>
</RollingFile>
<!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
<RollingFile name="RollingFileWarn" fileName="${LOG_FILE_PATH}/warn.log" filePattern="${LOG_FILE_PATH}/logs/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.zip">
<!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
<ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
<PatternLayout pattern="${LOG_PATTERN}"/>
<Policies>
<!--interval属性用来指定多久滚动一次，默认是1 hour-->
<TimeBasedTriggeringPolicy modulate="true" interval="1"/>
<SizeBasedTriggeringPolicy size="10MB"/>
</Policies>
<!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
<DefaultRolloverStrategy max="15"/>
</RollingFile>
<!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
<RollingFile name="RollingFileError" fileName="${LOG_FILE_PATH}/error.log" filePattern="${LOG_FILE_PATH}/logs/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.zip">
<!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
<ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
<PatternLayout pattern="${LOG_PATTERN}"/>
<Policies>
<!--interval属性用来指定多久滚动一次，默认是1 hour-->
<TimeBasedTriggeringPolicy modulate="true" interval="1"/>
<SizeBasedTriggeringPolicy size="10MB"/>
</Policies>
<!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
<DefaultRolloverStrategy max="15"/>
</RollingFile>
</Appenders>
<!--
Root节点用来指定项目的根日志，如果没有单独指定Logger，那么就会默认使用该Root日志输出
level:日志输出级别，共有8个级别，按照从低到高为：All < Trace < Debug < Info < Warn < Error < Fatal < OFF.
AppenderRef：Root的子节点，用来指定该日志输出到哪个Appender.
Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。
level:日志输出级别，共有8个级别，按照从低到高为：All < Trace < Debug < Info < Warn < Error < Fatal < OFF.
name:用来指定该Logger所适用的类或者类所在的包全路径,继承自Root节点.
AppenderRef：Logger的子节点，用来指定该日志输出到哪个Appender,如果没有指定，就会默认继承自Root.如果指定了，那么会在指定的这个Appender和Root的Appender中都会输出，此时我们可以设置Logger的additivity="false"只在自定义的Appender中进行输出。
-->
<!--<Loggers>
<!–过滤掉spring和mybatis的一些无用的All,Trace,Debug级别的日志信息–>
<logger name="org.springframework" level="INFO"/>
<logger name="com.spring" level="INFO"/>
<!–
additivity设置成false:org.mybatis包下的日志,只会打印到LogFile的appender中,不会再打到Root中定义的appender中
additivity设置成true或不设置:日志除了打到LogFile的appender中,还会打印到Root中定义的appender的中
–>
<logger name="org.mybatis" level="INFO" additivity="false">
<appender-ref ref="LogFile"/>
</logger>
<!–level代表只输出info级别以上的日志–>
<root level="info">
<appender-ref ref="Console"/>
<appender-ref ref="RollingFile"/>
</root>
</Loggers>-->
<!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
<!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
<loggers>
<!--过滤掉spring和mybatis的一些无用的DEBUG信息
监控系统信息 若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
<Logger name="org.springframework" level="info" additivity="false">
<AppenderRef ref="Console"/>
</Logger>
<logger name="com.spring" level="INFO"/>
<logger name="org.mybatis" level="info" additivity="false">
<AppenderRef ref="Console"/>
</logger>
<root level="info">
<appender-ref ref="Console"/>
<appender-ref ref="XLogs"/>
<appender-ref ref="RollingFileInfo"/>
<appender-ref ref="RollingFileWarn"/>
<appender-ref ref="RollingFileError"/>
</root>
</loggers>
</configuration>springboot启动入口
package com.yema;
import org.apache.commons.lang3.StringUtils;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.yaml.snakeyaml.Yaml;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
@EnableScheduling
@SpringBootApplication
public class TerminalApplication extends SpringBootServletInitializer {
public static void main(String[] args) throws IOException {
System.setProperty("ACTIVE_PROFILE", getActive());
SpringApplication.run(TerminalApplication.class,args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(TerminalApplication.class);
}
/**
* 获取启动环境配置值
* @return
* @throws IOException
*/
private static String getActive() throws IOException {
//1、先从系统属性获取
String property = System.getProperty("spring.profiles.active");
if (!StringUtils.isBlank(property)){
return property;
}
//2、系统属性没有就获取主配置文件的
Yaml yaml = new Yaml();
Map<String, Object> config;
try (InputStream in = TerminalApplication.class
.getClassLoader()
.getResourceAsStream("application.yml")) {
config = yaml.load(in);
}
// 安全获取 active（默认返回 null 或默认值）
if (config != null) {
if (config.get("spring.profiles.active") != null){
return config.get("spring.profiles.active").toString();
}
Map<String, Object> springMap = (Map<String, Object>) config.get("spring");
if (springMap != null) {
Map<String, Object> profilesMap = (Map<String, Object>) springMap.get("profiles");
if (profilesMap != null) {
Object active = profilesMap.get("active");
if (active != null) {
return active.toString();
}
}
}
}
return "default";
}
}
需求2的Java部分，其实还有其他方式，比如在执行命令的是主动设置参数，看个人喜好。
总之，单体项目打包好，扔服务器执行即可。对于Windowsserver来说，写个bat文件啥的就满足了。好维护，简单粗暴。
论技术，肯定喜欢微服务啥的全套上
实际上，很多企业并发量用户量没多少，买个服务器硬件性能都抠抠搜搜