文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

JDKSPI机制以及自定义SPI类加载问题

2022-11-21 22:51

关注

概述

介绍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启动类加载器会尝试去加载MySqljar包,但明显是找不到的,因为它根本不在JDK

那我们不妨看一下DriverManager的源码:

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

private static void loadInitialDrivers() {
    String drivers;
    try {
        drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });
    } catch (Exception ex) {
        drivers = null;
    }
	// 1
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {            ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
            Iterator<Driver> 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 <S> ServiceLoader<S> load(Class<S> service) {
    //获取到了线程上下文类加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

线程上下文类加载器是当前线程使用的类加载器,默认就是应用程序类加载器,那么这个方法中的load方法就会使用刚才拿到的线程上下文类加载器去加载目标实现类,不过这个方法比较深,真正加载的具体代码在 ServiceLoader 的内部类 LazyIteratornextService方法中:

自定义实现

注解

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<T> {
    
    private static final String SERVICE_DIRECTORY = "META-INF/extensions/";    
    private final Class<?> type;    
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> 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<T> clazz = loadExtensionFile();
        if (clazz == null) {
            return null;
        }
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException("实例化失败 : " + clazz);
        }
    }    
    private Class<T> loadExtensionFile() {
        //想要获取谁的实现类
        String fileName = ExtensionLoader.SERVICE_DIRECTORY + type.getName();
        try {
            Enumeration<URL> 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<T> 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<T>) classLoader.loadClass(line.trim());
            }
        } catch (IOException | ClassNotFoundException e) {
            log.error(e.getMessage());
            return null;
        }
        return null;
    }
}

测试

参考如下方式:

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


public InetSocketAddress doChoice(List<InetSocketAddress> 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);
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持编程网。

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯