SPI机制源码解析

news2024/11/24 0:49:03

概念

SPI(service provider interface),是JDK内置的一种服务提供发现机制。是一种动态替换发现机制,比如有个接口,想在运行时动态地给它添件实现,只需要添加一个实现。

然后在META-INF/services目录创建一个以服务接口命名的文件,这个文件里的内容就是这个接口的具体的实现类(全限定名)。

在这里插入图片描述

源码实现

  • 创建ServiceLoader

    ServiceLoader.load(Driver.class);
    
    
     public void reload() {
            providers.clear();
            lookupIterator = new LazyIterator(service, loader);
        }
    
        private ServiceLoader(Class<S> svc, ClassLoader cl) {
            service = Objects.requireNonNull(svc, "Service interface cannot be null");
            loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
            acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
            reload();
        }
    
  • 服务实现获取

在这里插入图片描述

  • 初始化LazyIterator

    public Iterator<S> iterator() {
        return new Iterator<S>() {
    				//ServiceLoader.LazyIterator的封装对象
            Iterator<Map.Entry<String,S>> knownProviders
                = providers.entrySet().iterator();
    
            public boolean hasNext() {
            //ServiceLoader已经从classPath读取过从构造参数传递进来的指定接口的子类,则会将全限定类名和对应实例缓存起来
                if (knownProviders.hasNext())
                    return true;
                return lookupIterator.hasNext();
            }
    
            public S next() {
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();
            }
    
            public void remove() {
                throw new UnsupportedOperationException();
            }
    
        };
    }
    
  • 调用layIterator的forEachRemaining方法

    default void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (hasNext())
                action.accept(next());
        }
    
    private class LazyIterator
        implements Iterator<S>
    {
        private boolean hasNextService() {
           ....
        }
    
        private S nextService() {
           ....
        }
    
        public boolean hasNext() {
            if (acc == null) {
                return hasNextService();
            } else {
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }
    
        public S next() {
            if (acc == null) {
                return nextService();
            } else {
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { return nextService(); }
                };
                return AccessController.doPrivileged(action, acc);
            }
        }
    
        public void remove() {
            throw new UnsupportedOperationException();
        }
    
    }
    
    • 调用hasNext ->hasNextService
    • next -> nextService
  • 判断是否还有服务提供

    private boolean hasNextService() {
                if (nextName != null) {
                    return true;
                }
                if (configs == null) {
                    try {
                        String fullName = PREFIX + service.getName();
                        if (loader == null)
                            configs = ClassLoader.getSystemResources(fullName);
                        else
                            configs = loader.getResources(fullName);
                    } catch (IOException x) {
                        fail(service, "Error locating configuration files", x);
                    }
                }
                while ((pending == null) || !pending.hasNext()) {
                    if (!configs.hasMoreElements()) {
                        return false;
                    }
                    pending = parse(service, configs.nextElement());
                }
                nextName = pending.next();
                return true;
            }
    
  • 加载下一个服务

    private S nextService() {
                if (!hasNextService())
                    throw new NoSuchElementException();
                //nextName是在hasNextService中赋值的
                String cn = nextName;
                nextName = null;
                Class<?> c = null;
                try {
                    c = Class.forName(cn, false, loader);
                } catch (ClassNotFoundException x) {
                    fail(service,
                         "Provider " + cn + " not found");
                }
                if (!service.isAssignableFrom(c)) {
                    fail(service,
                         "Provider " + cn  + " not a subtype");
                }
                try {
                    S p = service.cast(c.newInstance());
                    providers.put(cn, p);
                    return p;
                } catch (Throwable x) {
                    fail(service,
                         "Provider " + cn + " could not be instantiated",
                         x);
                }
                throw new Error();          // This cannot happen
            }
    
  • hasNextService() -> getResource()

    public Enumeration<URL> getResources(String name) throws IOException {
            @SuppressWarnings("unchecked")
            Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
            if (parent != null) {
           			//ExtensionClassLoader
                tmp[0] = parent.getResources(name);
            } else {
            		//BootstrapClassLoader
                tmp[0] = getBootstrapResources(name);
            }
            //加载当前类加载器
            tmp[1] = findResources(name);
    
            return new CompoundEnumeration<>(tmp);
        }
    

    这里是递归调用,需注意类加载器的层级关系 Application ClassLoader -> Extension ClassLoader -> BootStrap ClassLoader

  • findResource

    public Enumeration<URL> findResources(final String name)
            throws IOException
        {
            final Enumeration<URL> e = ucp.findResources(name, true);
    
            return new Enumeration<URL>() {
                private URL url = null;
    
                private boolean next() {
                    if (url != null) {
                        return true;
                    }
                    do {
                        URL u = AccessController.doPrivileged(
                            new PrivilegedAction<URL>() {
                                public URL run() {
                                    if (!e.hasMoreElements())
                                        return null;
                                    return e.nextElement();
                                }
                            }, acc);
                        if (u == null)
                            break;
                        url = ucp.checkURL(u);
                    } while (url == null);
                    return url != null;
                }
    
                public URL nextElement() {
                    if (!next()) {
                        throw new NoSuchElementException();
                    }
                    URL u = url;
                    url = null;
                    return u;
                }
    
                public boolean hasMoreElements() {
                    return next();
                }
            };
        }
    

    从UrlClassPath中获取Enumeration

  • UrlClassPath.findResource()

    public Enumeration<URL> findResources(final String name,
                                         final boolean check) {
            return new Enumeration<URL>() {
            		// 懒加载的方式
                private int index = 0;
                private int[] cache = getLookupCache(name);
                private URL url = null;
    
                private boolean next() {
                    if (url != null) {
                        return true;
                    } else {
                        Loader loader;
                        //遍历UrlClassPath的所有loader,直到为空,并用index记录位置,因为再次调用时要获取
                        while ((loader = getNextLoader(cache, index++)) != null) {
                        //用获取到的loader加载指定资源
                            url = loader.findResource(name, check);
                            if (url != null) {
                                return true;
                            }
                        }
                        return false;
                    }
                }
            };
        }
    
  • getLoader()

    private synchronized Loader getLoader(int index) {
            if (closed) {
                return null;
            }
            while (loaders.size() < index + 1) {
                URL url;
                synchronized (urls) {
                    if (urls.empty()) {
                        return null;
                    } else {
                        url = urls.pop();
                    }
                }
                String urlNoFragString = URLUtil.urlNoFragString(url);
                if (lmap.containsKey(urlNoFragString)) {
                    continue;
                }
                Loader loader;
                try {
                    loader = getLoader(url);
                    URL[] urls = loader.getClassPath();
                    if (urls != null) {
                        push(urls);
                    }
                } catch (IOException e) {
                    continue;
                } catch (SecurityException se) {
                    if (DEBUG) {
                        System.err.println("Failed to access " + url + ", " + se );
                    }
                    continue;
                }
                // Finally, add the Loader to the search path.
                validateLookupCache(loaders.size(), urlNoFragString);
                loaders.add(loader);
                lmap.put(urlNoFragString, loader);
            }
            if (DEBUG_LOOKUP_CACHE) {
                System.out.println("NOCACHE: Loading from : " + index );
            }
            return loaders.get(index);
        }
    

    UrlClassPath构造函数会传入待加载的url,并将其存入stack,如果处理了该url就将其抛出,所有url只会被处理一次。

    //代办为空 或 代办中没有元素开始遍历下一个类加载器获取代办
    while ((pending == null) || !pending.hasNext()) {
                    if (!configs.hasMoreElements()) {
                        return false;
                    }
                    pending = parse(service, configs.nextElement());
                }
                nextName = pending.next();
    
  • hasNextService返回True,forEachRemaining()方法中的hasNext也为True,继续遍历

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/465630.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

树莓派+摄像头:mjpg-streamer实现监控功能的配置及调试

目录 一 树莓派摄像头安装 二 配置mjpg-streamer ① 说明 ② 配置 <1> 配置前需要安装的工具包 <2> 下载安装mjpg-streamer源码到树莓 <3> 进入下载目录的路径 <4> 输入指令编译&#xff1a;make all <5> 安装指令&#xff1a;…

任务调度原理 通俗详解(FreeRTOS)

寄存器说明 以cortex-M3&#xff0c;首先先要了解比较特别的几个寄存器&#xff1a; r15 PC程序计数器&#xff08;Program Counter&#xff09;,存储下一条要执行的指令的地址。 r14 LR连接寄存器&#xff08;Link Register &#xff09;&#xff0c;保存函数返回地址&#x…

【操作系统】第一章

文章目录 &#x1f337; 一、操作系统的概念1、定义2、功能 和 目标 &#x1f337; 二、操作系统的特征1、**并发**2、 **共享**3、 **虚拟**4、 **不确定性** &#x1f337; 三、操作系统的发展与分类1、 手工操作阶段2、 批处理阶段3、 分时操作系统4、 实时操作系统5、 网络…

servlet技术

功能 对客户端发送的数据进行读取和拦截读取客户端请求的隐含数据运行结果或者生成结果发送响应的数据 Servlet技术特点 高效率 Servlet本身就是一个Java类&#xff0c;在运行的时候位于同一个Java虚拟机中&#xff0c;可以快速地响应客户 端的请求并生成结果。在Wb服务器…

停用词(stop words)+TF-IDF实现

一、什么是停用词&#xff1f; 在汉语中&#xff0c;有一类没有实际意义的词语&#xff0c;比如组词“的”&#xff0c;连词“以及”&#xff0c;副词“甚至”&#xff0c;语气词“吧”&#xff0c;被称为停用词。一个句子去掉这些停用词&#xff0c;并不影响理解。所以&#…

资产管理系统

目录 1、资产管理模块 资产入库 ​编辑 闲置资产分配 资产调配 资产回收 资产报废 车辆维修 2、资产设置模块 资产标准规格 资产分类 3、资产报表模块 全部资产报表 已分配资产报表 资产分类报表 到期资产报表 机构资产报表 资产折旧报表 机构分类报表 资产…

〖ChatGPT实践指南 - 零基础扫盲篇⑤〗- OpenAI API 演示 Demo 之宠物名字生成器

文章目录 ⭐ 运行 Demo应用 - 宠物名字生成器&#x1f31f; 安装 - node.js&#x1f31f; 利用 git 下载 Demo应用 - 宠物名字成器&#x1f31f; 添加 API 秘钥&#x1f31f; 安装依赖并运行Demo应用 - 宠物名字成器 ⭐ 访问并测试 Demo应用 - 宠物名字成器 在上一章节&#xf…

最新版TensorFlow的GPU版本不支持原生Windows系统(大坑预警)

一、前言 首先需要说明&#xff0c;按照官方中文文档安装是无法正常检测到GPU的。因为TensorFlow 2.10是支持原生Windows系统GPU环境的最后版本&#xff0c;默认安装的版本都比较高。 中文文档没有说明&#xff0c;英文文档是有提到的&#xff1a; &#xff08;我在GitHub上找…

PostgreSQL-布尔类型

布尔类型 boolean的值要么是true&#xff0c;要么是false&#xff0c;如果是unknown状态&#xff0c;用NULL表示。 boolean在SQL中可以用不带引号的TRUE或FALSE表示&#xff0c;也可以用其他表示“真”和“假”的带引号字符表示&#xff0c;如true、false、yes、no等等。 cr…

操作系统之进程同步和互斥

目录 什么是进程同步和进程互斥 进程互斥的软件实现方法 进程互斥的硬件实现方法 互斥锁 信号量机制 用信号量实现进程互斥和同步 生产者消费者问题 多生产者多消费者问题 吸烟者问题 读者写者问题 哲学家进餐问题 管程 死锁 什么是进程同步和进程互斥 进程同步 进…

【Golang开发入门】一篇文章弄懂:值类型、指针类型

博主简介&#xff1a;努力学习的大一在校计算机专业学生&#xff0c;热爱学习和创作。目前在学习和分享&#xff1a;数据结构、Go&#xff0c;Java等相关知识。博主主页&#xff1a; 是瑶瑶子啦所属专栏: Go语言核心编程近期目标&#xff1a;写好专栏的每一篇文章 目录 一、前言…

【数据分析之道-Pandas(二)】DataFrame

文章目录 专栏导读1、DataFrame简介2、DataFrame创建2.1字典创建DataFrame2.2列表创建DataFrame2.3ndarrays 创建DataFrame2.4CSV文件创建DataFrame 3、DataFrame基本操作3.1添加列3.2删除列 专栏导读 ✍ 作者简介&#xff1a;i阿极&#xff0c;CSDN Python领域新星创作者&…

什么是 TDSQL-C MySQL版 ---- 数据库开发者视角

我们从设计演化的角度来讲什么是 TDSQL-C MySQL 版本。 首先&#xff0c;我们有了一个纯净版 MySQL。它是一个单机数据库。存算分离&#xff1a;然后&#xff0c;我们把 MySQL 的存储引擎拿掉&#xff0c;换成云存储。这就成了存算分离。这时&#xff0c;在用户看来它还是一个…

测牛学堂:2023软件测试入门系列(软件测试方法之流程分析法)

流程分析法 流程就是用户为了完成一定的业务目的&#xff0c;需要进行的一系列的操作。 流程分析法又叫场景分析法&#xff0c;是编写测试用例最常用的方法之一。 流程分析法不校验单个功能点的正确性&#xff0c;只关心流程能不能走通。 流程分类的几个概念 场景&#xff1…

Arduno ESP8266接入中移OneNet动态显示实时数据

Arduno ESP8266接入中移OneNet动态显示实时上传数据 ✨本案例基于HTTP协议. 🌼网页查看动态数据: 📓Onenet产品创建 从全部产品服务点击进入-多协议接入 2.创建基于HTTP协议的产品 添加产品属性 创建产品成功后,可以开始添加具体的设备了。

本周一至周三总结

周一 学习如何进行竞品分析 对软件杯项目进行了竞品分析&#xff0c;测试了十余个强相关网站&#xff0c;为团队写好了竞品分析报告 分别对主要目标&#xff0c;竞品优劣点&#xff0c;竞品选择原因&#xff0c;产品创新点等进行了分析和阐述 周二 下午晚上刷了五道题 题解…

不是什么高深玩意,Arrays.asList、ArrayList.subList需要注意的坑

前言 集合是日常工作中几乎每天都在用的玩意&#xff0c;也是八股文中被翻烂的东西&#xff0c;诸如List、Map&#xff0c;确实很重要也很实用&#xff0c;但是不注意细节就比较容易踩坑。比较常见的就是今天要整理的Arrays.asList和ArrayList.subList。不是什么高深的东西&…

第一章设计模式前置知识

文章目录 软件设计模式的概念学习设计模式的必要性设计模式分类UML图类的表述方式类的表示方式 类与类之间的表示方式关联关系聚合关系组合关系依赖关系继承关系实现关系 软件设计原则开闭原则实例 里氏代换原则反例优化 依赖倒转原则组装电脑改进反例 接口隔离原则安全门案例 …

1分钟学会Midjourney十种绘图风格关键词

Midjourney最新V5版的卡通模型中最流行的就是皮克斯&#xff0c;今天介绍十种绘图风格。我们统一用如下描述词来绘制&#xff0c;每次只是风格不一样&#xff0c;对比看看。 首先我们先画一个皮克斯风格(Pixar)&#xff0c;打开ai绘图软件&#xff0c;点击左上角的图像绘制&a…

centos主机测磁盘读写速度极限

下面将使用dd命令在CentOS主机上测试磁盘的极限速度 先测试磁盘的极限写入速度 dd if/dev/zero of/tmp/testfile bs1M count3072 convfdatasync,notrunc statusprogress 该命令将在/tmp目录下创建一个名为testfile的文件&#xff0c;并向其中写入3GB的数据 if/dev/zero&#x…