Java SPI机制

什么是SPI

SPI全称：Service Provider Interface，字面意思就是服务提供者的接口。具体一点就是Java提供的一套用来被第三方实现或扩展的接口，实现了接口的动态扩展，让第三方的实现类能像插件一样嵌入到系统中。
SPI的核心思想就是解耦，通过约定配合动态加载的方式为接口寻找服务实现。

测试DEMO

1. 创建服务接口

public interface ISPIDemo {
    void process();
}

2. 创建服务实现类

这个实现类一般都是在其他模块或者二方库三方库中通过maven等工具引入过来的，本Demo就简单一点直接写在同一个模块了。

public class SPIDemoOne implements ISPIDemo {
    @Override
    public void process() {
        System.out.println("spi demo one");
    }
}

public class SPIDemoTwo implements ISPIDemo {
    @Override
    public void process() {
        System.out.println("spi demo two");
    }
}

3. 添加配置

在META-INF/services目录下创建com.zww.spi.ISPIDemo

com.zww.spi.SPIDemoOne
com.zww.spi.SPIDemoTwo

测试一下结果

public class SPIMain {
    public static void main(String[] args) {
        ServiceLoader<ISPIDemo> load = ServiceLoader.load(ISPIDemo.class);
        Iterator<ISPIDemo> spiIterator = load.iterator();
        while (spiIterator.hasNext()) {
            spiIterator.next().process();
        }
    }
}

返回结果如下

spi demo one
spi demo two

SPI源码解析

上面简单写了下使用方法，下面开始通过源码解析一下SPI的原理
SPI的使用第一步就是 ServiceLoader#load方法

public static <S> ServiceLoader<S> load(Class<S> service) {
    // 使用上下文加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    // 创建ServicecLoader对象
    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 = svc;
    loader = cl;
    reload();
}

public void reload() {
    // 清空缓存
    providers.clear();
    // 懒加载迭代器。也就是当前不去加载配置内容， 等使用的时候再进行加载
    lookupIterator = new LazyIterator(service, loader);
}

当迭代器器被遍历时，才会去读取配置文件。

public Iterator<S> iterator() {
    return new Iterator<S>() {
        // provides 本地缓存服务
        Iterator<Map.Entry<String,S>> knownProviders
            = providers.entrySet().iterator();

        public boolean hasNext() {
            if (knownProviders.hasNext())
                return true;
            // 缓存不存在，再调用LazyIterator
            return lookupIterator.hasNext();
        }

        public S next() {
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            // 缓存不存在，再调用LazyIterator
            return lookupIterator.next();
        }

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

    };
}

下面看LazyIterator

private class LazyIterator
        implements Iterator<S>
{

    Class<S> service;
    ClassLoader loader;
    Enumeration<URL> configs = null;
    Iterator<String> pending = null;
    String nextName = null;

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

    public boolean hasNext() {
        if (nextName != null) {
            return true;
        }
        if (configs == null) {
            try {
                // PREFIX = "META-INF/services/"
                // service.getName() = SPI接口的全路径名
                // 由此看出SPI配置方式是一个约定,需要按照这个约定的方式来配置
                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());
        }
        // SPI实现类全路径名
        nextName = pending.next();
        return true;
    }

    public S next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        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 {
            // 将实例转换成API接口类型
            S p = service.cast(c.newInstance());
            // 加入到providers缓存中
            providers.put(cn, p);
            return p;
        } catch (Throwable x) {
            fail(service,
                 "Provider " + cn + " could not be instantiated",
                 x);
        }
        throw new Error();          // This cannot happen
    }

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

}

总结

1. 约定。 配置路径为"META-INF/services/" + SPI接口的全路径名
2. 懒加载。SPI的加载方式是懒加载，只有迭代器真正进行遍历的时候才会去解析文件