深入浅出 spring boot 日志

1
2
3
4
private Map<String, Logger> loggerCache;
public final Logger getLogger(final Class<?> clazz) {
    return getLogger(clazz.getName());
}

1
2
3
4
5
6
7
transient private AppenderAttachableImpl<ILoggingEvent> aai;
public synchronized void addAppender(Appender<ILoggingEvent> newAppender) {
    if (aai == null) {
        aai = new AppenderAttachableImpl<ILoggingEvent>();
    }
    aai.addAppender(newAppender);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package ch.qos.logback.core;
  
import ch.qos.logback.core.spi.ContextAware;
import ch.qos.logback.core.spi.FilterAttachable;
import ch.qos.logback.core.spi.LifeCycle;
  

public interface Appender<E> extends LifeCycle, ContextAware, FilterAttachable {

  public String getName();
  public void setName(String name);
  void doAppend(E event);
  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public interface LoggingEvent {

    Level getLevel();

    Marker getMarker();

    String getLoggerName();

    String getMessage();

    String getThreadName();

    Object[] getArgumentArray();

    long getTimeStamp();

    Throwable getThrowable();

}

1
2
3
4
5
6
private void buildLoggingEventAndAppend(final String localFQCN, final Marker marker, final Level level, final String msg, final Object[] params,
                                        final Throwable t) {
    LoggingEvent le = new LoggingEvent(localFQCN, this, level, msg, t, params);
    le.setMarker(marker);
    callAppenders(le);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public void callAppenders(ILoggingEvent event) {
    int writes = 0;
    for (Logger l = this; l != null; l = l.parent) {
        writes += l.appendLoopOnAppenders(event);
        if (!l.additive) {
            break;
        }
    }
    // No appenders in hierarchy
    if (writes == 0) {
        loggerContext.noAppenderDefinedWarning(this);
    }
}

1
2
3
public interface Configurator extends ContextAware {
    public void configure(LoggerContext loggerContext);
}

1
2
3
4
5
6
public class BasicConfigurator extends ContextAwareBase implements Configurator {
    ... 
    public void configure(LoggerContext lc) {
        // 传一个上下文过来，配置一个默认的上下文。
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
public class logbackDemo {
    public static void main(String[] args) {
        LoggerContext loggerContext = new LoggerContext();
        // 去 Cache 里边去取，如果存在就返回，没有的话，实例化一个
        Logger logger = loggerContext.getLogger(logbackDemo.class);
        // 添加控制台的日志附加器
        logger.addAppender(new ConsoleAppender<>());
        BasicConfigurator basicConfigurator = new BasicConfigurator();
        basicConfigurator.configure(loggerContext);
        logger.info("hello, logback");
    }
}

1
2
3
{
    org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(logbackDemo.class);
}

1
2
3
4
5
6
7
8
public class Slf4jDemo {
    public static void main(String[] args) {
        // 类会决定全路径名称，和 Slf4jDemo.class 和 Slf4jDemo.class.getName() 一摸一样的
        // 在重载方法一样都是一样的
        Logger logger = LoggerFactory.getLogger(Slf4jDemo.class);
        logger.info("Hello, slf4j");
    }
}

1
2
3
4
public static Logger getLogger(String name) {
    ILoggerFactory iLoggerFactory = getILoggerFactory();
    return iLoggerFactory.getLogger(name);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static ILoggerFactory getILoggerFactory() {
    if (INITIALIZATION_STATE == UNINITIALIZED) {
        synchronized (LoggerFactory.class) {
            if (INITIALIZATION_STATE == UNINITIALIZED) {
                INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                performInitialization();
            }
        }
    }
    switch (INITIALIZATION_STATE) {
    case SUCCESSFUL_INITIALIZATION:
        return StaticLoggerBinder.getSingleton().getLoggerFactory();
    case NOP_FALLBACK_INITIALIZATION:
        return NOP_FALLBACK_FACTORY;
    case FAILED_INITIALIZATION:
        throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
    case ONGOING_INITIALIZATION:
        // support re-entrant behavior.
        // See also http://jira.qos.ch/browse/SLF4J-97
        return SUBST_FACTORY;
    }
    throw new IllegalStateException("Unreachable code");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private static StaticLoggerBinder SINGLETON = new StaticLoggerBinder();
public static StaticLoggerBinder getSingleton() {
    return SINGLETON;
}
void init() {
        try {
            try {
                // 自动配置
                new ContextInitializer(defaultLoggerContext).autoConfig();
            } catch (JoranException je) {
                Util.report("Failed to auto configure default logger context", je);
            }
            // logback-292
            if (!StatusUtil.contextHasStatusListener(defaultLoggerContext)) {
                StatusPrinter.printInCaseOfErrorsOrWarnings(defaultLoggerContext);
            }
            contextSelectorBinder.init(defaultLoggerContext, KEY);
            initialized = true;
        } catch (Exception t) { // see LOGBACK-1159
            Util.report("Failed to instantiate [" + LoggerContext.class.getName() + "]", t);
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void autoConfig() throws JoranException {
    StatusListenerConfigHelper.installIfAsked(loggerContext);
    URL url = findURLOfDefaultConfigurationFile(true);
    if (url != null) {
        configureByResource(url);
    } else {
        Configurator c = EnvUtil.loadFromServiceLoader(Configurator.class);
        if (c != null) {
            try {
                c.setContext(loggerContext);
                c.configure(loggerContext);
            } catch (Exception e) {
                throw new LogbackException(String.format("Failed to initialize Configurator: %s using ServiceLoader", c != null ? c.getClass()
                                .getCanonicalName() : "null"), e);
            }
        } else {
            BasicConfigurator basicConfigurator = new BasicConfigurator();
            basicConfigurator.setContext(loggerContext);
            basicConfigurator.configure(loggerContext);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ApplicationStartingEvent) {
        this.onApplicationStartingEvent((ApplicationStartingEvent)event);
    } else if (event instanceof ApplicationEnvironmentPreparedEvent) {
        this.onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent)event);
    } else if (event instanceof ApplicationPreparedEvent) {
        this.onApplicationPreparedEvent((ApplicationPreparedEvent)event);
    } else if (event instanceof ContextClosedEvent && ((ContextClosedEvent)event).getApplicationContext().getParent() == null) {
        this.onContextClosedEvent();
    } else if (event instanceof ApplicationFailedEvent) {
        this.onApplicationFailedEvent();
    }

}

private void onApplicationStartingEvent(ApplicationStartingEvent event) {
    this.loggingSystem = LoggingSystem.get(event.getSpringApplication().getClassLoader());
    this.loggingSystem.beforeInitialize();
}
public abstract void beforeInitialize();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
static {
    Map<String, String> systems = new LinkedHashMap();
    systems.put("ch.qos.logback.core.Appender", "org.springframework.boot.logging.logback.LogbackLoggingSystem");
    systems.put("org.apache.logging.log4j.core.impl.Log4jContextFactory", "org.springframework.boot.logging.log4j2.Log4J2LoggingSystem");
    systems.put("java.util.logging.LogManager", "org.springframework.boot.logging.java.JavaLoggingSystem");
    SYSTEMS = Collections.unmodifiableMap(systems);
}
public static LoggingSystem get(ClassLoader classLoader) {
    String loggingSystem = System.getProperty(SYSTEM_PROPERTY);
    if (StringUtils.hasLength(loggingSystem)) {
        return (LoggingSystem)("none".equals(loggingSystem) ? new LoggingSystem.NoOpLoggingSystem() : get(classLoader, loggingSystem));
    } else {
        Iterator var2 = SYSTEMS.entrySet().iterator();

        Entry entry;
        do {
            if (!var2.hasNext()) {
                throw new IllegalStateException("No suitable logging system located");
            }

            entry = (Entry)var2.next();
        } while(!ClassUtils.isPresent((String)entry.getKey(), classLoader));

        return get(classLoader, (String)entry.getValue());
    }
}

private static LoggingSystem get(ClassLoader classLoader, String loggingSystemClass) {
    try {
        Class<?> systemClass = ClassUtils.forName(loggingSystemClass, classLoader);
        return (LoggingSystem)systemClass.getConstructor(ClassLoader.class).newInstance(classLoader);
    } catch (Exception var3) {
        throw new IllegalStateException(var3);
    }
}

1
System.setProperty("path","....");

1
2
3
4
public abstract class BaseController  {
    protected final Logger logger = LoggerFactory.getLogger(BaseController.class);

}

1
2
3
4
5
6
7
8
9
10
11
12
13
@RestController
public class LoggerController extends BaseController{

    @GetMapping("/log")
    public void log(@RequestParam String message) {
        System.setProperty("path","....");

        if( logger instanceof ch.qos.logback.classic.Logger){
            ch.qos.logback.classic.Logger.class.cast(logger).setLevel(Level.DEBUG);
        }
        logger.debug(message);
    }
}

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        Map<Thread, StackTraceElement[]> threadMap = Thread.getAllStackTraces();
        StackTraceElement[] stackTraceElements = threadMap.get(thread);
        Stream.of(stackTraceElements).forEach( System.out::println);
    }
}

1
2
3
4
5
public void method(String s){
    log.info("messages");
    // 能否把 "s" 给打印出来 s = message
    // info -> appender
}