「DUBBO系列」JDK SPI机制原理

系统管理员 2021-09-24 23:36 390阅读 0赞

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，欢迎大家加我微信「java_front」一起交流学习

1 文章概述

SPI（Service Provider Interface）是一种服务发现机制，本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件加载实现类，这样可以在运行时动态为接口替换实现类，我们通过 SPI 机制可以为程序提供拓展功能。本文我们介绍JDK SPI使用方法并通过分析源码深入理解。后续文章介绍Dubbo自己实现的SPI机制。

2 SPI实例

(1) 新建项目工程并定义接口DataBaseDriver

  1. public interface DataBaseDriver { 
  2.     String connect(String hostIp);
  3. }

(2) 打包这个工程为JAR

  1. <dependency>
  2.   <groupId>com.itxpz.spi</groupId>
  3.   <artifactId>DataBaseDriver</artifactId>
  4.   <version>1.0.0-SNAPSHOT</version>
  5. </dependency>

(3) 新建MySQLDriver工程添加上述依赖并实现DataBaseDriver接口

  1. import com.itxpz.database.driver.DataBaseDriver;
  2. public class MySQLDataBaseDriver implements DataBaseDriver { 
  3.     @Override
  4.     public String connect(String hostIp) { 
  5.         return "MySQL DataBase Driver connect";
  6.     }
  7. }

(4) 在MySQLDriver项目新建文件

  1. src/main/resources/META-INF/services/com.itxpz.database.driver.DataBaseDriver

(5) 在此文件添加如下内容

  1. com.itxpz.database.mysql.driver.MySQLDataBaseDriver

(6) 新建OracleDriver工程操作方式相同，配置文件内容有所变化

  1. com.itxpz.database.oracle.driver.OracleDataBaseDriver

(7) 将上述两个项目打包

  1. <dependency>
  2.   <groupId>com.itxpz.spi</groupId>
  3.   <artifactId>MySQLDriver</artifactId>
  4.   <version>1.0.0-SNAPSHOT</version>
  5. </dependency>
  6. <dependency>
  7.   <groupId>com.itxpz.spi</groupId>
  8.   <artifactId>OracleDriver</artifactId>
  9.   <version>1.0.0-SNAPSHOT</version>
  10. </dependency>

(8) 新建测试项目引入上述依赖并执行以下代码

  1. public class DataBaseConnector { 
  2.     public static void main(String[] args) { 
  3.         ServiceLoader<DataBaseDriver> serviceLoader = ServiceLoader.load(DataBaseDriver.class);
  4.         Iterator<DataBaseDriver> iterator = serviceLoader.iterator();
  5.         while (iterator.hasNext()) { 
  6.             DataBaseDriver driver = iterator.next();
  7.             System.out.println(driver.connect("localhost"));
  8.         }
  9.     }
  10. }
  12. 输出结果
  13. MySQL DataBase Driver connect
  14. Oracle DataBase Driver connect

我们并没有指定使用哪个驱动进行连接，而是通过ServiceLoader方式加载实现了DataBaseDriver接口的实现类。假设我们只想要使用MySQL驱动那么直接引入相应依赖即可。

3 源码分析

3.1 迭代器模式

我们在分析JDK SPI源码之前首先学习迭代器设计模式，因为JDK SPI应用了迭代器模式。

  1. public class OrderInfoModel implements Serializable { 
  2.     private String orderId;
  4.     public OrderInfoModel(String orderId) { 
  5.         this.orderId = orderId;
  6.     }
  8.     public String getOrderId() { 
  9.         return orderId;
  10.     }
  12.     public void setOrderId(String orderId) { 
  13.         this.orderId = orderId;
  14.     }
  16.     @Override
  17.     public String toString() { 
  18.         return "OrderInfoModel [orderId=" + orderId + "]";
  19.     }
  20. }
  22. public class OrderInfoIterator implements Iterator<OrderInfoModel> { 
  23.     private int cursor;
  24.     private List<OrderInfoModel> orderInfoList;
  26.     public OrderInfoIterator(List<OrderInfoModel> orderInfoList) { 
  27.         this.cursor = 0;
  28.         this.orderInfoList = orderInfoList;
  29.     }
  31.     @Override
  32.     public boolean hasNext() { 
  33.         if(CollectionUtils.isEmpty(orderInfoList)) { 
  34.             throw new RuntimeException("param error");
  35.         }
  36.         return cursor != orderInfoList.size();
  37.     }
  39.     @Override
  40.     public OrderInfoModel next() { 
  41.         if(CollectionUtils.isEmpty(orderInfoList)) { 
  42.             throw new RuntimeException("param error");
  43.         }
  44.         OrderInfoModel element = orderInfoList.get(cursor);
  45.         cursor++;
  46.         return element;
  47.     }
  48. }
  50. public class TestMain { 
  51.     public static void main(String[] args) { 
  52.         List<OrderInfoModel> orderInfoList = new ArrayList<>();
  53.         OrderInfoModel order1 = new OrderInfoModel("111");
  54.         OrderInfoModel order2 = new OrderInfoModel("222");
  55.         OrderInfoModel order3 = new OrderInfoModel("333");
  56.         orderInfoList.add(order1);
  57.         orderInfoList.add(order2);
  58.         orderInfoList.add(order3);
  60.         Iterator<OrderInfoModel> iterator = new OrderInfoIterator(orderInfoList);
  61.         while (iterator.hasNext()) { 
  62.             System.out.println(iterator.next());
  63.         }
  64.     }
  65. }
  67. 输出结果
  68. OrderInfoModel [orderId=111]
  69. OrderInfoModel [orderId=222]
  70. OrderInfoModel [orderId=333]

3.2 SPI源码分析

  1. public class DataBaseConnector { 
  2.     public static void main(String[] args) { 
  3.         // 根据类型获取服务加载器
  4.         ServiceLoader<DataBaseDriver> serviceLoader = ServiceLoader.load(DataBaseDriver.class);
  5.         // 获取迭代器
  6.         Iterator<DataBaseDriver> iterator = serviceLoader.iterator();
  7.         // 迭代器遍历
  8.         while (iterator.hasNext()) { 
  9.             DataBaseDriver driver = iterator.next();
  10.             System.out.println(driver.connect("localhost"));
  11.         }
  12.     }
  13. }

进入ServiceLoader.load方法

  1. ServiceLoader<DataBaseDriver> serviceLoader = ServiceLoader.load(DataBaseDriver.class);

跟进load方法发现只是进行初始化

  1. public final class ServiceLoader<S> implements Iterable<S> { 
  3.     // 默认加载服务路径
  4.     private static final String PREFIX = "META-INF/services/";
  6.     // 缓存提供者信息
  7.     private LinkedHashMap<String, S> providers = new LinkedHashMap<>();
  9.     // 当前迭代器
  10.     private LazyIterator lookupIterator;
  12.     public void reload() { 
  13.         // 清除缓存
  14.         providers.clear();
  15.         // 核心迭代器
  16.         lookupIterator = new LazyIterator(service, loader);
  17.     }
  19.     private ServiceLoader(Class<S> svc, ClassLoader cl) { 
  20.         service = Objects.requireNonNull(svc, "Service interface cannot be null");
  21.         loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
  22.         acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
  23.         reload();
  24.     }
  25. }

进入serviceLoader.iterator()方法

  1. public Iterator<S> iterator() { 
  2.     return new Iterator<S>() { 
  3.         Iterator<Map.Entry<String,S>> knownProviders = providers.entrySet().iterator();
  4.         public boolean hasNext() { 
  5.             if (knownProviders.hasNext())
  6.                 return true;
  7.             return lookupIterator.hasNext();
  8.         }
  10.         public S next() { 
  11.             // 如果缓存有则取缓存
  12.             if (knownProviders.hasNext())
  13.                 return knownProviders.next().getValue();
  14.             // 缓存没有则重新加载
  15.             return lookupIterator.next();
  16.         }
  18.         public void remove() { 
  19.             throw new UnsupportedOperationException();
  20.         }
  21.     }
  22. }

进入迭代器遍历代码

  1. while (iterator.hasNext()) { 
  2.     DataBaseDriver driver = iterator.next();
  3.     System.out.println(driver.connect("localhost"));
  4. }

LazyIterator核心方法分析详见注释。核心是读取指定路径文件内容，通过反射进行类实例化并且保存至缓存容器。因为创建类需要使用栈空间，如果不使用缓存频繁创建类会造成栈溢出异常。

  1. private class LazyIterator implements Iterator<S> { 
  2.     Class<S> service;
  3.     ClassLoader loader;
  4.     Enumeration<URL> configs = null;
  5.     Iterator<String> pending = null;
  6.     String nextName = null;
  8.     private boolean hasNextService() { 
  9.         if (nextName != null) { 
  10.             return true;
  11.         }
  12.         if (configs == null) { 
  13.             try { 
  14.                 // META-INFO/Services/com.itxpz.database.driver.DataBaseDriver
  15.                 String fullName = PREFIX + service.getName();
  16.                 if (loader == null)
  17.                     configs = ClassLoader.getSystemResources(fullName);
  18.                 else
  19.                     // 构建fullName路径配置对象
  20.                     configs = loader.getResources(fullName);
  21.             } catch (IOException x) { 
  22.                 fail(service, "Error locating configuration files", x);
  23.             }
  24.         }
  25.         while ((pending == null) || !pending.hasNext()) { 
  26.             if (!configs.hasMoreElements()) { 
  27.                 return false;
  28.             }
  29.             // 解析文件内容
  30.             pending = parse(service, configs.nextElement());
  31.         }
  32.         // com.itxpz.database.mysql.driver.MySQLDataBaseDriver
  33.         // com.itxpz.database.mysql.driver.OracleDataBaseDriver
  34.         nextName = pending.next();
  35.         return true;
  36.     }
  38.     private S nextService() { 
  39.         if (!hasNextService())
  40.             throw new NoSuchElementException();
  41.         // com.itxpz.database.mysql.driver.MySQLDataBaseDriver
  42.         // com.itxpz.database.mysql.driver.OracleDataBaseDriver
  43.         String cn = nextName;
  44.         nextName = null;
  45.         Class<?> c = null;
  46.         try { 
  47.             // 通过反射进行实例化
  48.             c = Class.forName(cn, false, loader);
  49.         } catch (ClassNotFoundException x) { 
  50.             fail(service, "Provider " + cn + " not found");
  51.         }
  52.         if (!service.isAssignableFrom(c)) { 
  53.             fail(service, "Provider " + cn  + " not a subtype");
  54.         }
  55.         try { 
  56.             // 类型转换父类引用指向子类对象
  57.             S p = service.cast(c.newInstance());
  58.             // 保存至缓存容器
  59.             providers.put(cn, p);
  60.             return p;
  61.         } catch (Throwable x) { 
  62.             fail(service, "Provider " + cn + " could not be instantiated", x);
  63.         }
  64.         throw new Error();
  65.     }
  66. }

4 实际应用

使用JDBC时利用DriverManager加载数据库驱动时正是使用了SPI机制，我们引入MySQL依赖

  1. <dependency>
  2.   <groupId>mysql</groupId>
  3.   <artifactId>mysql-connector-java</artifactId>
  4.   <version>6.0.6</version>
  5. </dependency>

在MySQL依赖包中会发现如下文件

  1. META-INF/services/java.sql.Driver

DriverManager加载驱动时可以发现SPI机制

  1. package java.sql;
  2. public class DriverManager { 
  3.     private static void loadInitialDrivers() { 
  4.         AccessController.doPrivileged(new PrivilegedAction<Void>() { 
  5.             public Void run() { 
  6.                 // META-INF/services/java.sql.Driver
  7.                 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
  8.                 Iterator<Driver> driversIterator = loadedDrivers.iterator();
  9.                 try { 
  10.                     while(driversIterator.hasNext()) { 
  11.                         driversIterator.next();
  12.                     }
  13.                 } catch(Throwable t) { 
  14.                 }
  15.                 return null;
  16.             }
  17.         });
  18.     }
  19. }

欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章，主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等，欢迎大家加我微信「java_front」一起交流学习

发表评论

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

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

相关阅读

    相关 jdk和dubbo的SPI机制

    [jdk和dubbo的SPI机制][jdk_dubbo_SPI] 前言：开闭原则一直是软件开发领域中所追求的,开闭原则中的"开"是指对于组件功能的扩展是开放的,是允许对其

    小鱼儿小鱼儿/ 0 赞/ 266 阅读