SPI机制

目录

JDK SPI（ServiceLoader，META-INF/services/）

jdk spi demo

ServiceLoader

Spring SPI（SpringFactoriesLoader，META-INF/spring.factories）

spring spi demo

 SpringFactoriesLoader

Dubbo SPI（ExtensionLoader，META-INF/dubbo/（用户自定义）、META-INF/dubbo/internal/（Dubbo内部）、META-INF/services/（兼容JDK SPI））

dubbo spi demo

ExtensionLoader

---

JDK SPI（ServiceLoader，META-INF/services/）

jdk spi demo

//resources/META-INF/services 
//com.xxx.Log
com.xxx.impl.Log4j 
com.xxx.impl.Logback 

//
public class Main { 
    public static void main(String[] args) { 
        ServiceLoader<Log> serviceLoader = ServiceLoader.load(Log.class); 
        Iterator<Log> iterator = serviceLoader.iterator(); 
        while (iterator.hasNext()) { 
            Log log = iterator.next(); 
            log.log("JDK SPI");  
        } 
    } 
} 
// 输出如下: 
// Log4j:JDK SPI 
// Logback:JDK SPI 

ServiceLoader

public final class ServiceLoader<S>
    implements Iterable<S>
{

    private static final String PREFIX = "META-INF/services/";

    // The class or interface representing the service being loaded
    private final Class<S> service;

    // The class loader used to locate, load, and instantiate providers
    private final ClassLoader loader;

    // The access control context taken when the ServiceLoader is created
    private final AccessControlContext acc;


    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
    
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        reload();
    }

}

Spring SPI（SpringFactoriesLoader，META-INF/spring.factories）

spring spi demo

//spring.factories
org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory

//
List<BeanInfoFactory> list = SpringFactoriesLoader.loadFactories(BeanInfoFactory.class,Thread.currentThread().getContextClassLoader());
for(BeanInfoFactory factory:list){
    System.out.println(factory.getClass().getSimpleName());
}

 SpringFactoriesLoader

public final class SpringFactoriesLoader {

    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

    public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }
        List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
        List<T> result = new ArrayList<>(factoryNames.size());
        for (String factoryName : factoryNames) {
            result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
        }
        AnnotationAwareOrderComparator.sort(result);
        return result;
    }

    public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        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 resource = new UrlResource(url);
            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;
    }

    private static <T> T instantiateFactory(String instanceClassName, Class<T> factoryClass, ClassLoader classLoader) {
        Class<?> instanceClass = ClassUtils.forName(instanceClassName, classLoader);
        return (T) ReflectionUtils.accessibleConstructor(instanceClass).newInstance();
    }

}

Dubbo SPI（ExtensionLoader，META-INF/dubbo/（用户自定义）、META-INF/dubbo/internal/（Dubbo内部）、META-INF/services/（兼容JDK SPI））

dubbo spi demo

Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getExtension("dubbo");
System.out.println(protocol.getServers());

ExtensionLoader

public class ExtensionLoader<T> {

    //获取扩展实现类的类加载器
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        //从 EXTENSION_LOADERS 缓存中查找相应的 ExtensionLoader 实例
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        //若缓存中没有则手动获取
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }
    
    //获取扩展实现类
    public T getExtension(String name) {
        // getOrCreateHolder()方法中封装了查找cachedInstances缓存的逻辑 
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        // double-check防止并发问题 
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    // 根据扩展名从SPI配置文件中查找对应的扩展实现类 
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

}