Java SPI 使用及原理分析

package com.dongzl.spi;

public interface IRegistry {

    void register(String url);
}

package com.dongzl.spi;

public class ZookeeperRegistry implements IRegistry {

    @Override
    public void register(String url) {
        System.out.println("Register " + url + " service to Zookeeper");
    }
}

package com.dongzl.spi;

public class EtcdRegistry implements IRegistry {

    @Override
    public void register(String url) {
        System.out.println("Register " + url + " service to Etcd");
    }
}

package com.dongzl.spi;

import java.util.Iterator;
import java.util.ServiceLoader;

public class Test {

    public static void main(String[] args) throws Exception {
        ServiceLoader<IRegistry> serviceLoader = ServiceLoader.load(IRegistry.class);
        Iterator<IRegistry> iterator = serviceLoader.iterator();
        while (iterator != null && iterator.hasNext()){
            IRegistry registry = iterator.next();
            System.out.println("class: " + registry.getClass().getName());
            registry.register("SPI");
        }
    }
}

class: com.dongzl.spi.ZookeeperRegistry
Register SPI service to Zookeeper
class: com.dongzl.spi.EtcdRegistry
Register SPI service to Etcd

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

// 表示正在加载的服务的类或接口
private final Class<S> service;

// 用于定位、加载和实例化提供程序的类加载器
private final ClassLoader loader;

// 创建 ServiceLoader 时采用的访问控制上下文
private final AccessControlContext acc;

// 缓存服务 providers, 按实例化顺序缓存
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

// 延迟查找迭代器
private LazyIterator lookupIterator;

/**
 * Creates a new service loader for the given service type, using the
 * current thread's {@linkplain java.lang.Thread#getContextClassLoader
 * context class loader}.
 *
 * <p> An invocation of this convenience method of the form
 *
 * <blockquote><pre>
 * ServiceLoader.load(<i>service</i>)</pre></blockquote>
 *
 * is equivalent to
 *
 * <blockquote><pre>
 * ServiceLoader.load(<i>service</i>,
 *                    Thread.currentThread().getContextClassLoader())</pre></blockquote>
 *
 * @param  <S> the class of the service type
 *
 * @param  service
 *         The interface or abstract class representing the service
 *
 * @return A new service loader
 */
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);
}

ServiceLoader.load(service);

ServiceLoader.load(service, Thread.currentThread().getContextClassLoader());

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();
}

public void reload() {
    providers.clear();
    lookupIterator = new LazyIterator(service, loader);
}

public Iterator<S> iterator() {
    return new Iterator<S>() {

        Iterator<Map.Entry<String,S>> knownProviders
            = providers.entrySet().iterator();

        public boolean hasNext() {
            if (knownProviders.hasNext())
                return true;
            return lookupIterator.hasNext();
        }

        public S next() {
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            return lookupIterator.next();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

// 获取完整路径名称（包名 + 接口名）
String fullName = PREFIX + service.getName();

// 加载配置，得到配置文件的URL集合（可能有多个配置文件）
configs = loader.getResources(fullName);

// 参数是接口的 Class 对象和配置文件的 URL 来解析配置文件
// 返回值是配置文件里面的内容，也就是实现类的全名（包名+类名）
pending = parse(service, configs.nextElement());

// 在 parse 方法中通过字符流的方式读取文件内容

// 通过 Class.forName java 反射机制加载类
c = Class.forName(cn, false, loader);

// 创建对象
S p = service.cast(c.newInstance());

// 缓存到全局的 LinkedHashMap
providers.put(cn, p);

/**
 * Creates a new service loader for the given service type, using the
 * extension class loader.
 *
 * <p> This convenience method simply locates the extension class loader,
 * call it <tt><i>extClassLoader</i></tt>, and then returns
 *
 * <blockquote><pre>
 * ServiceLoader.load(<i>service</i>, <i>extClassLoader</i>)</pre></blockquote>
 *
 * <p> If the extension class loader cannot be found then the system class
 * loader is used; if there is no system class loader then the bootstrap
 * class loader is used.
 *
 * <p> This method is intended for use when only installed providers are
 * desired.  The resulting service will only find and load providers that
 * have been installed into the current Java virtual machine; providers on
 * the application's class path will be ignored.
 *
 * @param  <S> the class of the service type
 *
 * @param  service
 *         The interface or abstract class representing the service
 *
 * @return A new service loader
 */
public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
    ClassLoader cl = ClassLoader.getSystemClassLoader();
    ClassLoader prev = null;
    while (cl != null) {
        prev = cl;
        cl = cl.getParent();
    }
    return ServiceLoader.load(service, prev);
}

ServiceLoader<IRegistry> serviceLoader = ServiceLoader.loadInstalled(IRegistry.class);