[关闭]
@yulongsun 2018-05-05T10:33:30.000000Z 字数 6999 阅读 1153

Dubbo源码走读 - Jdk SPI & Dubbo SPI

Dubbo源码走读

一、JDK SPI

1、jdk spi是什么？

全称：Service Provider Interface.

2、有什么作用？

3、使用demo

demo工程

3.1 定义标准接口

  1. //win.yulongsun.demo.spring.jdkspi.spi.HelloSPIInterface
  2. public interface HelloSPIInterface {
  3.     public void sayHello();
  4. }

3.2 具体实现1

  1. //win.yulongsun.demo.spring.jdkspi.impl.HelloAImpl
  2. public class HelloAImpl implements HelloSPIInterface {
  3.     @Override
  4.     public void sayHello() {
  5.         System.out.printf("say a");
  6.     }
  7. }

3.3 具体实现2

  1. //win.yulongsun.demo.spring.jdkspi.impl.HelloBImpl
  2. public class HelloBImpl implements HelloSPIInterface{
  3.     @Override
  4.     public void sayHello() {
  5.         System.out.println("say b");
  6.     }
  7. }

3.4 配置<接口，实现类>

在classpath:META-INF/services/下新建

  1. win.yulongsun.demo.spring.jdkspi.spi.HelloSPIInterface //=>全接口名称

内容为:

  1. #具体实现类1
  2. win.yulongsun.demo.spring.jdkspi.impl.HelloAImpl
  3. #具体实现类2
  4. win.yulongsun.demo.spring.jdkspi.impl.HelloBImpl

3.5 测试

  1. public class HelloSPITestCase {
  3.     public static void main(String[] args) {
  4.         ServiceLoader<HelloSPIInterface> helloSPIInterfaces = ServiceLoader.load(HelloSPIInterface.class);
  5.         for (HelloSPIInterface item : helloSPIInterfaces) {
  6.             item.sayHello();
  7.         }
  8.     }
  9. }

测试结果

4、SPI的缺点

SPI在查找具体实现的时候，会先遍历实例化所有实现，然后循环找需要的实现。实现了没有必要实现的实例；

  1. //ServiceLoader实现了Iterable接口，可以遍历所有的服务实现者
  2. public final class ServiceLoader<S> implements Iterable<S>
  3. {
  4.     //查找配置文件的目录
  5.     private static final String PREFIX = "META-INF/services/";
  7.     //表示要被加载的服务的类或接口
  8.     private final Class<S> service;
  10.     //这个ClassLoader用来定位，加载，实例化服务提供者
  11.     private final ClassLoader loader;
  13.     // 访问控制上下文
  14.     private final AccessControlContext acc;
  16.     // 缓存已经被实例化的服务提供者，按照实例化的顺序存储
  17.     private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
  19.     // 迭代器
  20.     private LazyIterator lookupIterator;
  22.     //重新加载，就相当于重新创建ServiceLoader了，用于新的服务提供者安装到正在运行的Java虚拟机中的情况。
  23.     public void reload() {
  24.         //清空缓存中所有已实例化的服务提供者
  25.         providers.clear();
  26.         //新建一个迭代器，该迭代器会从头查找和实例化服务提供者
  27.         lookupIterator = new LazyIterator(service, loader);
  28.     }
  30.     //私有构造器
  31.     //使用指定的类加载器和服务创建服务加载器
  32.     //如果没有指定类加载器，使用系统类加载器，就是应用类加载器。
  33.     private ServiceLoader(Class<S> svc, ClassLoader cl) {
  34.         service = Objects.requireNonNull(svc, "Service interface cannot be null");
  35.         loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
  36.         acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
  37.         reload();
  38.     }
  40.     //解析失败处理的方法
  41.     private static void fail(Class<?> service, String msg, Throwable cause)
  42.         throws ServiceConfigurationError
  43.     {
  44.         throw new ServiceConfigurationError(service.getName() + ": " + msg,cause);
  45.     }
  47.     private static void fail(Class<?> service, String msg)
  48.         throws ServiceConfigurationError
  49.     {
  50.         throw new ServiceConfigurationError(service.getName() + ": " + msg);
  51.     }
  53.     private static void fail(Class<?> service, URL u, int line, String msg)
  54.         throws ServiceConfigurationError
  55.     {
  56.         fail(service, u + ":" + line + ": " + msg);
  57.     }
  59.     //解析服务提供者配置文件中的一行
  60.     //首先去掉注释校验，然后保存
  61.     //返回下一行行号
  62.     //重复的配置项和已经被实例化的配置项不会被保存
  63.     private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
  64.                           List<String> names)
  65.         throws IOException, ServiceConfigurationError
  66.     {
  67.         //读取一行
  68.         String ln = r.readLine();
  69.         if (ln == null) {
  70.             return -1;
  71.         }
  72.         //#号代表注释行
  73.         int ci = ln.indexOf('#');
  74.         if (ci >= 0) ln = ln.substring(0, ci);
  75.         ln = ln.trim();
  76.         int n = ln.length();
  77.         if (n != 0) {
  78.             if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
  79.                 fail(service, u, lc, "Illegal configuration-file syntax");
  80.             int cp = ln.codePointAt(0);
  81.             if (!Character.isJavaIdentifierStart(cp))
  82.                 fail(service, u, lc, "Illegal provider-class name: " + ln);
  83.             for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
  84.                 cp = ln.codePointAt(i);
  85.                 if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
  86.                     fail(service, u, lc, "Illegal provider-class name: " + ln);
  87.             }
  88.             if (!providers.containsKey(ln) && !names.contains(ln))
  89.                 names.add(ln);
  90.         }
  91.         return lc + 1;
  92.     }
  94.     //解析配置文件，解析指定的url配置文件
  95.     //使用parseLine方法进行解析，未被实例化的服务提供者会被保存到缓存中去
  96.     private Iterator<String> parse(Class<?> service, URL u)
  97.         throws ServiceConfigurationError
  98.     {
  99.         InputStream in = null;
  100.         BufferedReader r = null;
  101.         ArrayList<String> names = new ArrayList<>();
  102.         try {
  103.             in = u.openStream();
  104.             r = new BufferedReader(new InputStreamReader(in, "utf-8"));
  105.             int lc = 1;
  106.             while ((lc = parseLine(service, u, r, lc, names)) >= 0);
  107.         }
  108.         return names.iterator();
  109.     }
  111.     //服务提供者查找的迭代器
  112.     private class LazyIterator implements Iterator<S>
  113.     {
  115.         Class<S> service;//服务提供者接口
  116.         ClassLoader loader;//类加载器
  117.         Enumeration<URL> configs = null;//保存实现类的url
  118.         Iterator<String> pending = null;//保存实现类的全名
  119.         String nextName = null;//迭代器中下一个实现类的全名
  121.         private LazyIterator(Class<S> service, ClassLoader loader) {
  122.             this.service = service;
  123.             this.loader = loader;
  124.         }
  126.         private boolean hasNextService() {
  127.             if (nextName != null) {
  128.                 return true;
  129.             }
  130.             if (configs == null) {
  131.                 try {
  132.                     String fullName = PREFIX + service.getName();
  133.                     if (loader == null)
  134.                         configs = ClassLoader.getSystemResources(fullName);
  135.                     else
  136.                         configs = loader.getResources(fullName);
  137.                 }
  138.             }
  139.             while ((pending == null) || !pending.hasNext()) {
  140.                 if (!configs.hasMoreElements()) {
  141.                     return false;
  142.                 }
  143.                 pending = parse(service, configs.nextElement());
  144.             }
  145.             nextName = pending.next();
  146.             return true;
  147.         }
  149.         private S nextService() {
  150.             if (!hasNextService())
  151.                 throw new NoSuchElementException();
  152.             String cn = nextName;
  153.             nextName = null;
  154.             Class<?> c = null;
  155.             try {
  156.                 c = Class.forName(cn, false, loader);
  157.             }
  158.             if (!service.isAssignableFrom(c)) {
  159.                 fail(service, "Provider " + cn  + " not a subtype");
  160.             }
  161.             try {
  162.                 //注意：实例化
  163.                 S p = service.cast(c.newInstance());
  164.                 providers.put(cn, p);
  165.                 return p;
  166.             }
  167.         }
  169.         public boolean hasNext() {
  170.             if (acc == null) {
  171.                 return hasNextService();
  172.             } else {
  173.                 PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
  174.                     public Boolean run() { return hasNextService(); }
  175.                 };
  176.                 return AccessController.doPrivileged(action, acc);
  177.             }
  178.         }
  180.         public S next() {
  181.             if (acc == null) {
  182.                 return nextService();
  183.             } else {
  184.                 PrivilegedAction<S> action = new PrivilegedAction<S>() {
  185.                     public S run() { return nextService(); }
  186.                 };
  187.                 return AccessController.doPrivileged(action, acc);
  188.             }
  189.         }
  191.         public void remove() {
  192.             throw new UnsupportedOperationException();
  193.         }
  195.     }
  197.     //获取迭代器
  198.     //返回遍历服务提供者的迭代器
  199.     //以懒加载的方式加载可用的服务提供者
  200.     //懒加载的实现是：解析配置文件和实例化服务提供者的工作由迭代器本身完成
  201.     public Iterator<S> iterator() {
  202.         return new Iterator<S>() {
  203.             //按照实例化顺序返回已经缓存的服务提供者实例
  204.             Iterator<Map.Entry<String,S>> knownProviders
  205.                 = providers.entrySet().iterator();
  207.             public boolean hasNext() {
  208.                 if (knownProviders.hasNext())
  209.                     return true;
  210.                 return lookupIterator.hasNext();
  211.             }
  213.             public S next() {
  214.                 if (knownProviders.hasNext())
  215.                     return knownProviders.next().getValue();
  216.                 return lookupIterator.next();
  217.             }
  219.             public void remove() {
  220.                 throw new UnsupportedOperationException();
  221.             }
  223.         };
  224.     }
  226.     //为指定的服务使用指定的类加载器来创建一个ServiceLoader
  227.     public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader)
  228.     {
  229.         return new ServiceLoader<>(service, loader);
  230.     }
  232.     //使用线程上下文的类加载器来创建ServiceLoader
  233.     public static <S> ServiceLoader<S> load(Class<S> service) {
  234.         ClassLoader cl = Thread.currentThread().getContextClassLoader();
  235.         return ServiceLoader.load(service, cl);
  236.     }
  238.     //使用扩展类加载器为指定的服务创建ServiceLoader
  239.     //只能找到并加载已经安装到当前Java虚拟机中的服务提供者，应用程序类路径中的服务提供者将被忽略
  240.     public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {
  241.         ClassLoader cl = ClassLoader.getSystemClassLoader();
  242.         ClassLoader prev = null;
  243.         while (cl != null) {
  244.             prev = cl;
  245.             cl = cl.getParent();
  246.         }
  247.         return ServiceLoader.load(service, prev);
  248.     }
  250.     public String toString() {
  251.         return "java.util.ServiceLoader[" + service.getName() + "]";
  252.     }
  254. }

二、Dubbo SPI内核加载

1、Dubbo采用微内核+插件体系。使得扩展性强。
Dubbo强大的扩展能力，主要依赖于它自己实现的一套SPI机制，开发人员可以根据dubbo的规范进行扩展现有的功能或者替换现有的实现，dubbo内部的功能的实现也都是通过的SPI来实现的，这是dubbo的功能高度可插拔的原因。

2、SPI接口定义

  1. public @interface SPI {
  2.     /**
  3.      * default extension name
  4.      */
  5.     String value() default "";
  7. }

在扩展点加了@SPI注解，Dubbo会依次从以下目录加载具体实现：

  1. META-INF/dubbo/internal/ --> Dubbo内部实现的各种插件
  2. META-INF/dubbo/
  3. META-INF/services/

3、特性

4、SPI使用

问题

1、JDK SPI和Dubbo SPI有什么区别？

  1. 1、Dubbo SPI添加了缓存机制。增加了对IOC和AOP的支持。
  2. 2、JDK SPI会一次性加载所有扩展点实现。

参考

1、Dubbo原理解析-Dubbo内核实现之基于SPI思想Dubbo内核实现（转）
2、5.dubbo源码分析 之 SPI 分析
3、Dubbo扩展点加载机制 - ExtensionLoader

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注