自定义log配置文件

实际是使用过程中，很有可能日志文件在一个自定义的位置，需要自定义一下，可以用以下的方式实现

• 在spring 启动前设置properties指定对应配置文件的名字和地址
• 修改启动脚本或者直接加入如下代码

System.setProperty(LoggingApplicationListener.CONFIG_PROPERTY,对应日志配置文件);

spring boot logging system 基本启动流程

• 启动入口

org.springframework.boot.context.logging.LoggingApplicationListener

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationStartingEvent) {
                       // 预启动
            onApplicationStartingEvent((ApplicationStartingEvent) event);
        }
        else if (event instanceof ApplicationEnvironmentPreparedEvent) {
                     // 启动
            onApplicationEnvironmentPreparedEvent(
                    (ApplicationEnvironmentPreparedEvent) event);
        }
        else if (event instanceof ApplicationPreparedEvent) {
                // 将对应的loggingSystem（比如LogbackLoggingSystem）暴露到spring上下文中，供业务引用
            onApplicationPreparedEvent((ApplicationPreparedEvent) event);
        }
        else if (event instanceof ContextClosedEvent && ((ContextClosedEvent) event)
                .getApplicationContext().getParent() == null) {
            onContextClosedEvent();
        }
        else if (event instanceof ApplicationFailedEvent) {
            onApplicationFailedEvent();
        }
    }

• beforeInitialize 启动准备

org.springframework.boot.logging.logback.LogbackLoggingSystem#beforeInitialize

    @Override
    public void beforeInitialize() {
        LoggerContext loggerContext = getLoggerContext();
               // 防止重复启动， 启动标志完毕的写入逻辑在Initilize那一节会提到
        if (isAlreadyInitialized(loggerContext)) {
            return;
        }
                // 删除可能预先加载的jul 业务代码
        super.beforeInitialize();
                // 禁止所有日志数据打印
        loggerContext.getTurboFilterList().add(FILTER);
    }

• 启动
  org.springframework.boot.context.logging.LoggingApplicationListener

        if (this.loggingSystem == null) {
            this.loggingSystem = LoggingSystem
                    .get(event.getSpringApplication().getClassLoader());
        }
// 正式启动
        initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());

    private void initializeSystem(ConfigurableEnvironment environment,
            LoggingSystem system, LogFile logFile) {
        LoggingInitializationContext initializationContext = new LoggingInitializationContext(
                environment);
// 寻找自定义配置文件 配置key 
        String logConfig = environment.getProperty(CONFIG_PROPERTY);
        if (ignoreLogConfig(logConfig)) {
            system.initialize(initializationContext, null, logFile);
        }
        else {
            try {
                ResourceUtils.getURL(logConfig).openStream().close();
                system.initialize(initializationContext, logConfig, logFile);
            }
            catch (Exception ex) {
                // NOTE: We can't use the logger here to report the problem
                System.err.println("Logging system failed to initialize "
                        + "using configuration from '" + logConfig + "'");
                ex.printStackTrace(System.err);
                throw new IllegalStateException(ex);
            }
        }
    }

org.springframework.boot.logging.logback.LogbackLoggingSystem#initialize

    public void initialize(LoggingInitializationContext initializationContext,
            String configLocation, LogFile logFile) {
        LoggerContext loggerContext = getLoggerContext();
        if (isAlreadyInitialized(loggerContext)) {
            return;
        }
// 初始化核心逻辑
        super.initialize(initializationContext, configLocation, logFile);
   // 打开日志开关，让日志可以正常打印
        loggerContext.getTurboFilterList().remove(FILTER);
// 写入初始化完毕标志，防止重复初始化
        markAsInitialized(loggerContext);
        if (StringUtils.hasText(System.getProperty(CONFIGURATION_FILE_PROPERTY))) {
            getLogger(LogbackLoggingSystem.class.getName()).warn(
                    "Ignoring '" + CONFIGURATION_FILE_PROPERTY + "' system property. "
                            + "Please use 'logging.config' instead.");
        }
    }

org.springframework.boot.logging.AbstractLoggingSystem#initialize

        if (StringUtils.hasLength(configLocation)) {
// 使用自定义的配置文件 最终使用loadConfiguration让配置生效
            initializeWithSpecificConfig(initializationContext, configLocation, logFile);
            return;
        }
// 使用默认的配置文件 最终使用loadConfiguration让配置生效 如果没有任何配置，则使用默认配置项
// 配置文件的优先级是  logback-*.xml->logback-spring-*.xml
        initializeWithConventions(initializationContext, logFile);

org.springframework.boot.logging.logback.LogbackLoggingSystem#loadConfiguration

// 导入默认配置项，如最大文件大小等等
        super.loadConfiguration(initializationContext, location, logFile);
// 清理已有的配置
        LoggerContext loggerContext = getLoggerContext();
        stopAndReset(loggerContext);
// 检测配置文件地址是否正确
        try {
// 使配置生效
            configureByResourceUrl(initializationContext, loggerContext,
                    ResourceUtils.getURL(location));
        }
        catch (Exception ex) {
            throw new IllegalStateException(
                    "Could not initialize Logback logging from " + location, ex);
        }
        List<Status> statuses = loggerContext.getStatusManager().getCopyOfStatusList();
        StringBuilder errors = new StringBuilder();
        for (Status status : statuses) {
            if (status.getLevel() == Status.ERROR) {
                errors.append((errors.length() > 0) ? String.format("%n") : "");
                errors.append(status.toString());
            }
        }
        if (errors.length() > 0) {
            throw new IllegalStateException(
                    String.format("Logback configuration error detected: %n%s", errors));
        }