java的SPI机制

SPI

全称为 Service Provider Interface，是一种服务发现机制。我们看看简单的一个例子。
定义一个接口HelloSpiService：

public interface HelloSpiService {  
    void sayHello();  
}

实现类HelloSpiServiceImpl

public class HelloSpiServiceImpl implements HelloSpiService {  
    @Override  
  public void sayHello() {  
        System.out.println("hello");  
    }  
}

在资源META-INF/services文件下创建一个文件com.learn.dubbo.spi.HelloSpiService，文件名同接口全路径，文件内容就是上面的实现类com.learn.dubbo.spi.impl.HelloSpiServiceImpl，也可以有多个。
测试代码：

public class Test {  
    public static void main(String[] args) {  
        ServiceLoader<HelloSpiService> load = ServiceLoader.load(HelloSpiService.class);  
        Iterator<HelloSpiService> iterator = load.iterator();  
        while (iterator.hasNext()) {  
            HelloSpiService helloSpiService = iterator.next();  
            helloSpiService.sayHello();  
        }  
    }  
}

运行结果如下：

Iterator就是文件的实现类内容。

源码分析

load

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)
{
    // 返回一个ServiceLoader
    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();
}

public void reload() {
    // 清空提供者
    providers.clear();
    // 初始化lookupIterator，Iterator遍历就是他做的
    lookupIterator = new LazyIterator(service, loader);
}

private LazyIterator(Class<S> service, ClassLoader loader) {  
    this.service = service;  
    this.loader = loader;  
}

iterator

返回一个迭代器，knownProviders是用来储存解析过的文件的值，也就是说，上面的load.iterator()再执行的时候，此时返回的是已解析过的值。如果没有解析过，那hasNext()和next()是由lookupIterator执行的。

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

    };
}

hasNext

第一次解析的时候，knownProviders还没有缓存值，所以包括下面的next，都是lookupIterator的方法。
lookupIterator有5个成员变量：

• service：接口，load的时候初始化
• loader：类加载器，load的时候初始化
• configs：接口文件信息
• pending：资源文件的内容
• nextName：下一个值

public boolean hasNext() {
    if (acc == null) {
        return hasNextService();
    } else {
        PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
            public Boolean run() { return hasNextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}

private boolean hasNextService() {
    // 下一个有值，直接返回true
    if (nextName != null) {
        return true;
    }
    // 配置文件没有值，就去读取
    if (configs == null) {
        try {
            // 这个PREFIX就是META-INF/services/，我们创建文件夹的路径
            // fullName接口全路径
            String fullName = PREFIX + service.getName();
            // 获取文件信息
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
    // 获取文件内容
    while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
            return false;
        }
        pending = parse(service, configs.nextElement());
    }
    // 获取下一个文件内容
    nextName = pending.next();
    return true;
}

主要是读取文件，把文件内容的实现类的路径读取出来。

next

public S next() {
    if (acc == null) {
        return nextService();
    } else {
        PrivilegedAction<S> action = new PrivilegedAction<S>() {
            public S run() { return nextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}

private S nextService() {
    // 是否有下一个节点
    if (!hasNextService())
        throw new NoSuchElementException();
    // 把下一个节点赋值给cn，然后再重置nextName
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    try {
        // 用同一个类加载器实例化
        c = Class.forName(cn, false, loader);
    } catch (ClassNotFoundException x) {
        fail(service,
             "Provider " + cn + " not found");
    }
    if (!service.isAssignableFrom(c)) {
        fail(service,
             "Provider " + cn  + " not a subtype");
    }
    try {
        // 判断实例对象，并把值存入providers，后面再load的时候，就是用providers生成的knownProviders
        S p = service.cast(c.newInstance());
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
             x);
    }
    throw new Error();          // This cannot happen
}

主要是获取实例化对象，并缓存起来。