2.1 jdk-spi的实现原理

dubbo-spi是在jdk-spi的基础上进行重写优化，下面看一下jdk-spi。

一、作用

• 为接口自动寻找实现类。

二、实现方式

• 标准制定者制定接口
• 不同厂商编写针对于该接口的实现类，并在jar的“classpath:META-INF/services/全接口名称”文件中指定相应的实现类全类名
• 开发者直接引入相应的jar，就可以实现为接口自动寻找实现类的功能

三、使用方法

注意：示例以Log体系为例，但是实际中的Log体系并不是这样来实现的。

1、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hulk</groupId>
    <artifactId>java-spi</artifactId>
    <version>1.0-SNAPSHOT</version>
</project>

2、标准接口：com.hulk.javaspi.Log

package com.hulk.javaspi;

public interface Log {
    void execute();
}

3、具体实现1：com.hulk.javaspi.Log4j

package com.hulk.javaspi;

public class Log4j implements Log {
    @Override
    public void execute() {
        System.out.println("log4j ...");
    }
}

4、具体实现2：com.hulk.javaspi.Logback

package com.hulk.javaspi;

public class Logback implements Log {
    @Override
    public void execute() {
        System.out.println("logback ...");
    }
}

5、指定使用的实现文件：META-INF/services/com.hulk.javaspi.Log

1 com.hulk.javaspi.Logback

注意

• 这里指定了实现类Logback，那么加载的时候就会自动为Log接口指定实现类为Logback。
• 这里也可以指定两个实现类，那么在实际中使用哪一个实现类，就需要使用额外的手段来控制。

  1 com.hulk.javaspi.Logback
  2 com.hulk.javaspi.Log4j

6、加载实现主类：com.hulk.javaspi.Main

package com.hulk.javaspi;

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

public class Main {
    public static void main(String[] args) {
        ServiceLoader<Log> serviceLoader = ServiceLoader.load(Log.class);
        Iterator<Log> iterator = serviceLoader.iterator();
        while (iterator.hasNext()) {
            Log log = iterator.next();
            log.execute();
        }
    }
}

注意：

• ServiceLoader不是实例化以后，就去读取配置文件中的具体实现，并进行实例化。而是等到使用迭代器去遍历的时候，才会加载对应的配置文件去解析，调用hasNext方法的时候会去加载配置文件进行解析，调用next方法的时候进行实例化并缓存 - 具体见“源码分析”

现在来解析Main的源码。

四、源码解析

1、获取ServiceLoader

ServiceLoader<Log> serviceLoader = ServiceLoader.load(Log.class);

源码：

首先来看一下ServiceLoader的6个属性

     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 LazyIterator lookupIterator;//真正进行迭代的迭代器

其中LazyIterator是ServiceLoader的一个内部类，在迭代部分会说。

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

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

这样一个ServiceLoader实例就创建成功了。在创建的过程中，我们看到还实例化了一个LazyIterator，该类下边会说。

2、获取迭代器并迭代

         Iterator<Log> iterator = serviceLoader.iterator();
         while (iterator.hasNext()) {
             Log log = iterator.next();
             log.execute();
         }

外层迭代器：

    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()和迭代过程next()来看。

• hasNext()：先从provider（缓存）中查找，如果有，直接返回true；如果没有，通过LazyIterator来进行查找。
• next()：先从provider（缓存）中直接获取，如果有，直接返回实现类对象实例；如果没有，通过LazyIterator来进行获取。

下面来看一下，LazyIterator这个类。首先看一下他的属性：

        Class<S> service;//接口
        ClassLoader loader;//类加载器
        Enumeration<URL> configs = null;//存放配置文件
        Iterator<String> pending = null;//存放配置文件中的内容，并存储为ArrayList，即存储多个实现类名称
        String nextName = null;//当前处理的实现类名称

其中，service和loader在上述实例化ServiceLoader的时候就已经实例化好了。

下面看一下hasNext()：

        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() {
            if (nextName != null) {
                return true;
            }
            if (configs == null) {
                try {
                    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;
        }

hasNextService()中，核心实现如下：

• 首先使用loader加载配置文件，此时找到了META-INF/services/com.hulk.javaspi.Log文件；
• 然后解析这个配置文件，并将各个实现类名称存储在pending的ArrayList中; -->  此时[ com.hulk.javaspi.Logback ]
• 最后指定nextName; --> 此时nextName=com.hulk.javaspi.Logback

 下面看一下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();
            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 {
                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
        }

nextService()中，核心实现如下：

• 首先加载nextName代表的类Class，这里为com.hulk.javaspi.Logback；
• 之后创建该类的实例，并转型为所需的接口类型
• 最后存储在provider中，供后续查找，最后返回转型后的实现类实例。

再next()之后，拿到实现类实例后，就可以执行其具体的方法了。

五、缺点

• 查找一个具体的实现需要遍历查找，耗时；-->此时就体现出Collection相较于Map差的地方，map可以直接根据key来获取具体的实现 （dubbo-spi实现了根据key获取具体实现的方式）