20200510 深入理解SPI机制

最新推荐文章于 2024-10-13 19:42:33 发布
最新推荐文章于 2024-10-13 19:42:33 发布
阅读量229 收藏
点赞数
分类专栏： 曼哈顿计划 文章标签： SPI DUBBO
原文链接：https://www.jianshu.com/p/3a3edbcd8f24
版权

一、什么是SPI

SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。

这一机制为很多框架扩展提供了可能，比如在Dubbo、JDBC中都使用到了SPI机制。我们先通过一个很简单的例子来看下它是怎么用的。

1、小栗子

首先，我们需要定义一个接口，SPIService

 

package com.viewscenes.netsupervisor.spi;
public interface SPIService {
    void execute();
}

然后，定义两个实现类，没别的意思，只输入一句话。

 

package com.viewscenes.netsupervisor.spi;
public class SpiImpl1 implements SPIService{
    public void execute() {
        System.out.println("SpiImpl1.execute()");
    }
}
----------------------我是乖巧的分割线----------------------
package com.viewscenes.netsupervisor.spi;
public class SpiImpl2 implements SPIService{
    public void execute() {
        System.out.println("SpiImpl2.execute()");
    }
}

最后呢，要在ClassPath路径下配置添加一个文件。文件名字是接口的全限定类名，内容是实现类的全限定类名，多个实现类用换行符分隔。
文件路径如下：

 

SPI配置文件位置

 

内容就是实现类的全限定类名：

 

com.viewscenes.netsupervisor.spi.SpiImpl1
com.viewscenes.netsupervisor.spi.SpiImpl2

2、测试

然后我们就可以通过ServiceLoader.load或者Service.providers方法拿到实现类的实例。其中，Service.providers包位于sun.misc.Service，而ServiceLoader.load包位于java.util.ServiceLoader。

 

public class Test {
    public static void main(String[] args) {    
        Iterator<SPIService> providers = Service.providers(SPIService.class);
        ServiceLoader<SPIService> load = ServiceLoader.load(SPIService.class);

        while(providers.hasNext()) {
            SPIService ser = providers.next();
            ser.execute();
        }
        System.out.println("--------------------------------");
        Iterator<SPIService> iterator = load.iterator();
        while(iterator.hasNext()) {
            SPIService ser = iterator.next();
            ser.execute();
        }
    }
}

两种方式的输出结果是一致的：

 

SpiImpl1.execute()
SpiImpl2.execute()
--------------------------------
SpiImpl1.execute()
SpiImpl2.execute()

二、源码分析

我们看到一个位于sun.misc包，一个位于java.util包，sun包下的源码看不到。我们就以ServiceLoader.load为例，通过源码看看它里面到底怎么做的。

1、ServiceLoader

首先，我们先来了解下ServiceLoader，看看它的类结构。

 

public final class ServiceLoader<S> implements Iterable<S>
    //配置文件的路径
    private static final String PREFIX = "META-INF/services/";
    //加载的服务类或接口
    private final Class<S> service;
    //已加载的服务类集合
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    //类加载器
    private final ClassLoader loader;
    //内部类，真正加载服务类
    private LazyIterator lookupIterator;
}

2、Load

load方法创建了一些属性，重要的是实例化了内部类，LazyIterator。最后返回ServiceLoader的实例。

 

public final class ServiceLoader<S> implements Iterable<S>
    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;
        //先清空
        providers.clear();
        //实例化内部类 
        LazyIterator lookupIterator = new LazyIterator(service, loader);
    }
}

3、查找实现类

查找实现类和创建实现类的过程，都在LazyIterator完成。当我们调用iterator.hasNext和iterator.next方法的时候，实际上调用的都是LazyIterator的相应方法。

 

public Iterator<S> iterator() {
    return new Iterator<S>() {
        public boolean hasNext() {
            return lookupIterator.hasNext();
        }
        public S next() {
            return lookupIterator.next();
        }
        .......
    };
}

所以，我们重点关注lookupIterator.hasNext()方法，它最终会调用到hasNextService。

 

private class LazyIterator implements Iterator<S>{
    Class<S> service;
    ClassLoader loader;
    Enumeration<URL> configs = null;
    Iterator<String> pending = null;
    String nextName = null; 
    private boolean hasNextService() {
        //第二次调用的时候，已经解析完成了，直接返回
        if (nextName != null) {
            return true;
        }
        if (configs == null) {
            //META-INF/services/ 加上接口的全限定类名，就是文件服务类的文件
            //META-INF/services/com.viewscenes.netsupervisor.spi.SPIService
            String fullName = PREFIX + service.getName();
            //将文件路径转成URL对象
            configs = loader.getResources(fullName);
        }
        while ((pending == null) || !pending.hasNext()) {
            //解析URL文件对象，读取内容，最后返回
            pending = parse(service, configs.nextElement());
        }
        //拿到第一个实现类的类名
        nextName = pending.next();
        return true;
    }
}

4、创建实例

当然，调用next方法的时候，实际调用到的是，lookupIterator.nextService。它通过反射的方式，创建实现类的实例并返回。

 

private class LazyIterator implements Iterator<S>{
    private S nextService() {
        //全限定类名
        String cn = nextName;
        nextName = null;
        //创建类的Class对象
        Class<?> c = Class.forName(cn, false, loader);
        //通过newInstance实例化
        S p = service.cast(c.newInstance());
        //放入集合，返回实例
        providers.put(cn, p);
        return p; 
    }
}

看到这儿，我想已经很清楚了。获取到类的实例，我们自然就可以对它为所欲为了！

三、JDBC中的应用

我们开头说，SPI机制为很多框架的扩展提供了可能，其实JDBC就应用到了这一机制。回忆一下JDBC获取数据库连接的过程。在早期版本中，需要先设置数据库驱动的连接，再通过DriverManager.getConnection获取一个Connection。

 

String url = "jdbc:mysql:///consult?serverTimezone=UTC";
String user = "root";
String password = "root";

Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, user, password);

在较新版本中(具体哪个版本，笔者没有验证)，设置数据库驱动连接，这一步骤就不再需要，那么它是怎么分辨是哪种数据库的呢？答案就在SPI。

1、加载

我们把目光回到DriverManager类，它在静态代码块里面做了一件比较重要的事。很明显，它已经通过SPI机制， 把数据库驱动连接初始化了。

 

public class DriverManager {
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
}

具体过程还得看loadInitialDrivers，它在里面查找的是Driver接口的服务类，所以它的文件路径就是：META-INF/services/java.sql.Driver。

 

public class DriverManager {
    private static void loadInitialDrivers() {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                //很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
                //所以它要找的就是META-INF/services/java.sql.Driver文件
                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;
            }
        });
    }
}

那么，这个文件哪里有呢？我们来看MySQL的jar包，就是这个文件，文件内容为：com.mysql.cj.jdbc.Driver。

MySQL SPI文件

 

2、创建实例

上一步已经找到了MySQL中的com.mysql.cj.jdbc.Driver全限定类名，当调用next方法时，就会创建这个类的实例。它就完成了一件事，向DriverManager注册自身的实例。

 

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            //注册
            //调用DriverManager类的注册方法
            //往registeredDrivers集合中加入实例
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

3、创建Connection

在DriverManager.getConnection()方法就是创建连接的地方，它通过循环已注册的数据库驱动程序，调用其connect方法，获取连接并返回。

 

private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {   
    //registeredDrivers中就包含com.mysql.cj.jdbc.Driver实例
    for(DriverInfo aDriver : registeredDrivers) {
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                //调用connect方法创建连接
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    return (con);
                }
            }catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }
        } else {
            println("    skipping: " + aDriver.getClass().getName());
        }
    }
}

4、再扩展

既然我们知道JDBC是这样创建数据库连接的，我们能不能再扩展一下呢？如果我们自己也创建一个java.sql.Driver文件，自定义实现类MyDriver，那么，在获取连接的前后就可以动态修改一些信息。

还是先在项目ClassPath下创建文件，文件内容为自定义驱动类com.viewscenes.netsupervisor.spi.MyDriver

自定义数据库驱动程序

我们的MyDriver实现类，继承自MySQL中的NonRegisteringDriver，还要实现java.sql.Driver接口。这样，在调用connect方法的时候，就会调用到此类，但实际创建的过程还靠MySQL完成。

 

package com.viewscenes.netsupervisor.spi

public class MyDriver extends NonRegisteringDriver implements Driver{
    static {
        try {
            java.sql.DriverManager.registerDriver(new MyDriver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public MyDriver()throws SQLException {}
    
    public Connection connect(String url, Properties info) throws SQLException {
        System.out.println("准备创建数据库连接.url:"+url);
        System.out.println("JDBC配置信息："+info);
        info.setProperty("user", "root");
        Connection connection =  super.connect(url, info);
        System.out.println("数据库连接创建完成!"+connection.toString());
        return connection;
    }
}
--------------------输出结果---------------------
准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
JDBC配置信息：{user=root, password=root}
数据库连接创建完成!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f

 

hhcccchh
关注
专栏目录
STM32 SPI发送波形
三思的博客
03-02 8233
STM32 SPI发送波形 文章目录STM32 SPI发送波形前言一、SPI的四种波形二、连续和不连续传输1.连续传输2.不连续传输三、实测波形总结 前言 本文主要内容为STM32 的SPI发送波形，不涉及相关软件配置，相关内容网络上一搜就有很多参考。 一、SPI的四种波形 根据SPI协议，STM32发送的波形有四种可能，如图所示，主要分为两种时钟相位（CPHA）和时钟极性（CPOL）。 关于时钟极性，也有很多人把它理解为第一个边沿，第二个边沿：也有人觉得CPHA=0时，时钟是从第一个边沿启动，这
(转)SPI常见传输错误解答
热门推荐
lanxinyuchs的专栏
11-13 1万+
http://www.dzsc.com/data/html/2011-3-25/89304.html   1. SPR设定错误 　　在从器件时钟频率小于主器件时钟频率时，如果SCK的速率设得太快，将导致接收到的数据不正确（SPI接口本身难以判断收到的数据是否正确，要在软件中处理）。 　　整个系统的速度受三个因素影响：主器件时钟CLK主、从器件时钟CLK从和同步串行时钟SCK，其中SCK...
【api、spi机制还傻傻分不清吗】
weixin_44585177的博客
09-14 1128
API,SPI
SPI理解和实现
zpflwy1314的博客
12-23 428
SPI简单使用
PostgreSQL 的 SPI_接口函数
PostgreSQL China
08-12 512
这个SPI_比较便利的一点在于，我们可以在自定义的Extension中也可以使用它，去用C调用SQL执行，也就是说，如果我们想的话，我们可以在Extension里用C语言定义一个函数，在函数里拼接出我们想要执行的SQL，并调用SPI_的相关接口函数，在数据库里实际执行该SQL。关键的部分如下，通过逻辑，其实可以看出来，我这里做了一个巨鸡肋的功能———通过函数输入一个表名和一个路径文件，函数拼接了一个COPY的SQL来实现copy to拷贝表的功能，但是为了演示SPI_的接口函数已经足够了。...
SPI机制
最新发布
Leighteen
10-13 879
SPI（Service Provider Interface）机制是一种服务发现机制，广泛用于Java生态中。它允许框架或库通过接口解耦具体实现，用户可以在运行时动态地提供接口的实现，而不是在编译时确定。这种机制在很多场景下非常有用，比如数据库驱动、日志框架、解析库等。接口定义SPI机制为Java生态中的扩展和插件提供了标准的方式，尤其是在跨多个库或框架中非常有用。通过和的配置，Java程序可以在运行时动态加载实现类，从而实现高扩展性和解耦。
Java-深入理解ServiceLoader类与SPI机制
li_xunhuan的博客
11-11 982
Java-ServiceLoader类与SPI机制 引子 对于Java中的Service类和SPI机制的透彻理解，也算是对Java类加载模型的掌握的不错的一个反映。 了解一个不太熟悉的类，那么从使用案例出发，读懂源代码以及代码内部执行逻辑是一个不错的学习方式。 一、使用案例 通常情况下，使用ServiceLoader来实现SPI机制。 SPI 全称为 (Service Provider Inte...
Java：深入理解ServiceLoader类与SPI机制
Jeffery的博客
05-13 1227
Java：深入理解ServiceLoader类与SPI机制一、SPI接口介绍1.1 SPI与API区别1.2 应用场景二、Demo展示三、源码分析四、总结 一、SPI接口介绍 SPI（Service Provider Interface），是JDK内置的一种 服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用，比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和PostgreSQL都有不同的实现提供给用户，而Java的SPI机制可以为某
Java类加载及SPI机制.pdf
06-27
Java类加载机制和SPI（ServiceProviderInterface）机制是Java平台中极其重要的两个概念，它们对于Java...在实际开发过程中，深入理解和正确使用这两个机制，对于提升软件的灵活性、可维护性以及可扩展性具有重要意义。
spi协议spi协议spi协议
11-22
SPI（Serial Peripheral Interface）协议是一种广泛应用的串行通信协议，由Motorola公司首先在其MC68HCXX系列处理器中定义。...理解和掌握SPI协议的原理和操作方法，对于进行相关硬件设计和软件开发至关重要。
Java SPI深入理解与自定义扩展SPI
zhangxing
06-06 678
SPI（service provider interface）即服务提供者接口，通俗来讲，提供方只需要给定接口的命名，入参及返回类型，具体的实现可以支持默认实现或让被调用方自己实现。SPI机制是JDK内置的一种服务发现，将服务接口与服务实现分离以达到解耦、大大提升了程序可扩展性的机制。引入服务提供者就是引入了SPI接口的实现者，通过本地的注册发现获取到具体的实现类，轻松可插拔SPI实现了动态加载和插件化。.........
Java SPI在数据库驱动、SpringBoot自动装配中的应用
心流时间的博客
01-13 1113
JAVA SPI在数据库驱动、SpringBoot自动装配中的应用
关于spi在数据库连接时的作用,jdbc连接数据库原理分析
qq_42231355的博客
10-29 433
java提供访问数据库的接口，如果不这么做，那么需要开发者针对不同的数据库去实现每个数据库厂商不同的接口来去连接，类似于redis的client，那么不同的数据库都有一套自己的client，这样增加了开发人员的工作量。 这样的话相当麻烦，于是java提供jdbc接口，然后所有厂商只需要实现这个接口，使用jdbc连接即可，这样的话，就不需要开发人员针对每个数据库去实现各自的连接方式 tr...
SPI机制介绍
学习空间
03-06 572
SPI机制介绍 SPI机制介绍 概述 实现说明 实现举例 概述 SPI即Service Provider Interface(服务提供者接口)，与我们常用的API(Application Programming Inteface)概念不同： SPI是面向服务提供者的，用于描述服务提供者如何扩展才能在符合服务要求的情况下提供具体的服务实现。一般用于基于某个标准接口/服务...
SPI机制的一次具体使用
jamesgan's blogs
08-10 929
对spi机制的使用在一次对schemacrawler（一个数据库元数据爬虫框架）的使用中提升了很多。 基础了解：http://blog.csdn.net/qq_33793432/article/details/73112302具体的使用： 我使用spi机制来调用不同数据库实现的分页方法。通过一个数据库类型来查找对应的实现类。 对外的接口或抽象类A 你可以在A中定义实现
PostgreSQL内核开发——使用SPI创建C函数
Focus on PostgreSQL
06-06 2263
说明： 服务器编程接口(SPI)给予用户定义C函数编写者在其函数内运行SQL命令的能力。SPI是一组接口函数，它们可以简化对解析器、规划器和执行器的访问。SPI也做一些内存管理。我们可以使用这些SPI来编写C函数来实现运行SQL的功能。 例子： 1、首先，我们在数据库中创建测试表并插入数据 bill=# create table test(id int,info text,crt_time timestamp); CREATE TABLE bill=# insert into test select gen
JDBC SPI加载机制
风泊月
09-14 970
测试时偶然发现即使不加载驱动 也是可以成功获取数据库连接的 @Test public void test3() throws Exception { //Class.forName("com.mysql.jdbc.Driver"); String userName = "root"; String passWord = "root"; String url = "jdbc:mysql://localhost:3306/test";
SPI详解
bianjianhui126的专栏
09-15 3848
<br />AD7888与S3C2410的SPI接口及Linux下嵌入式驱动的实现<br /> http://tech.ddvip.com   2008年07月07日    社区交流<br />   关键字： 视频监控系统 EJTAG调试 热水器 超声探伤仪 NGN业务安全 继电保护软件 <br />内容摘要：带有SPI接口的串行A/D转换器和ARM微处理器的结合可广泛应用于实现数据采集功能的掌上设备及其他嵌入式的系统，如：医疗仪器、通信设备、抄表设备等领域。 <br />       　　串行外围设备接口
Java SPI机制
风轻云淡
02-26 231
前言 虽然我自己在前段时间再总结一些Java知识，但是经过最近的面试发现，很多自己掌握的并不牢靠，所以决定把原来很多内容拆分出来一部分一部分自己写，这篇主要在梳理一遍Java的SPI 机制吧。温故而知新，可以为师矣。 介绍 Java SPI 全程为 Service Provider Interface，直译过来就是 服务提供商接口。我理解的概念的话就是，由JDK语言开发组制定一系列功能接口，...
深入理解SPI接口协议及其PDF文件
对于希望实现或理解SPI通信的工程师来说，这些文档是宝贵的资源。文档通常会详细介绍如何正确地初始化和配置SPI接口，包括设置正确的时钟速率、数据位宽、时钟极性和相位以及如何管理多个从设备的片选信号。此外，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值