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获取具体实现的方式）