java实践SPI机制及浅析源码

小灰灰 2023-02-28 15:28 92阅读 0赞

1.概念

正式步入今天的核心内容之前，溪源先给大家介绍一下关于SPI机制的相关概念，最后会提供实践源代码。

SPI即Service Provider Interface，属于JDK内置的一种动态的服务提供发现机制，可以理解为运行时动态加载接口的实现类。更甚至，大家可以将SPI机制与设计模式中的策略模式建立联系。

  • SPI机制：
    在这里插入图片描述

从上图中理解SPI机制：标准化接口+策略模式+配置文件；

SPI机制核心思想：系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制

  • 使用场景：

    1. 数据库驱动加载：面对不同厂商的数据库，JDBC需要加载不同类型的数据库驱动；
    2. 日志接口实现：SLF4J加载不同日志实现类；
    3. 溪源在实际开发中也使用了SPI机制：面对不同仪器平台的结果文件上传需要解析具体的结果，文件不同，解析逻辑不同，因此采用SPI机制能够解耦和降低维护成本；

  • SPI机制使用约定：

    从上面的图中，我们可以清晰的知道SPI的三部分：接口+实现类+配置文件；因此，项目中若要利用SPI机制，则需要遵循以下约定：

    1. 当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名。
    2. 主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；

2.实践

整体包结构如图：
在这里插入图片描述

  • 新建标准化接口：

    public interface SayService { 

    1. void say(String word);

    }

  • 建立两个实现类

    @Service
    public class ASayServiceImpl implements SayService { 

    1. @Override
    2. public void say(String word) { 
    3.     System.out.println(word + " A say: I am a boy");
    4. }

    }

  1. @Service
  2. public class BSayServiceImpl implements SayService { 
  3.     @Override
  4.     public void say(String word) { 
  5.         System.out.println(word + " B say: I am a girl");
  6.     }
  7. }
  • 新建META-INF/services目录和配置文件（以接口全限定名）

配置文件内容为实现类全限定名

  1. com.qxy.spi.impl.ASayServiceImpl
  2. com.qxy.spi.impl.BSayServiceImpl

  • 单测

    @SpringBootTest
    @RunWith(SpringRunner.class)
    public class SpiTest { 

    1. static ServiceLoader<SayService> services = ServiceLoader.load(SayService.class);
    3. @Test
    4. public void test1() { 
    5.     for (SayService sayService : services) { 
    6.         sayService.say("Hello");
    7.     }
    8. }

    }

  • 结果

    Hello A say: I am a boy
    Hello B say: I am a girl

3.源码

源码主要加载流程如下：

  • 应用程序调用ServiceLoader.load方法 ServiceLoader.load方法内先创建一个新的ServiceLoader，并实例化该类中的成员变量；
  1. loader(ClassLoader类型，类加载器)
  2. acc(AccessControlContext类型，访问控制器)
  3. providers(LinkedHashMap类型，用于缓存加载成功的类)

  4. lookupIterator(实现迭代器功能)

    • 应用程序通过迭代器接口获取对象实例 ServiceLoader先判断成员变量providers对象中(LinkedHashMap类型)是否有缓存实例对象，如果有缓存，直接返回。如果没有缓存，执行类的装载。

  5. 读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称，值得注意的是，ServiceLoader可以跨越jar包获取META-INF下的配置文件；

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

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

    public final class ServiceLoader

    1. implements Iterable<S>

    { 

    1. // 加载具体实现类信息的前缀
    2. private static final String PREFIX = "META-INF/services/";
    4. // 需要加载的接口
    5. // The class or interface representing the service being loaded
    6. private final Class<S> service;
    8. // 用于加载的类加载器
    9. // The class loader used to locate, load, and instantiate providers
    10. private final ClassLoader loader;
    12. // 创建ServiceLoader时采用的访问控制上下文
    13. // The access control context taken when the ServiceLoader is created
    14. private final AccessControlContext acc;
    16. // 用于缓存已经加载的接口实现类，其中key为实现类的完整类名
    17. // Cached providers, in instantiation order
    18. private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    20. // 用于延迟加载接口的实现类
    21. // The current lazy-lookup iterator
    22. private LazyIterator lookupIterator;
  1.     public void reload() { 
  2.         providers.clear();
  3.         lookupIterator = new LazyIterator(service, loader);
  4.     }
  6.     private ServiceLoader(Class<S> svc, ClassLoader cl) { 
  7.         service = Objects.requireNonNull(svc, "Service interface cannot be null");
  8.         loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
  9.         acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
  10.         reload();
  11.     }
  13.     private static void fail(Class<?> service, String msg, Throwable cause)
  14.         throws ServiceConfigurationError
  15.     { 
  16.         throw new ServiceConfigurationError(service.getName() + ": " + msg,
  17.                                             cause);
  18.     }
  20.     private static void fail(Class<?> service, String msg)
  21.         throws ServiceConfigurationError
  22.     { 
  23.         throw new ServiceConfigurationError(service.getName() + ": " + msg);
  24.     }
  26.     private static void fail(Class<?> service, URL u, int line, String msg)
  27.         throws ServiceConfigurationError
  28.     { 
  29.         fail(service, u + ":" + line + ": " + msg);
  30.     }
  32.     // Parse a single line from the given configuration file, adding the name
  33.     // on the line to the names list.
  34.     //具体解析资源文件中的每一行内容
  35.     private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
  36.                           List<String> names)
  37.         throws IOException, ServiceConfigurationError
  38.     { 
  39.         String ln = r.readLine();
  40.         if (ln == null) { 
  41.             //-1表示解析完成
  42.             return -1;
  43.         }
  44.         // 如果存在'#'字符，截取第一个'#'字符串之前的内容，'#'字符之后的属于注释内容
  45.         int ci = ln.indexOf('#');
  46.         if (ci >= 0) ln = ln.substring(0, ci);
  47.         ln = ln.trim();
  48.         int n = ln.length();
  49.         if (n != 0) { 
  50.             //不合法的标识：' '、'\t'
  51.             if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
  52.                 fail(service, u, lc, "Illegal configuration-file syntax");
  53.             int cp = ln.codePointAt(0);
  54.             //判断第一个 char 是否一个合法的 Java 起始标识符
  55.             if (!Character.isJavaIdentifierStart(cp))
  56.                 fail(service, u, lc, "Illegal provider-class name: " + ln);
  57.                //判断所有其他字符串是否属于合法的Java标识符
  58.             for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) { 
  59.                 cp = ln.codePointAt(i);
  60.                 if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
  61.                     fail(service, u, lc, "Illegal provider-class name: " + ln);
  62.             }
  63.             //不存在则缓存
  64.             if (!providers.containsKey(ln) && !names.contains(ln))
  65.                 names.add(ln);
  66.         }
  67.         return lc + 1;
  68.     }
  71.     private Iterator<String> parse(Class<?> service, URL u)
  72.         throws ServiceConfigurationError
  73.     { 
  74.         InputStream in = null;
  75.         BufferedReader r = null;
  76.         ArrayList<String> names = new ArrayList<>();
  77.         try { 
  78.             in = u.openStream();
  79.             r = new BufferedReader(new InputStreamReader(in, "utf-8"));
  80.             int lc = 1;
  81.             while ((lc = parseLine(service, u, r, lc, names)) >= 0);
  82.         } catch (IOException x) { 
  83.             fail(service, "Error reading configuration file", x);
  84.         } finally { 
  85.             try { 
  86.                 if (r != null) r.close();
  87.                 if (in != null) in.close();
  88.             } catch (IOException y) { 
  89.                 fail(service, "Error closing configuration file", y);
  90.             }
  91.         }
  92.         return names.iterator();
  93.     }
  95.     // Private inner class implementing fully-lazy provider lookup
  96.     //
  97.     private class LazyIterator
  98.         implements Iterator<S>
  99.     { 
  101.         Class<S> service;
  102.         ClassLoader loader;
  103.         // 加载资源的URL集合
  104.         Enumeration<URL> configs = null; 
  105.         // 需加载的实现类的全限定类名的集合
  106.         Iterator<String> pending = null;
  107.         // 下一个需要加载的实现类的全限定类名
  108.         String nextName = null;
  110.         private LazyIterator(Class<S> service, ClassLoader loader) { 
  111.             this.service = service;
  112.             this.loader = loader;
  113.         }
  115.         private boolean hasNextService() { 
  116.             if (nextName != null) { 
  117.                 return true;
  118.             }
  119.             if (configs == null) { 
  120.                 try { 
  121.                 // 资源名称，META-INF/services + 全限定名
  122.                     String fullName = PREFIX + service.getName();
  123.                     if (loader == null)
  124.                         configs = ClassLoader.getSystemResources(fullName);
  125.                     else
  126.                         configs = loader.getResources(fullName);
  127.                 } catch (IOException x) { 
  128.                     fail(service, "Error locating configuration files", x);
  129.                 }
  130.             }
  131.             // 从资源中解析出需要加载的所有实现类的全限定名
  132.             while ((pending == null) || !pending.hasNext()) { 
  133.                 if (!configs.hasMoreElements()) { 
  134.                     return false;
  135.                 }
  136.                 pending = parse(service, configs.nextElement());
  137.             }
  138.             //下一个需要加载的实现类全限定名
  139.             nextName = pending.next();
  140.             return true;
  141.         }
  143.         private S nextService() { 
  144.             if (!hasNextService())
  145.                 throw new NoSuchElementException();
  146.             String cn = nextName;
  147.             nextName = null;
  148.             Class<?> c = null;
  149.             try { 
  150.             //反射构造Class实例
  151.                 c = Class.forName(cn, false, loader);
  152.             } catch (ClassNotFoundException x) { 
  153.                 fail(service,
  154.                      "Provider " + cn + " not found");
  155.             }
  156.             // 类型判断，校验实现类必须与当前加载的类/接口的关系是派生或相同，否则抛出异常终止
  157.             if (!service.isAssignableFrom(c)) { 
  158.                 fail(service,
  159.                      "Provider " + cn  + " not a subtype");
  160.             }
  161.             try { 
  162.                 //强转
  163.                 S p = service.cast(c.newInstance());
  164.                  // 实例完成，添加缓存，Key：实现类全限定类名，Value：实现类实例
  165.                 providers.put(cn, p);
  166.                 return p;
  167.             } catch (Throwable x) { 
  168.                 fail(service,
  169.                      "Provider " + cn + " could not be instantiated",
  170.                      x);
  171.             }
  172.             throw new Error();          // This cannot happen
  173.         }
  175.         public boolean hasNext() { 
  176.             if (acc == null) { 
  177.                 return hasNextService();
  178.             } else { 
  179.                 PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() { 
  180.                     public Boolean run() {  return hasNextService(); }
  181.                 };
  182.                 return AccessController.doPrivileged(action, acc);
  183.             }
  184.         }
  186.         public S next() { 
  187.             if (acc == null) { 
  188.                 return nextService();
  189.             } else { 
  190.                 PrivilegedAction<S> action = new PrivilegedAction<S>() { 
  191.                     public S run() {  return nextService(); }
  192.                 };
  193.                 return AccessController.doPrivileged(action, acc);
  194.             }
  195.         }
  197.         public void remove() { 
  198.             throw new UnsupportedOperationException();
  199.         }
  201.     }
  204.     public Iterator<S> iterator() { 
  205.         return new Iterator<S>() { 
  207.             Iterator<Map.Entry<String,S>> knownProviders
  208.                 = providers.entrySet().iterator();
  210.             public boolean hasNext() { 
  211.                 if (knownProviders.hasNext())
  212.                     return true;
  213.                 return lookupIterator.hasNext();
  214.             }
  216.             public S next() { 
  217.                 if (knownProviders.hasNext())
  218.                     return knownProviders.next().getValue();
  219.                 return lookupIterator.next();
  220.             }
  222.             public void remove() { 
  223.                 throw new UnsupportedOperationException();
  224.             }
  226.         };
  227.     }
  230.     public static <S> ServiceLoader<S> load(Class<S> service,
  231.                                             ClassLoader loader)
  232.     { 
  233.     // 返回ServiceLoader的实例
  234.         return new ServiceLoader<>(service, loader);
  235.     }
  238.     public static <S> ServiceLoader<S> loadInstalled(Class<S> service) { 
  240.         ClassLoader cl = ClassLoader.getSystemClassLoader();
  241.         ClassLoader prev = null;
  242.         while (cl != null) { 
  243.             prev = cl;
  244.             cl = cl.getParent();
  245.         }
  246.         return ServiceLoader.load(service, prev);
  247.     }
  250.     public String toString() { 
  251.         return "java.util.ServiceLoader[" + service.getName() + "]";
  252.     }
  254. }

4.总结

SPI机制在实际开发中使用得场景也有很多。特别是统一标准的不同厂商实现，溪源也正是利用SPI机制(但略做改进，避免过多加载资源浪费)实现不同技术平台的结果文件解析需求。

优点

使用Java SPI机制的优势是实现解耦，使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离，而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。

缺点

虽然ServiceLoader也算是使用的延迟加载，但是基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类，它也被加载并实例化了，这就造成了浪费。

源码传送门：SPI Service

发表评论

表情：
评论列表 （有 0 条评论，92人围观）

还没有评论，来说两句吧...

相关阅读

    相关 dubbo源码解析-SPI机制

    　架构体系 　　框架介绍 　　概述 　　Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spri

    蔚落蔚落/ 0 赞/ 127 阅读