import org.slf4j.LoggerFactory;

public class Logger {
    static final org.slf4j.Logger LOG = LoggerFactory.getLogger(Logger.class);//获取日志对象

    public static void main(String[] args) {
        LOG.info("Hello JCL");//打印普通日志
        LOG.info("{}",LOG.getClass());//打印日志对象类路径
    }
}

LoggerFactory.getLogger(Logger.class);//获取日志对象⬅️

//获取日志实例
public static Logger getLogger(Class<?> clazz) {
  	Logger logger = getLogger(clazz.getName());
  	return logger;
}

public static Logger getLogger(String name) {
  	//获取日志工厂
  	ILoggerFactory iLoggerFactory = getILoggerFactory();⬅️
  	//获取日志实例
  	return iLoggerFactory.getLogger(name);⬅️
}

//获取日志工厂
public static ILoggerFactory getILoggerFactory() {
  	return getProvider().getLoggerFactory();⬅️
}

//获取提供者
static SLF4JServiceProvider getProvider() {
  //一开始未初始化
  if (INITIALIZATION_STATE == UNINITIALIZED) {
    synchronized (LoggerFactory.class) {
      if (INITIALIZATION_STATE == UNINITIALIZED) {//DCL（Double Check Lock）
        INITIALIZATION_STATE = ONGOING_INITIALIZATION;//正在进行初始化
       	performInitialization();//执行初始化 -> SPI查找服务提供者1⃣️
      }
    }
  }
  switch (INITIALIZATION_STATE) {
    case SUCCESSFUL_INITIALIZATION://成功初始化
      return PROVIDER;//提供者
    case NOP_FALLBACK_INITIALIZATION://NOP回退初始化
      return NOP_FALLBACK_FACTORY;//NOP回退工厂
    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_PROVIDER;//SUBST提供者
  }
  throw new IllegalStateException("Unreachable code");//提供者获取异常
}

//获取日志工厂
public ILoggerFactory getLoggerFactory();⬅️

//简单服务提供者
public class SimpleServiceProvider implements SLF4JServiceProvider {
  	private ILoggerFactory loggerFactory;
  	public ILoggerFactory getLoggerFactory() {
        return loggerFactory;⬅️
    }
  	@Override
    public void initialize() {
      	//初始化简单日志工厂
        loggerFactory = new SimpleLoggerFactory();
    }
}

//执行初始化
private final static void performInitialization() {
  	//查找并绑定
  	bind();⬅️
  	if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
		//验证是否为支持版本
		versionSanityCheck();
  	}
}

//服务提供者查找并绑定
private final static void bind() {
    try {
      	//查找所有服务提供者
      	List<SLF4JServiceProvider> providersList = findServiceProviders();⬅️
      	//验证服务提供者的唯一性
      	reportMultipleBindingAmbiguity(providersList);
      	//验证日志服务提供者是否存在
      	if (providersList != null && !providersList.isEmpty()) {
			PROVIDER = providersList.get(0);//获取第一个服务提供者
			PROVIDER.initialize();//调用服务提供者初始化流程
			INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;//设置成功标识
			reportActualBinding(providersList);
      	} else {
			//没有找到服务提供者，设置回退初始化标识、打印错误日志
			INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
			Util.report("No SLF4J providers were found.");
			Util.report("Defaulting to no-operation (NOP) logger implementation");
			Util.report("See " + NO_PROVIDERS_URL + " for further details.");

			//输出到可能存在的日志绑定
			Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
			reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
      	}
		//提交绑定清理
		postBindCleanUp();
	} catch (Exception e) {
		failedBinding(e);//异常绑定
		throw new IllegalStateException("Unexpected initialization failure", e);
	}
}

//查找所有的服务提供者
private static List<SLF4JServiceProvider> findServiceProviders() {
	//SPI加载机制
	ServiceLoader<SLF4JServiceProvider> serviceLoader = ServiceLoader.load(SLF4JServiceProvider.class);
	List<SLF4JServiceProvider> providerList = new ArrayList<SLF4JServiceProvider>();
	for (SLF4JServiceProvider provider : serviceLoader) {
		providerList.add(provider);
	}
	return providerList;
}

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Logger {
    static final Log LOG = LogFactory.getLog(Logger.class);//获取日志对象

    public static void main(String[] args) {
        LOG.info("Hello JCL");//打印普通日志
        LOG.info(LOG.getClass());//打印日志对象类路径
    }
}

LogFactory.getLog(Logger.class);⬅️

//获取日志对象
public static Log getLog(final Class clazz) throws LogConfigurationException {
    return getFactory().getInstance(clazz);⬅️
}

//获取日志工厂对象（ps：只要没有额外配置都是 " LogFactoryImpl " 对象）
public static LogFactory getFactory() throws LogConfigurationException {
		//上下文类加载器
 	 final ClassLoader contextClassLoader = getContextClassLoaderInternal();
 	 //从缓存工厂获取日志工厂对象
   LogFactory factory = getCachedFactory(contextClassLoader);
   //缓存工厂有直接返回
   if (factory != null) {
   		return factory;
   }
   // ...
   if (factory == null) {
   		//构建 " LogFactoryImpl " 工厂实现
   		factory = newFactory(FACTORY_DEFAULT, thisClassLoader, contextClassLoader);⬅️
   	}
   	if (factory != null) {
   		//存入缓存工厂供下一次快速获取
   		cacheFactory(contextClassLoader, factory);
   	}
   	return factory;
}

// 子类实现
public abstract Log getInstance(String name) throws LogConfigurationException;⬅️

//获取日志实例
@Override
public Log getInstance(final Class clazz) throws LogConfigurationException {
    return getInstance(clazz.getName());⬅️
}

@Override
public Log getInstance(final String name) throws LogConfigurationException {
  	//实例表获取缓存日志实例
 		Log instance = (Log) instances.get(name);
  	if (instance == null) {
    	//构建日志实例
    	instance = newInstance(name);⬅️
    	//缓存到实例表
   		instances.put(name, instance);
  	}
  	return instance;
}

//构建日志实例
protected Log newInstance(final String name) throws LogConfigurationException {
  	Log instance;
  	//没有日志构造进入，有日志构造直接创建
  	if (logConstructor == null) {
    		//发现日志实现
    		instance = discoverLogImplementation(name);⬅️
  	}
  	else {
    		final Object params[] = { name };
    		instance = (Log) logConstructor.newInstance(params);
  	}
  
  	if (logMethod != null) {
      	final Object params[] = { this };
      	logMethod.invoke(instance, params);
    }
 		return instance;
}

//实现类集
private static final String[] classesToDiscover = {
            "org.apache.commons.logging.impl.Log4JLogger",
            "org.apache.commons.logging.impl.Jdk14Logger",
            "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
            "org.apache.commons.logging.impl.SimpleLog"
};

//发现日志实现
private Log discoverLogImplementation(final String logCategory) throws LogConfigurationException {
  Log result = null;
  // ...
  for(int i=0; i<classesToDiscover.length && result == null; ++i) {
    	//从具体日志类中创建日志实例
    	result = createLogFromClass(classesToDiscover[i], logCategory, true);⬅️
  }
  //...
  return result;
}

//创建日志实例
private Log createLogFromClass(final String logAdapterClassName,
                                final String logCategory,
                                final boolean affectState)
  	throws LogConfigurationException {
  		Log logAdapter = null;
      Constructor constructor = null;
			Class logAdapterClass = null;
  		//获取应用类加载
      ClassLoader currentCL = getBaseClassLoader();
  
  		for(;;) {
  				Class c;
        	try {
            //加载实现类
            c = Class.forName(logAdapterClassName, true, currentCL);
          } catch (final ClassNotFoundException originalClassNotFoundException) {
            // ...
          }

          //获取类构造
          constructor = c.getConstructor(logConstructorSignature);
          //构建实例
          final Object o = constructor.newInstance(params);⬅️
        
          //日志对象验证
          if (o instanceof Log) {
            logAdapterClass = c;
            logAdapter = (Log) o;
            break;
          }
      }
 			if (logAdapterClass != null && affectState) {
          this.logClassName   = logAdapterClassName;//日志适配器类名
          this.logConstructor = constructor;//日志构造器
          try {
              this.logMethod = logAdapterClass.getMethod("setLogFactory", logMethodSignature);
          } catch (final Throwable t) {
              // ...
          }
      }
 			return logAdapter;
}