Java加餐篇之Java-SPI机制

最近在准备学习Spring源码，这是一个浩大的工程，所以要考一些知识点，圈起来考的。

SPI是什么

  • SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。具体机制如下图所示

1.webp

  • Java SPI 实际上是“基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制。
  • 系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制。
    Java SPI就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。所以SPI的核心思想就是解耦。

使用场景

  • 调用者根据实际使用需要，启用、扩展、或者替换框架的实现策略
  • 比较常见的例子：
    • 数据库驱动加载接口实现类的加载。JDBC加载不同类型数据库的驱动。
    • 日志门面接口实现类加载。SLF4J加载不同提供商的日志实现类。
    • Spring。Spring中大量使用了SPI，比如：对servlet3.0规范对ServletContainerInitializer的实现、自动类型转换Type Conversion SPI(Converter SPI、Formatter SPI)等
    • Dubbo。Dubbo中也大量使用SPI的方式实现框架的扩展, 不过它对Java提供的原生SPI做了封装，允许用户扩展实现Filter接口。

使用介绍

  • 要使用SPI，必须遵守以下约定
    • 当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名
    • 接口实现类所在的jar包放在主程序的classpath中
    • 主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM
    • SPI的实现类必须携带一个不带参数的构造方法

代码示例

  • 步骤1：定义一个接口、并且编写其实现。
  1. public interface IShout {
  2.     /**
  3.      * say hello
  4.      */
  5.     void sayHello();
  6. }
  8. public class ShoutOne implements IShout {
  9.     /**
  10.      * say hello
  11.      */
  12.     @Override
  13.     public void sayHello() {
  14.         System.out.println("ShoutOne.sayHello");
  15.     }
  16. }
  18. public class ShoutTwo implements IShout {
  19.     /**
  20.      * say hello
  21.      */
  22.     @Override
  23.     public void sayHello() {
  24.         System.out.println("ShoutTwo.sayHello");
  25.     }
  26. }
  • 步骤2：在src/main/resources/ 下建立 /META-INF/services 目录， 新增一个以接口全限定类名命名的文件，目录层级如下所示
  1. - src
  2.     -main
  3.         -resources
  4.             - META-INF
  5.                 - services
  6.                     - cn.icanci.demo.IShout
  • 文件内容如下
  1. cn.icanci.demo.ShoutOne
  2. cn.icanci.demo.ShoutTwo
  • 步骤3：编写测试main函数进行测试
  1. public class Main {
  2.     public static void main(String[] args) {
  3.         ServiceLoader<IShout> load = ServiceLoader.load(IShout.class);
  4.         Iterator<IShout> iterator = load.iterator();
  5.         while (iterator.hasNext()) {
  6.             IShout next = iterator.next();
  7.             next.sayHello();
  8.         }
  9.     }
  10. }
  11. // 输出结果如下：
  12. // ShoutOne.sayHello
  13. // ShoutTwo.sayHello

源码解析

  • 其源代码如下所示
  2. package java.util;
  4. import java.io.BufferedReader;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.net.URL;
  9. import java.security.AccessController;
  10. import java.security.AccessControlContext;
  11. import java.security.PrivilegedAction;
  12. import java.util.ArrayList;
  13. import java.util.Enumeration;
  14. import java.util.Iterator;
  15. import java.util.List;
  16. import java.util.NoSuchElementException;
  18. public final class ServiceLoader<S>
  19.   implements Iterable<S>
  20. {
  22.   // 需要加载的文件的路径地址
  23.   private static final String PREFIX = "META-INF/services/";
  25.   // 需要被加载的服务或者类(可以是接口、抽象类、普通类)
  26.   private final Class<S> service;
  28.   // 类加载器
  29.   private final ClassLoader loader;
  31.   // 创建ServiceLoader时采用的访问控制上下文
  32.   private final AccessControlContext acc;
  34.   // 缓存providers，按实例化的顺序排列，也就是被创建的目标实例对象
  35.   private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
  37.   // 懒查找迭代器
  38.   private LazyIterator lookupIterator;
  40.   // 重新加载，先清空，再加载
  41.   public void reload() {
  42.     providers.clear();
  43.     lookupIterator = new LazyIterator(service, loader);
  44.   }
  46.   // 服务加载
  47.   private ServiceLoader(Class<S> svc, ClassLoader cl) {
  48.     service = Objects.requireNonNull(svc, "Service interface cannot be null");
  49.     loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
  50.     acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
  51.     reload();
  52.   }
  54.   // 加载失败
  55.   private static void fail(Class<?> service, String msg, Throwable cause)
  56.     throws ServiceConfigurationError
  57.   {
  58.     throw new ServiceConfigurationError(service.getName() + ": " + msg,
  59.                                         cause);
  60.   }
  62.   // 加载失败
  63.   private static void fail(Class<?> service, String msg)
  64.     throws ServiceConfigurationError
  65.   {
  66.     throw new ServiceConfigurationError(service.getName() + ": " + msg);
  67.   }
  69.   // 加载失败
  70.   private static void fail(Class<?> service, URL u, int line, String msg)
  71.     throws ServiceConfigurationError
  72.   {
  73.     fail(service, u + ":" + line + ": " + msg);
  74.   }
  76.   // 从配置文件中解析一行，并且将改行的名称加载在列表中
  77.   private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
  78.                         List<String> names)
  79.     throws IOException, ServiceConfigurationError
  80.   {
  81.     String ln = r.readLine();
  82.     if (ln == null) {
  83.       return -1;
  84.     }
  85.     int ci = ln.indexOf('#');
  86.     if (ci >= 0) ln = ln.substring(0, ci);
  87.     ln = ln.trim();
  88.     int n = ln.length();
  89.     if (n != 0) {
  90.       if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
  91.         fail(service, u, lc, "Illegal configuration-file syntax");
  92.       int cp = ln.codePointAt(0);
  93.       if (!Character.isJavaIdentifierStart(cp))
  94.         fail(service, u, lc, "Illegal provider-class name: " + ln);
  95.       for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
  96.         cp = ln.codePointAt(i);
  97.         if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
  98.           fail(service, u, lc, "Illegal provider-class name: " + ln);
  99.       }
  100.       if (!providers.containsKey(ln) && !names.contains(ln))
  101.         names.add(ln);
  102.     }
  103.     return lc + 1;
  104.   }
  106.   // 通过 URL 加载
  107.   private Iterator<String> parse(Class<?> service, URL u)
  108.     throws ServiceConfigurationError
  109.   {
  110.     InputStream in = null;
  111.     BufferedReader r = null;
  112.     ArrayList<String> names = new ArrayList<>();
  113.     try {
  114.       in = u.openStream();
  115.       r = new BufferedReader(new InputStreamReader(in, "utf-8"));
  116.       int lc = 1;
  117.       while ((lc = parseLine(service, u, r, lc, names)) >= 0);
  118.     } catch (IOException x) {
  119.       fail(service, "Error reading configuration file", x);
  120.     } finally {
  121.       try {
  122.         if (r != null) r.close();
  123.         if (in != null) in.close();
  124.       } catch (IOException y) {
  125.         fail(service, "Error closing configuration file", y);
  126.       }
  127.     }
  128.     return names.iterator();
  129.   }
  131.   // 懒加载迭代器
  132.   private class LazyIterator
  133.     implements Iterator<S>
  134.   {
  136.     Class<S> service;
  137.     ClassLoader loader;
  138.     Enumeration<URL> configs = null;
  139.     Iterator<String> pending = null;
  140.     String nextName = null;
  142.     private LazyIterator(Class<S> service, ClassLoader loader) {
  143.       this.service = service;
  144.       this.loader = loader;
  145.     }
  147.     private boolean hasNextService() {
  148.       if (nextName != null) {
  149.         return true;
  150.       }
  151.       if (configs == null) {
  152.         try {
  153.           String fullName = PREFIX + service.getName();
  154.           if (loader == null)
  155.             configs = ClassLoader.getSystemResources(fullName);
  156.           else
  157.             configs = loader.getResources(fullName);
  158.         } catch (IOException x) {
  159.           fail(service, "Error locating configuration files", x);
  160.         }
  161.       }
  162.       while ((pending == null) || !pending.hasNext()) {
  163.         if (!configs.hasMoreElements()) {
  164.           return false;
  165.         }
  166.         pending = parse(service, configs.nextElement());
  167.       }
  168.       nextName = pending.next();
  169.       return true;
  170.     }
  172.     private S nextService() {
  173.       if (!hasNextService())
  174.         throw new NoSuchElementException();
  175.       String cn = nextName;
  176.       nextName = null;
  177.       Class<?> c = null;
  178.       try {
  179.         c = Class.forName(cn, false, loader);
  180.       } catch (ClassNotFoundException x) {
  181.         fail(service,
  182.              "Provider " + cn + " not found");
  183.       }
  184.       if (!service.isAssignableFrom(c)) {
  185.         fail(service,
  186.              "Provider " + cn  + " not a subtype");
  187.       }
  188.       try {
  189.         S p = service.cast(c.newInstance());
  190.         providers.put(cn, p);
  191.         return p;
  192.       } catch (Throwable x) {
  193.         fail(service,
  194.              "Provider " + cn + " could not be instantiated",
  195.              x);
  196.       }
  197.       throw new Error();          // This cannot happen
  198.     }
  200.     public boolean hasNext() {
  201.       if (acc == null) {
  202.         return hasNextService();
  203.       } else {
  204.         PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
  205.           public Boolean run() { return hasNextService(); }
  206.         };
  207.         return AccessController.doPrivileged(action, acc);
  208.       }
  209.     }
  211.     public S next() {
  212.       if (acc == null) {
  213.         return nextService();
  214.       } else {
  215.         PrivilegedAction<S> action = new PrivilegedAction<S>() {
  216.           public S run() { return nextService(); }
  217.         };
  218.         return AccessController.doPrivileged(action, acc);
  219.       }
  220.     }
  222.     public void remove() {
  223.       throw new UnsupportedOperationException();
  224.     }
  226.   }
  228.   // 迭代器
  229.   public Iterator<S> iterator() {
  230.     return new Iterator<S>() {
  232.       Iterator<Map.Entry<String,S>> knownProviders
  233.         = providers.entrySet().iterator();
  235.       public boolean hasNext() {
  236.         if (knownProviders.hasNext())
  237.           return true;
  238.         return lookupIterator.hasNext();
  239.       }
  241.       public S next() {
  242.         if (knownProviders.hasNext())
  243.           return knownProviders.next().getValue();
  244.         return lookupIterator.next();
  245.       }
  247.       public void remove() {
  248.         throw new UnsupportedOperationException();
  249.       }
  251.     };
  252.   }
  254.   // 加载
  255.   public static <S> ServiceLoader<S> load(Class<S> service,
  256.                                           ClassLoader loader)
  257.   {
  258.     return new ServiceLoader<>(service, loader);
  259.   }
  261.   // 加载
  262.   public static <S> ServiceLoader<S> load(Class<S> service) {
  263.     ClassLoader cl = Thread.currentThread().getContextClassLoader();
  264.     return ServiceLoader.load(service, cl);
  265.   }
  267.   // 使用扩展类加载器为给定的服务类型创建一个新的服务加载器
  268.   public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
  269.     ClassLoader cl = ClassLoader.getSystemClassLoader();
  270.     ClassLoader prev = null;
  271.     while (cl != null) {
  272.       prev = cl;
  273.       cl = cl.getParent();
  274.     }
  275.     return ServiceLoader.load(service, prev);
  276.   }
  279.   public String toString() {
  280.     return "java.util.ServiceLoader[" + service.getName() + "]";
  281.   }
  282. }

实现流程

  • 应用程序调用ServiceLoader.load方法
  • 然后获取类加载器和类，创建ServiceLoader对象
  • 实例化其中的对象，如下
    • loader(ClassLoader类型，类加载器)
    • acc(AccessControlContext类型，访问控制器)
    • providers(LinkedHashMap类型，用于缓存加载成功的类)
    • lookupIterator(实现迭代器功能)

  • 应用程序通过迭代器接口获取对象实例

    • ServiceLoader先判断成员变量providers对象中(LinkedHashMap类型)是否有缓存实例对象，如果有缓存，直接返回。
    • 如果没有缓存，执行类的装载，实现如下

    • 读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称，值得注意的是，ServiceLoader可以跨越jar包获取META-INF下的配置文件，具体加载配置的实现代码如下：

      1. private boolean hasNextService() {
      2. if (nextName != null) {
      3. return true;
      4. }
      5. if (configs == null) {
      6. try {
      7.  String fullName = PREFIX + service.getName();
      8.  if (loader == null)
      9.    configs = ClassLoader.getSystemResources(fullName);
      10.  else
      11.    configs = loader.getResources(fullName);
      12. } catch (IOException x) {
      13.  fail(service, "Error locating configuration files", x);
      14. }
      15. }
      16. while ((pending == null) || !pending.hasNext()) {
      17. if (!configs.hasMoreElements()) {
      18.  return false;
      19. }
      20. pending = parse(service, configs.nextElement());
      21. }
      22. nextName = pending.next();
      23. return true;
      24. }

    • 通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化。

    • 把实例化后的类缓存到providers对象中，(LinkedHashMap类型）然后返回实例对象。

总结

优点
  • 使用Java SPI机制的优势是实现解耦，使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离，而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。
  • 相比使用提供接口jar包，供第三方服务模块实现接口的方式，SPI的方式使得源框架，不必关心接口的实现类的路径，可以不用通过下面的方式获取接口实现类：
    • 代码硬编码import 导入实现类
    • 指定类全路径反射获取：例如在JDBC4.0之前，JDBC中获取数据库驱动类需要通过Class.forName(“com.mysql.jdbc.Driver”)，类似语句先动态加载数据库相关的驱动，然后再进行获取连接等的操作
    • 第三方服务模块把接口实现类实例注册到指定地方，源框架从该处访问实例
  • 通过SPI的方式，第三方服务模块实现接口后，在第三方的项目代码的META-INF/services目录下的配置文件指定实现类的全路径名，源码框架即可找到实现类

缺点
  • 虽然ServiceLoader也算是使用的延迟加载，但是基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类，它也被加载并实例化了，这就造成了浪费。获取某个实现类的方式不够灵活，只能通过Iterator形式获取，不能根据某个参数来获取对应的实现类。
  • 多个并发多线程使用ServiceLoader类的实例是不安全的。