关于springboot:一java-Spi-与-SpringFactoriesLoader

spring 的 SpringFactoriesLoader 是 spring 框架外部工具类，在 Spring boot 利用启动的过程中，这个类的工作很重要，启动逻辑应用该类从 classpath 上所有 jar 包中找出各自的 META-INF/spring.factories 属性文件，并剖析出其中定义的工厂类。这些工厂类进而被启动逻辑应用，利用于进一步初始化工作。其应用的形式和 java 的 spi 根本相似，咱们能够先学习 java 的 spi 而且进一步学习 SpringFactoriesLoader。

SPI 全称 Service Provider Interface，是 Java 提供的一套用来被第三方实现或者扩大的接口，它能够用来启用框架扩大和替换组件。SPI 的作用就是为这些被扩大的 API 寻找服务实现。

SPI（Service Provider Interface）是 调用方 来制订接口标准，提供给内部来实现，调用方在调用时则 抉择本人须要的内部实现。从应用人员上来说，SPI 被框架扩大人员应用。

（1）、定义一个接口

public interface Upload {void upload();
}

（2）、接口实现类

package cn..antispam.soa.service;
public class BduUploadImpl implements Upload {
    @Override
 public void upload(){System.out.println("上传到百度云");
 }
}

public class AliUploadImpl implements Upload {
    @Override
 public void upload() {System.out.println("上传到阿里 oss");
 }
}

(3)、测试类

public class spidemo {public static void main(String[] args) {ServiceLoader<Upload> uploads = ServiceLoader.load(Upload.class);
for (Upload upload :uploads){upload.upload();
}
   }
}

(4)输入

上传到阿里 oss
上传到百度云

Process finished with exit code 0

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


    // 扫描目录前缀
    private static final String PREFIX = "META-INF/services/";

    // 被加载的类或接口
    private final Class<S> service;

    // 用于定位、加载和实例化实现方实现的类的类加载器
    private final ClassLoader loader;

    // 上下文对象
    private final AccessControlContext acc;

    // 依照实例化的程序缓存曾经实例化的类
    private LinkedHashMap<String, S> providers = new LinkedHashMap<>();

    // 懒加载迭代器
    private java.util.ServiceLoader.LazyIterator lookupIterator;

    // 公有外部类，提供对所有的 service 的类的加载与实例化
    private class LazyIterator implements Iterator<S> {
        Class<S> service;
        ClassLoader loader;
        Enumeration<URL> configs = null;
        String nextName = null;
        
   public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader){return new ServiceLoader<>(service, loader);
    }
   public static <S> ServiceLoader<S> load(Class<S> service) {ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }
      
    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        //....
        reload();}
   public void reload() {
       // 清空 providers
        providers.clear();
        lookupIterator = new LazyIterator(service, loader);
    }
      
   private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service;
            this.loader = loader;
   }
        //...
        private boolean hasNextService() {if (configs == null) {
                try {
                    // 获取目录下所有的类
                    //"META-INF/services/"+service 的全限定类名
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        // 加载 META-INF/services/"+service 里的所有全限定类名
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        configs = loader.getResources(fullName);
                } catch (IOException x) {//...}
                //....
            }
        }

        private S nextService() {
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
                // 反射加载类
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) { }
            try {
                // 实例化
                S p = service.cast(c.newInstance());
                // 放进缓存
                providers.put(cn, p);
                return p;
            } catch (Throwable x) {//..}
            //..
        }
    }
}

下面的代码只贴出了局部要害的实现，上面贴出比拟直观的 spi 加载的次要流程供参考：

关于springboot:一java-Spi-与-SpringFactoriesLoader

一、java spi

1、什么是 Spi

2、Spi 的利用场景

3、Spi 的简略 demo

4、Spi 源码剖析