Spring5 之前是 JCL（外部jar包）
Spring5(包含) 之后是 Spring-JCL（内部module，基于jcl修改）
因为之前源码下载是 5.2.19，所以主要看下 Spring-JCL。

源码

首先看下log对象

  1.     /** Logger used by this class. Available to subclasses. */
  2.     protected final Log logger = LogFactory.getLog(getClass());
  1.     /**
  2.      * Convenience method to return a named logger.
  3.      * @param name logical name of the <code>Log</code> instance to be returned
  4.      */
  5.     public static Log getLog(String name) {
  6.         // 创建具体的log对象
  7.         return LogAdapter.createLog(name);
  8.     }

看到这边主要是LogAdapter类去创建对象，那我们详细看下这个类。

  1. final class LogAdapter {
  3.     // log4j2 jar包中的一个类
  4.     private static final String LOG4J_SPI = "org.apache.logging.log4j.spi.ExtendedLogger";
  6.     private static final String LOG4J_SLF4J_PROVIDER = "org.apache.logging.slf4j.SLF4JProvider";
  8.     private static final String SLF4J_SPI = "org.slf4j.spi.LocationAwareLogger";
  10.     private static final String SLF4J_API = "org.slf4j.Logger";
  13.     private static final LogApi logApi;
  15.     static {
  16.         if (isPresent(LOG4J_SPI)) {
  17.             if (isPresent(LOG4J_SLF4J_PROVIDER) && isPresent(SLF4J_SPI)) {
  18.                 // log4j-to-slf4j bridge -> we'll rather go with the SLF4J SPI;
  19.                 // however, we still prefer Log4j over the plain SLF4J API since
  20.                 // the latter does not have location awareness support.
  21.                 /*
  22.                  * spring团队其实更倾向使用 log4j2，但如果你非要用slf4j，那就必须满足两个条件
  23.                  * 1. 必须要有 log4j2 - slf4j 的桥接器
  24.                  * 2. slf4j 的依赖
  25.                  */
  26.                 logApi = LogApi.SLF4J_LAL;
  27.             }
  28.             else {
  29.                 // Use Log4j 2.x directly, including location awareness support
  30.                 logApi = LogApi.LOG4J;
  31.             }
  32.         }
  33.         else if (isPresent(SLF4J_SPI)) {
  34.             // Full SLF4J SPI including location awareness support
  35.             logApi = LogApi.SLF4J_LAL;
  36.         }
  37.         else if (isPresent(SLF4J_API)) {
  38.             // Minimal SLF4J API without location awareness support
  39.             logApi = LogApi.SLF4J;
  40.         }
  41.         else {
  42.             // java.util.logging as default
  43.             logApi = LogApi.JUL;
  44.         }
  45.     }
  48.     private LogAdapter() {
  49.     }
  52.     /**
  53.      * Create an actual {@link Log} instance for the selected API.
  54.      * @param name the logger name
  55.      */
  56.     public static Log createLog(String name) {
  57.         switch (logApi) {
  58.             // log4j2
  59.             case LOG4J:
  60.                 return Log4jAdapter.createLog(name);
  61.             // slf4j_full
  62.             case SLF4J_LAL:
  63.                 return Slf4jAdapter.createLocationAwareLog(name);
  64.             // slf4j
  65.             case SLF4J:
  66.                 return Slf4jAdapter.createLog(name);
  67.             default:
  68.                 // Defensively use lazy-initializing adapter class here as well since the
  69.                 // java.logging module is not present by default on JDK 9. We are requiring
  70.                 // its presence if neither Log4j nor SLF4J is available; however, in the
  71.                 // case of Log4j or SLF4J, we are trying to prevent early initialization
  72.                 // of the JavaUtilLog adapter - e.g. by a JVM in debug mode - when eagerly
  73.                 // trying to parse the bytecode for all the cases of this switch clause.
  74.                 return JavaUtilAdapter.createLog(name);
  75.         }
  76.     }
  78.     private static boolean isPresent(String className) {
  79.         try {
  80.             Class.forName(className, false, LogAdapter.class.getClassLoader());
  81.             return true;
  82.         }
  83.         catch (ClassNotFoundException ex) {
  84.             return false;
  85.         }
  86.     }
  89.     private enum LogApi {LOG4J, SLF4J_LAL, SLF4J, JUL}
  92.     private static class Log4jAdapter {
  94.         public static Log createLog(String name) {
  95.             return new Log4jLog(name);
  96.         }
  97.     }
  100.     private static class Slf4jAdapter {
  102.         public static Log createLocationAwareLog(String name) {
  103.             Logger logger = LoggerFactory.getLogger(name);
  104.             return (logger instanceof LocationAwareLogger ?
  105.                     new Slf4jLocationAwareLog((LocationAwareLogger) logger) : new Slf4jLog<>(logger));
  106.         }
  108.         public static Log createLog(String name) {
  109.             return new Slf4jLog<>(LoggerFactory.getLogger(name));
  110.         }
  111.     }
  114.     private static class JavaUtilAdapter {
  116.         public static Log createLog(String name) {
  117.             return new JavaUtilLog(name);
  118.         }
  119.     }
  122.     @SuppressWarnings("serial")
  123.     private static class Log4jLog implements Log, Serializable {
  124.         // 先不关注
  125.         ...
  126.     }
  129.     @SuppressWarnings("serial")
  130.     private static class Slf4jLog<T extends Logger> implements Log, Serializable {
  131.         // 先不关注
  132.         ...
  133.     }
  136.     @SuppressWarnings("serial")
  137.     private static class Slf4jLocationAwareLog extends Slf4jLog<LocationAwareLogger> implements Serializable {
  138.         // 先不关注
  139.         ...
  140.     }
  143.     @SuppressWarnings("serial")
  144.     private static class JavaUtilLog implements Log, Serializable {
  145.         // 先不关注
  146.         ...
  147.     }
  150.     @SuppressWarnings("serial")
  151.     private static class LocationResolvingLogRecord extends LogRecord {
  152.         // 先不关注
  153.         ...
  154.     }
  156. }

去掉一些不是很重要的代码，先看下 createLog 方法。

  1.     public static Log createLog(String name) {
  2.         switch (logApi) {
  3.             // log4j2
  4.             case LOG4J:
  5.                 return Log4jAdapter.createLog(name);
  6.             // slf4j_full
  7.             case SLF4J_LAL:
  8.                 return Slf4jAdapter.createLocationAwareLog(name);
  9.             // slf4j
  10.             case SLF4J:
  11.                 return Slf4jAdapter.createLog(name);
  12.             default:
  13.                 // Defensively use lazy-initializing adapter class here as well since the
  14.                 // java.logging module is not present by default on JDK 9. We are requiring
  15.                 // its presence if neither Log4j nor SLF4J is available; however, in the
  16.                 // case of Log4j or SLF4J, we are trying to prevent early initialization
  17.                 // of the JavaUtilLog adapter - e.g. by a JVM in debug mode - when eagerly
  18.                 // trying to parse the bytecode for all the cases of this switch clause.
  19.                 return JavaUtilAdapter.createLog(name);
  20.         }
  21.     }

这里主要是根据 logApi 这个变量去判断的，那我们看下这个变量。
可以看到这个变量是在类初始化的时候去赋值的。

  1.     // log4j2 jar包中的一个类
  2.     private static final String LOG4J_SPI = "org.apache.logging.log4j.spi.ExtendedLogger";
  4.     private static final String LOG4J_SLF4J_PROVIDER = "org.apache.logging.slf4j.SLF4JProvider";
  6.     private static final String SLF4J_SPI = "org.slf4j.spi.LocationAwareLogger";
  8.     private static final String SLF4J_API = "org.slf4j.Logger";
  10.     private static final LogApi logApi;
  12.     static {
  13.         if (isPresent(LOG4J_SPI)) {
  14.             if (isPresent(LOG4J_SLF4J_PROVIDER) && isPresent(SLF4J_SPI)) {
  15.                 // log4j-to-slf4j bridge -> we'll rather go with the SLF4J SPI;
  16.                 // however, we still prefer Log4j over the plain SLF4J API since
  17.                 // the latter does not have location awareness support.
  18.                 /*
  19.                  * spring团队其实更倾向使用 log4j2，但如果你非要用slf4j，那就必须满足两个条件
  20.                  * 1. 必须要有 log4j2 - slf4j 的桥接器
  21.                  * 2. slf4j 的依赖
  22.                  */
  23.                 logApi = LogApi.SLF4J_LAL;
  24.             }
  25.             else {
  26.                 // Use Log4j 2.x directly, including location awareness support
  27.                 logApi = LogApi.LOG4J;
  28.             }
  29.         }
  30.         else if (isPresent(SLF4J_SPI)) {
  31.             // Full SLF4J SPI including location awareness support
  32.             logApi = LogApi.SLF4J_LAL;
  33.         }
  34.         else if (isPresent(SLF4J_API)) {
  35.             // Minimal SLF4J API without location awareness support
  36.             logApi = LogApi.SLF4J;
  37.         }
  38.         else {
  39.             // java.util.logging as default
  40.             logApi = LogApi.JUL;
  41.         }
  42.     }

可以看到主要是判断一些相关的类是否存在去实例化 logApi 对象。isPresent 方法就是通过 class.forName 去判断类是否存在。
流程图大概如下：
3. Spring 日志 - SpringJcl - 图1
可以看出 spring 的开发团队还是偏向 log4j2 的，原因他也在注释里写了

the latter does not have location awareness support. slf4j 没有位置感应支持。

位置感应支持这个暂时先不深究，因为偏向于 log4j2，所以只有当你项目只要存在log4j2的依赖，就会优先考虑log4j2，除非你的项目同时存在 slf4j 和 log4j-slf4j 桥接器的依赖后，这就表明你就是想用 slf4j，这时候才会使用 slf4j。或者我本身就没有 log4j2 的依赖，这种就是 slf4j 优先，没有的话使用 JUL。