【小家Spring】探讨注解驱动Spring应用的机制，详解ServiceLoader、SpringFactoriesLoader的使用（以JDBC、spring.factories为例介绍SPI）

/**
* 一个简单的服务提供商加载设施
* 服务 是一个熟知的接口和类（通常为抽象类）集合。服务提供者 是服务的特定实现
* 服务提供者可以以扩展的形式安装在 **Java 平台的实现中**.也就是将 jar 文件放入任意常用的扩展目录中
* 也可通过将提供者加入应用程序类路径，或者通过其他某些特定于平台的方式使其可用(所以并不限定你的方式，不在类路径也无所谓哟)
*/
// @since 1.6 Java6以后才有的工具类
public final class ServiceLoader<S> implements Iterable<S> {
	// 这个路径非常的重要，最终就是去此路径读取
    private static final String PREFIX = "META-INF/services/";
    // 指向对象类型的 Class<S> 对象  最后通过 Class<S> 对象来构造服务实现类 S 的实例 s 
    private final Class<S> service;
	
	//类加载器 ClassLoader
    private final ClassLoader loader;
    private final AccessControlContext acc;
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    private LazyIterator lookupIterator;
	
	...
｝

HelloService service = new HelloImpl();

// SPI服务接口
public interface IService {
    String sayHello();

    String getScheme();
}

// 主要为了测试，看看是子接口是否会被加载
public interface MyIService extends IService {

}

// 服务提供商的具体实现1：HDFS实现
public class HDFSService implements IService {

    @Override
    public String sayHello() {
        return "Hello HDFSService";
    }

    @Override
    public String getScheme() {
        return "hdfs";
    }
}
// 服务提供商的具体实现2：Local实现
public class LocalService implements IService {
    @Override
    public String sayHello() {
        return "Hello LocalService";
    }

    @Override
    public String getScheme() {
        return "local";
    }
}

com.fsx.serviceloader.MyIService // 注意这个是接口
com.fsx.serviceloader.HDFSService
com.fsx.serviceloader.LocalService

    public static void main(String[] args) {
        // 加载IService下所有的服务
        ServiceLoader<IService> serviceLoader = ServiceLoader.load(IService.class);

        for (IService service : serviceLoader) {
            System.out.println(service.getScheme() + "=" + service.sayHello());
        }
    }

java.util.ServiceConfigurationError: com.fsx.serviceloader.IService: Provider com.fsx.serviceloader.MyIService could not be instantiated

com.fsx.serviceloader.HDFSService
com.fsx.serviceloader.LocalService

hdfs=Hello HDFSService
local=Hello LocalService

private static void loadFileSystems() {  
  synchronized(FileSystem.class){  
    if(!FILE_SYSTEMS_LOADED) {  
			
	  // 此处通过ServiceLoader把FileSystem所有的服务提供者都拿出来并且缓存起来了
	  // 这个概念，特别特别像通过配置文件配置Bean一样，类比Spring吧  只是没那么强大而已
      ServiceLoader<FileSystem> serviceLoader = ServiceLoader.load(FileSystem.class); 
      for(FileSystem fs : serviceLoader) {  
        SERVICE_FILE_SYSTEMS.put(fs.getScheme(),fs.getClass());  
      } 
      FILE_SYSTEMS_LOADED= true; 
    } 
  } 
}

public class DriverManager {
	...
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }

    private static void loadInitialDrivers() {
    	,,,
    	ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
    	Iterator<Driver> driversIterator = loadedDrivers.iterator();
       try{
       	  // 只要导入了对应的Jar包，项目启动时候都会加载进来，用户其实并不需要再手动去加载了
           while(driversIterator.hasNext()) {
               driversIterator.next();
           }
       } catch(Throwable t) {
       // Do nothing
       }
    }
    ...
｝

// 全类名：javax.servlet.ServletContainerInitializer
// @since Servlet 3.0
public interface ServletContainerInitializer {
	...
}

package org.apache.catalina.startup

public class ContextConfig implements LifecycleListener {
	...
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
    	...
    	// 容器启动前，会执行configureStart配置工作
        if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
            configureStart();
        }
        ... 
    }

    protected synchronized void configureStart() {
    	...
        webConfig();
    }

    protected void webConfig() {
    	...
        // Step 3. Look for ServletContainerInitializer implementations
        if (ok) {
            processServletContainerInitializers();
        }
    }
	
	// 这一步就是Tomcat专门寻找，并且执行Servlet规范中的`ServletContainerInitializer`的所有的实现类的
    /**
     * Scan JARs for ServletContainerInitializer implementations.
     */
    protected void processServletContainerInitializers() {

        List<ServletContainerInitializer> detectedScis;
        try {
			
			// 此处使用的是Tomcat自己实现的 WebappServiceLoader，它使用方式完全同java.util.ServiceLoader,并且相关规范也一样的
			// 具体使用方式，请参见ServiceLoader的使用步骤
            WebappServiceLoader<ServletContainerInitializer> loader = new WebappServiceLoader<>(context);
			
			// 找到所有的SCI
            detectedScis = loader.load(ServletContainerInitializer.class);
        } catch (IOException e) {
            ok = false;
            return;
        }

		// 遍历，逐个处理@HandlesTypes注解~~~
        for (ServletContainerInitializer sci : detectedScis) {
            initializerClassMap.put(sci, new HashSet<Class<?>>());

            HandlesTypes ht;
            try {
            	// 拿到实现类上面标注的@HandlesTypes注解~~~
                ht = sci.getClass().getAnnotation(HandlesTypes.class);
            } catch (Exception e) {
                continue;
            }
			
			// 如过没有标注此注解，就继续处理下一个
            if (ht == null) {
                continue;
            }
			// 标注了注解，但是没有写value值，也继续处理下一个
            Class<?>[] types = ht.value();
            if (types == null) {
                continue;
            }
			
			// types：注解里面所关心的types，
            for (Class<?> type : types) {
                if (type.isAnnotation()) {
                    handlesTypesAnnotations = true;
                } else {
                    handlesTypesNonAnnotations = true;
                }

				// 以该type为key，对应上对应的SCI  最终onStartup()方法里会把对应Class类型放进去的
                Set<ServletContainerInitializer> scis = typeInitializerMap.get(type);
                if (scis == null) {
                    scis = new HashSet<>();
                    typeInitializerMap.put(type, scis);
                }
                scis.add(sci);
            }
        }
    }
}

    protected synchronized void configureStart() {
    	...
        webConfig();
        // 手动添加的
        context.addServletContainerInitializer(new JasperInitializer(), null);
 		...   	
    }

com.fsx.serviceloader.IService=com.fsx.serviceloader.HDFSService,com.fsx.serviceloader.LocalService

// 若有非常多个需要换行 可以这么写
// 前面是否顶头没关系（Spring在4.x版本修复了这个bug）
com.fsx.serviceloader.IService=\
    com.fsx.serviceloader.HDFSService,\
    com.fsx.serviceloader.LocalService

    public static void main(String[] args) throws IOException {
        List<IService> services = SpringFactoriesLoader.loadFactories(IService.class, Main.class.getClassLoader());
        List<String> list = SpringFactoriesLoader.loadFactoryNames(IService.class, Main.class.getClassLoader());
        System.out.println(list); //[com.fsx.serviceloader.HDFSService, com.fsx.serviceloader.LocalService]
        System.out.println(services); //[com.fsx.serviceloader.HDFSService@794cb805, com.fsx.serviceloader.LocalService@4b5a5ed1]
    }

// @since 3.2
public final class SpringFactoriesLoader {
	...
	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
	...
	// 核心方法如下：
	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			// 读取到资源文件，遍历
			Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();

			
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				// 此处使用的是URLResource把这个资源读进来~~~
				UrlResource resource = new UrlResource(url);
				
				// 可以看到，最终它使用的还是PropertiesLoaderUtils，只能使键值对的形式哦~~~ 当然xml也是被支持的
				
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
		
					// 使用逗号,分隔成数组，遍历   名称就出来了~~~
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		} catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}
}

	/** Stores the BeanInfoFactory instances. */
	private static List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
			BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());

// 配置文件内容为
org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory

// 也就是说`BeanInfoFactory`的实现类默认使用的`ExtendedBeanInfoFactory`