1、What is SPI???

  1. 1、SPI{Service Procider Interface},是JDK内置的一种服务提供发现机制。
  2. 2、SPI是一种动态替换发现的机制，比如有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。
  3. 3、如下图中：接口对应的抽象SPI接口，实现放实现SPI接口，调用放依赖SPI接口。
  5. 4、SPI接口定义在调用方，在概念上更依赖调用方。
  6.     4-1、当服务的提供者提供一个接口的实现之后，需要在classpath下的META-INF/service/目录下创建一个以服务接口命名的文件，这个文件里的内容就是这个接口的具体的实现类。
  7.     4-2、当其他的程序需要这个服务的时候，就可以通过查找这个jar包(一般都是以jar包做依赖)的META-INF/services/中的配置文件，配置文件中有接口的具体实现类名，可以根据这个类名进行加载实例化，然后就可以使用该服务了。
  8.     4-3、JDK中查找服务实现的工具类是：java.util.ServiceLoader.

1-1、SPI-概念示意图

image.png

1-2、SPI的用途-举例

  1. 1、SPI机制应用：DriverManager、Spring、ConfigurableBeanFactory等。

1-2-1、SPI的用途-举例-DriverManager

  1. 1、DriverManager 是 jdbc 里管理和注册不同数据库 driver 的工具类。针对一个数据库，可能会存在着不同的数据库驱动实现。我们在使用特定的驱动实现时，不希望修改现有的代码，而希望通过一个简单的配置达到效果。
  3. 2、Driver源码：
  4.     public class Driver extends NonRegisteringDriver implements java.sql.Driver {
  5.         public Driver() throws SQLException {
  6.         }
  8.         static {
  9.             try {
  10.                 //静态代码块中，调用DriverManager的注册驱动方法new一个自己当参数传给驱动管理器
  11.                 DriverManager.registerDriver(new Driver());
  12.             } catch (SQLException var1) {
  13.                 throw new RuntimeException("Can't register driver!");
  14.             }
  15.         }
  16.     } 
  17. 3、Mysql DriverManager 源码：
  18.     public class DriverManager {
  19.         // List of registered JDBC drivers
  20.         private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
  21.         private DriverManager(){}
  22.         static {
  23.             loadInitialDrivers();
  24.             println("JDBC DriverManager initialized");
  25.         }
  27.         //静态内部类，用到了SPI工具类ServiceLoader
  28.         private static void loadInitialDrivers() {
  29.             String drivers;
  30.             try {
  31.                 drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
  32.                     public String run() {
  33.                         return System.getProperty("jdbc.drivers");
  34.                     }
  35.                 });
  36.             } catch (Exception ex) {
  37.                 drivers = null;
  38.             }
  39.             AccessController.doPrivileged(new PrivilegedAction<Void>() {
  40.                 public Void run() {
  41.                     // 用到了SPI工具类ServiceLoader
  42.                     ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
  43.                     Iterator<Driver> driversIterator = loadedDrivers.iterator();
  45.                     //加载SPI扫描到的驱动来触发他们的初始化{触发static代码块}
  46.                     try{
  47.                         while(driversIterator.hasNext()) {
  48.                             driversIterator.next();
  49.                         }
  50.                     } catch(Throwable t) {
  51.                     // Do nothing
  52.                     }
  53.                     return null;
  54.                 }
  55.             });
  57.             println("DriverManager.initialize: jdbc.drivers = " + drivers);
  59.             if (drivers == null || drivers.equals("")) {
  60.                 return;
  61.             }
  62.             String[] driversList = drivers.split(":");
  63.             println("number of Drivers:" + driversList.length);
  64.             for (String aDriver : driversList) {
  65.                 try {
  66.                     println("DriverManager.Initialize: loading " + aDriver);
  67.                     Class.forName(aDriver, true,
  68.                             ClassLoader.getSystemClassLoader());
  69.                 } catch (Exception ex) {
  70.                     println("DriverManager.Initialize: load failed: " + ex);
  71.                 }
  72.             }
  73.         }
  75.         public static synchronized void registerDriver(java.sql.Driver driver) throws SQLException {
  76.             registerDriver(driver, null);
  77.         }
  79.         public static synchronized void registerDriver(java.sql.Driver driver,DriverAction da)throws SQLException {
  80.                 /* Register the driver if it has not already been added to our list */
  81.             // 将自己注册大片驱动管理器的驱动列表中
  82.             if(driver != null) {
  83.                 registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
  84.             } else {
  85.                 // This is for compatibility with the original DriverManager
  86.                 throw new NullPointerException();
  87.             }
  88.             println("registerDriver: " + driver);
  89.         }
  91.         //当获取连接的时候调用驱动管理器的连接方法从列表中(之前处理的map)获取
  92.         @CallerSensitive
  93.         public static Connection getConnection(String url,
  94.             java.util.Properties info) throws SQLException {
  95.             return (getConnection(url, info, Reflection.getCallerClass()));
  96.         }
  98.         //  Worker method called by the public getConnection() methods.
  99.         private static Connection getConnection(
  100.             String url, java.util.Properties info, Class<?> caller) throws SQLException {
  101.             /*
  102.              * When callerCl is null, we should check the application's
  103.              * (which is invoking this class indirectly)
  104.              * classloader, so that the JDBC driver class outside rt.jar
  105.              * can be loaded from here.
  106.              */
  107.             ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
  108.             synchronized(DriverManager.class) {
  109.                 // synchronize loading of the correct classloader.
  110.                 if (callerCL == null) {
  111.                     callerCL = Thread.currentThread().getContextClassLoader();
  112.                 }
  113.             }
  115.             if(url == null) {
  116.                 throw new SQLException("The url cannot be null", "08001");
  117.             }
  119.             println("DriverManager.getConnection(\"" + url + "\")");
  121.             // Walk through the loaded registeredDrivers attempting to make a connection.
  122.             // Remember the first exception that gets raised so we can reraise it.
  123.             SQLException reason = null;
  125.             for(DriverInfo aDriver : registeredDrivers) {
  126.                 // If the caller does not have permission to load the driver then
  127.                 // skip it.
  128.                 if(isDriverAllowed(aDriver.driver, callerCL)) {
  129.                     try {
  130.                         println("    trying " + aDriver.driver.getClass().getName());
  131.                         Connection con = aDriver.driver.connect(url, info);
  132.                         if (con != null) {
  133.                             // Success!
  134.                             println("getConnection returning " + aDriver.driver.getClass().getName());
  135.                             return (con);
  136.                         }
  137.                     } catch (SQLException ex) {
  138.                         if (reason == null) {
  139.                             reason = ex;
  140.                         }
  141.                     }
  143.                 } else {
  144.                     println("    skipping: " + aDriver.getClass().getName());
  145.                 }
  147.             }
  149.             // if we got here nobody could connect.
  150.             if (reason != null)    {
  151.                 println("getConnection failed: " + reason);
  152.                 throw reason;
  153.             }
  155.             println("getConnection: no suitable driver found for "+ url);
  156.             throw new SQLException("No suitable driver found for "+ url, "08001");
  157.         }
  158.     }
  159. 4、ServiceLoader源码：
  160.     public final class ServiceLoader<S> implements Iterable<S> {      
  161.         private static final String PREFIX = "META-INF/services/";
  162.         private final Class<S> service;
  163.         private final ClassLoader loader;
  164.         private final AccessControlContext acc;
  165.         private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
  166.         private LazyIterator lookupIterator;
  167.         //构造方法
  168.         private ServiceLoader(Class<S> svc, ClassLoader cl) {
  169.             service = Objects.requireNonNull(svc, "Service interface cannot be null");
  170.             loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
  171.             acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
  172.             reload();
  173.         }
  175.         public void reload() {
  176.             providers.clear();
  177.             lookupIterator = new LazyIterator(service, loader);
  178.         }
  179.         //内部类
  180.         private class LazyIterator implements Iterator<S> {
  181.             Class<S> service;
  182.             ClassLoader loader;
  183.             Enumeration<URL> configs = null;
  184.             Iterator<String> pending = null;
  185.             String nextName = null;
  187.             private LazyIterator(Class<S> service, ClassLoader loader) {
  188.                 this.service = service;
  189.                 this.loader = loader;
  190.             }
  192.             private boolean hasNextService() {
  193.                 if (nextName != null) {
  194.                     return true;
  195.                 }
  196.                 if (configs == null) {
  197.                     try {
  198.                         //加载META-INF/services/文件夹下类名为文件名的子类，将其加载到虚拟机
  199.                         String fullName = PREFIX + service.getName();
  200.                         if (loader == null)
  201.                             configs = ClassLoader.getSystemResources(fullName);
  202.                         else
  203.                             configs = loader.getResources(fullName);
  204.                     } catch (IOException x) {
  205.                         fail(service, "Error locating configuration files", x);
  206.                     }
  207.                 }
  208.                 while ((pending == null) || !pending.hasNext()) {
  209.                     if (!configs.hasMoreElements()) {
  210.                         return false;
  211.                     }
  212.                     pending = parse(service, configs.nextElement());
  213.                 }
  214.                 nextName = pending.next();
  215.                 return true;
  216.             }
  218.             private S nextService() {
  219.                 if (!hasNextService())
  220.                     throw new NoSuchElementException();
  221.                 String cn = nextName;
  222.                 nextName = null;
  223.                 Class<?> c = null;
  224.                 try {
  225.                     c = Class.forName(cn, false, loader);
  226.                 } catch (ClassNotFoundException x) {
  227.                     fail(service,
  228.                          "Provider " + cn + " not found");
  229.                 }
  230.                 if (!service.isAssignableFrom(c)) {
  231.                     fail(service,
  232.                          "Provider " + cn  + " not a subtype");
  233.                 }
  234.                 try {
  235.                     S p = service.cast(c.newInstance());
  236.                     providers.put(cn, p);
  237.                     return p;
  238.                 } catch (Throwable x) {
  239.                     fail(service,
  240.                          "Provider " + cn + " could not be instantiated",
  241.                          x);
  242.                 }
  243.                 throw new Error();          // This cannot happen
  244.             }
  246.             public boolean hasNext() {
  247.                 if (acc == null) {
  248.                     return hasNextService();
  249.                 } else {
  250.                     PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
  251.                         public Boolean run() { return hasNextService(); }
  252.                     };
  253.                     return AccessController.doPrivileged(action, acc);
  254.                 }
  255.             }
  257.             public S next() {
  258.                 if (acc == null) {
  259.                     return nextService();
  260.                 } else {
  261.                     PrivilegedAction<S> action = new PrivilegedAction<S>() {
  262.                         public S run() { return nextService(); }
  263.                     };
  264.                     return AccessController.doPrivileged(action, acc);
  265.                 }
  266.             }
  268.             public void remove() {
  269.                 throw new UnsupportedOperationException();
  270.             }
  272.         }
  273. }
  1.  @CallerSensitive
  2.     public static Connection getConnection(String url,
  3.         String user, String password) throws SQLException {
  4.         java.util.Properties info = new java.util.Properties();
  6.         if (user != null) {
  7.             info.put("user", user);
  8.         }
  9.         if (password != null) {
  10.             info.put("password", password);
  11.         }
  13.         return (getConnection(url, info, Reflection.getCallerClass()));
  14.     }