Android组件化—Java SPI机制

一、SPI是什么

SPI（Service Provider Interface），是JDK提供的一套用来被第三方实现或者扩展的API，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用。SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是解耦。

SPI整体机制如下：

Java SPI 实际上是“基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制。

SPI与API区别：

• API是调用并用于实现目标的类、接口、方法等的描述；
• SPI是扩展和实现以实现目标的类、接口、方法等的描述；

换句话说，API 为操作提供特定的类、方法，SPI 通过操作来符合特定的类、方法。

 

二、使用规范

 

三、源码分析

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

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

    // 代表被加载的类或者接口
    private final Class<S> service;
    // 用于定位，加载和实例化providers的类加载器
    private final ClassLoader loader;
    // 缓存providers，按实例化的顺序排列
    private LinkedHashMap<String, S> providers = new LinkedHashMap<>();
    // 懒查找迭代器(内部类，真正加载服务类)
    private LazyIterator lookupIterator;

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

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

    private static void fail(Class<?> service, String msg, Throwable cause) throws ServiceConfigurationError {
        throw new ServiceConfigurationError(service.getName() + ": " + msg, cause);
    }

    private static void fail(Class<?> service, String msg) throws ServiceConfigurationError {
        throw new ServiceConfigurationError(service.getName() + ": " + msg);
    }

    private static void fail(Class<?> service, URL u, int line, String msg) throws ServiceConfigurationError {
        fail(service, u + ":" + line + ": " + msg);
    }

    private int parseLine(Class<?> service, URL u, BufferedReader r, int lc, List<String> names) throws IOException, ServiceConfigurationError {
        String ln = r.readLine();
        if (ln == null) {
            return -1;
        }
        int ci = ln.indexOf('#');
        if (ci >= 0) ln = ln.substring(0, ci);
        ln = ln.trim();
        int n = ln.length();
        if (n != 0) {
            if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
                fail(service, u, lc, "Illegal configuration-file syntax");
            int cp = ln.codePointAt(0);
            if (!Character.isJavaIdentifierStart(cp))
                fail(service, u, lc, "Illegal provider-class name: " + ln);
            for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
                cp = ln.codePointAt(i);
                if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                    fail(service, u, lc, "Illegal provider-class name: " + ln);
            }
            if (!providers.containsKey(ln) && !names.contains(ln))
                names.add(ln);
        }
        return lc + 1;
    }

    private Iterator<String> parse(Class<?> service, URL u) throws ServiceConfigurationError {
        InputStream in = null;
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try {
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            while ((lc = parseLine(service, u, r, lc, names)) >= 0) ;
        } catch (IOException x) {
            fail(service, "Error reading configuration file", x);
        } finally {
            try {
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) {
                fail(service, "Error closing configuration file", y);
            }
        }
        return names.iterator();
    }

    private class LazyIterator implements Iterator<S> {
        // 服务提供者接口
        Class<S> service;
        ClassLoader loader;
        // 保存实现类的url
        Enumeration<URL> configs = null;
        // 保存实现类的全名
        Iterator<String> pending = null;
        // 迭代器中下一个实现类的全名
        String nextName = null;

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

        private boolean hasNextService() {
            // 第二次调用的时候，已经解析完成了，直接返回
            if (nextName != null) {
                return true;
            }
            if (configs == null) {
                // 读取META-INF/services下的配置文件，获得所有能被实例化的类的名称
                try {
                    // META-INF/services/ + 接口的全限定类名，就是文件服务类的文件
                    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;
                }
                // 解析URL文件对象，读取内容，最后返回
                pending = parse(service, configs.nextElement());
            }
            // 拿到第一个实现类的类名
            nextName = pending.next();
            return true;
        }

        /**
         * 通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化
         * @return
         */
        private S nextService() {
            if (!hasNextService())
                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", x);
            }
            if (!service.isAssignableFrom(c)) {
                ClassCastException cce = new ClassCastException(service.getCanonicalName() + " is not assignable from " + c.getCanonicalName());
                fail(service, "Provider " + cn + " not a subtype", cce);
            }
            try {
                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();
        }

        public boolean hasNext() {
            return hasNextService();
        }

        public S next() {
            return nextService();
        }

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

    public Iterator<S> iterator() {
        // 先判断providers对象中是否有缓存实例对象，如果有缓存直接返回，如果没有缓存执行类的装载
        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();
            }
        };
    }

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

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

    public static <S> S loadFromSystemProperty(final Class<S> service) {
        try {
            final String className = System.getProperty(service.getName());
            if (className != null) {
                Class<?> c = ClassLoader.getSystemClassLoader().loadClass(className);
                return (S) c.newInstance();
            }
            return null;
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public String toString() {
        return "java.util.ServiceLoader[" + service.getName() + "]";
    }
}

 

四、应用场景

1. WEB中的应用

JDBC、Spring、Dubbo、Common-Logging、Hotspot

2. Android中的应用

在Android的组件化方案中，有一种便是通过AutoService + ServiceLoader的方式，自动生成META-INF/services/xxx配置文件，以实现业务Module之间的交互(跳转、传参...)。

• 开发阶段：对关联的类使用编译期注解。
• 编译阶段：通过注解处理器遍历查找被指定注解修饰的类的信息，收集写入到 META-INF/services 目录下的文件中。
• 运行阶段：通过 ServiceLoader 查找 META-INF/services 目录下指定的文件，解析文件的内容，获取要加载的子类信息。

作者参照Google开源的AutoService源码，同样基于：编译期注解、注解处理器，模拟实现了该框架的基本功能：QAutoService

 

参考：

Java SPI思想梳理

设计原则：小议 SPI 和 API

高级开发必须理解的Java中SPI机制

组件化之AutoService使用与源码解析