JDK SPI机制以及自定义SPI类加载

概述

介绍SPI之前，我们先了解一下为什么要用SPI

JDBC相信已经不陌生了，JDBC 是一个标准。不同的数据库厂商（如，mysql、oracle等）会根据这个标准，有它们自己的实现。既然，JDBC 是一个标准，那么 JDBC 的接口，应该就已经存在于JDK 中了，以前我们在使用JDBC的时候，都是需要加载Driver驱动的，如：

Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql:///test";
Connection connection = = DriverManager.getConnection(url,"root","123456");

但是我们如果没有写的这行代码，也是可以让com.mysql.jdbc.Driver正确加载的，即：

String url = "jdbc:///test";
Connection connection = = DriverManager.getConnection(url,"root","123456");

那么这是为什么呢？要知道DriverManager类是由启动类加载器加载，而且根据全盘负责委托机制，每个类都有自己的类加载器，那么负责加载当前类的类加载器也会去加载当前类中引用的其他类，前提是引用的类没有被加载过。例如ClassA中有个变量 ClassB,那么加载ClassA的类加载器会去加载ClassB，如果找不到ClassB，则异常。根据以上特性，那么JDK中的DriverManager启动类加载器会尝试去加载MySql的jar包，但明显是找不到的，因为它根本不在JDK中，那我们不妨看一下DriverManager的源码：

继续查看一下其中的 loadInitialDrivers() 方法：

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
	// 1
    AccessController.doPrivileged(new PrivilegedAction() {
        public Void run() {

            ServiceLoader loadedDrivers = ServiceLoader.load(Driver.class);
            Iterator driversIterator = loadedDrivers.iterator();

            try{
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
            } catch(Throwable t) {
            // Do nothing
            }
            return null;
        }
    });

    println("DriverManager.initialize: jdbc.drivers = " + drivers);
    // 2
    if (drivers == null || drivers.equals("")) {
        return;
    }
    String[] driversList = drivers.split(":");
    println("number of Drivers:" + driversList.length);
    for (String aDriver : driversList) {
        try {
            println("DriverManager.Initialize: loading " + aDriver);
            // 3
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        } catch (Exception ex) {
            println("DriverManager.Initialize: load failed: " + ex);
        }
    }
}

分析其中两个地方：

1、这里使用了ServiceLoader机制来加载驱动，它是Java提供的一套 SPI（Service Provider Interface）框架，用于实现服务提供方与服务使用方解耦2、使用 jdbc.drivers 定义的驱动名加载驱动3、ClassLoader.getSystemClassLoader() 就是应用程序类加载器规则

SPI机制是JDK提供接口，第三方Jar包实现，接口由启动类加载器加载，实现类不在JDK中，需要反向委派，由线程上下文加载器加载。它约定：在 jar 包的 meta-INF/services 包下，以接口全限定名为文件名，文件内容是实现类名称

这样便可以使用刚才loadInitialDrivers这个方法

ServiceLoader<接口类型> allImpls = ServiceLoader.load(接口类型.class);
Iterator<接口类型> iter = allImpls.iterator();
while(iter.hasNext()) {
    iter.next();
}

来得到具体的Driver实现类，那我们再追一下ServiceLoader是如何通过Driver.class接口来加载它具体的实现类的，现在进入 load() 方法：

public static  ServiceLoader load(Class service) {
    //获取到了线程上下文类加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

线程上下文类加载器是当前线程使用的类加载器，默认就是应用程序类加载器，那么这个方法中的load方法就会使用刚才拿到的线程上下文类加载器去加载目标实现类，不过这个方法比较深，真正加载的具体代码在 ServiceLoader 的内部类 LazyIterator 的nextService方法中：
自定义实现注解
package com.phz.prpc.extension; import java.lang.annotation.*; @documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Spi { }
基于SPI的伪类加载器
package com.phz.prpc.extension; import lombok.Data; import lombok.extern.slf4j.Slf4j; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.URL; import java.util.Enumeration; import static java.nio.charset.StandardCharsets.UTF_8; @Slf4j @Data public final class ExtensionLoader { private static final String SERVICE_DIRECTORY = "meta-INF/extensions/"; private final Class type; public static ExtensionLoader getExtensionLoader(Class type) { if (type == null) { throw new IllegalArgumentException("Spi需要知道你想要找到哪个功能的第三方实现！"); } if (!type.isInterface()) { throw new IllegalArgumentException("只支持寻找接口类型的第三方实现！"); } if (type.getAnnotation(Spi.class) == null) { throw new IllegalArgumentException("目标接口必须被@Spi注解标注！"); } return new ExtensionLoader<>(type); } public T getExtension() { // 加载到一个第三方实现 Class clazz = loadExtensionFile(); if (clazz == null) { return null; } try { return clazz.newInstance(); } catch (InstantiationException | IllegalAccessException e) { throw new RuntimeException("实例化失败 : " + clazz); } } private Class loadExtensionFile() { //想要获取谁的实现类 String fileName = ExtensionLoader.SERVICE_DIRECTORY + type.getName(); try { Enumeration urls; ClassLoader classLoader = ExtensionLoader.class.getClassLoader(); urls = classLoader.getResources(fileName); if (urls != null) { URL resourceUrl = urls.nextElement(); return loadResource(classLoader, resourceUrl); } return null; } catch (IOException e) { log.error(e.getMessage()); return null; } } @SuppressWarnings("unchecked") private Class loadResource(ClassLoader classLoader, URL resourceUrl) { try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceUrl.openStream(), UTF_8))) { String line; while ((line = reader.readLine()) != null) { // 可能是注释 final int ci = line.indexOf('#'); //如果是第一个位置，则这一行都可以不用解析了 if (ci == 0) { continue; } else if (ci > 0) { //如果非第一个位置，需要将注释前面的内容取出来，也就是将注释后面的内容截取 line = line.substring(0, ci); } return (Class) classLoader.loadClass(line.trim()); } } catch (IOException | ClassNotFoundException e) { log.error(e.getMessage()); return null; } return null; } }
测试

参考如下方式：

代码中体现（因为自定义的SPI机制用于笔者自己的项目下方，所以读者可以仅关注代码中的11行即可）：

public InetSocketAddress doChoice(List serviceInstances) { String loadBalanceAlgorithm = prpcProperties.getLoadBalanceAlgorithm(); LoadBalance loadBalance; try { loadBalance = ExtensionLoader.getExtensionLoader(LoadBalance.class).getExtension(); if (loadBalance == null) { loadBalance = LoadBalanceAlgorithm.valueOf(loadBalanceAlgorithm); } } catch (IllegalArgumentException e) { log.error("未知的负载均衡算法:{},异常信息为:{}", loadBalanceAlgorithm, e.getMessage()); throw new PrpcException(ErrorMsg.UNKNOWN_LOAD_BALANCE_ALGORITHM); } return loadBalance.doChoice(serviceInstances); }

JDK SPI机制以及自定义SPI类加载

Java相关栏目本月热门文章