Java SPI机制源码

2024-09-05 02:20
文章标签 java 源码 机制 spi

本文主要是介绍Java SPI机制源码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • SPI简介
    • 使用案例
    • SPI的应用
    • SPI机制源码
    • SPI与类加载器
    • 双亲委派机制

SPI简介

Java的SPI（Service Provider Interface）机制允许第三方为应用程序提供插件式的扩展，而不需要修改应用程序本身的代码，从而实现了解耦。Java标准库本身就提供了SPI机制，通常是通过在META-INF/services目录下放置文件来实现的。

在这里插入图片描述
SPI机制的核心组件包括：

  • 服务接口：这是一个Java接口，定义了服务提供者需要实现的方法，应用程序将使用这个接口与具体的服务实现进行交互。

  • 服务实现：这是实现了服务接口的具体类，第三方可以为服务接口提供多个实现。

  • 服务提供者配置文件：这是一个位于META-INF/services目录下的文件，文件名与服务接口的全限定名相同，该文件包含了服务实现类的全限定名，每行一个接口的具体实现类，在运行时就可以加载这些实现类。

  • ServiceLoader：这是Java标准库中的一个类，用于加载服务实现，应用程序可以使用ServiceLoader来获取服务接口的所有具体实现类。

SPI的工作流程如下：

  1. 定义服务接口。

  2. 实现服务接口，创建具体的服务实现类。

  3. 在META-INF/services目录下创建服务提供者配置文件，列出所有服务实现类的全限定名。

  4. 使用ServiceLoader加载服务具体实现类，并根据需要使用它们。

总结就是说SPI机制使得应用程序可以在运行时动态地选择和加载服务实现，从而提高了应用程序的可扩展性和灵活性。

使用案例

首先定义一个服务的接口

public interface Service {void execute();
}

接着创建两个两个服务实现类去实现接口，并重写接口中的方法

public class Implementation1 implements Service {@Overridepublic void execute() {System.out.println("服务实现类1");}
}// Implementation2.java
public class Implementation2 implements Service {@Overridepublic void execute() {System.out.println("服务实现类2");}
}

然后在META-INF/services目录下创建一个名为com.xydp.SPI.Service(全限定名要与接口的名称对应)的文件，用于存储服务实现类的全限定名。文件内容如下：
在这里插入图片描述

com.xydp.SPI.Implementation1
com.xydp.SPI.Implementation2

编写对应的测试类进行验证

public class SPITest {public static void main(String[] args) {ServiceLoader<Service> loader = ServiceLoader.load(Service.class);Iterator<Service> iterator = loader.iterator();while(iterator.hasNext()){System.out.println(iterator.next().getClass());}}
}

输出结果

class com.xydp.SPI.Implementation1
class com.xydp.SPI.Implementation2

SPI的应用

SPI 机制被用于加载和注册 JDBC 驱动程序，JDBC的使用方法如下
首先，导入依赖

 <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.18</version>
</dependency>
public class JDBCTest {@SneakyThrowspublic static void main(String[] args) {String url = "jdbc:mysql://localhost:3306/hmdp?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8";String username = "root";String password = "1445413748";// 1. 加载JDBC驱动(Driver的静态代码块里面会注册JDBC驱动)//	实际上这行代码是可以省略的Class.forName("com.mysql.cj.jdbc.Driver");// 2. 建立数据库连接Connection connection = DriverManager.getConnection(url, username, password);// 3. 创建Statement对象Statement statement = connection.createStatement();// 4. 执行SQL查询String sql = "SELECT * FROM test";ResultSet resultSet = statement.executeQuery(sql);// 5. 处理查询结果while (resultSet.next()) {int id = resultSet.getInt("id");String name = resultSet.getString("value");System.out.println("ID: " + id + ", value: " + name);}//6. 关闭资源connection.close();}}

运行结果
在这里插入图片描述

可以知道JDBC在加载驱动后，节省了注册驱动这一步骤，这是因为在Driver类的静态代码块中已经注册了。

static {try {//注册驱动DriverManager.registerDriver(new Driver());} catch (SQLException var1) {throw new RuntimeException("Can't register driver!");}
}

除此之外，上面代码Class.forName(“com.mysql.cj.jdbc.Driver”)与SPI机制存在关联，会显示去加载Driver类，实际上这行代码是可以省略的，不写的话，下面的DriverManager的静态代码块就会通过ServiceLoader去加载配置文件下的Driver类。
DriverManager类的静态代码块

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

静态代码块就会执行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;}AccessController.doPrivileged(new PrivilegedAction<Void>() {public Void run() {//通过SPI机制加载Driver类ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);Iterator<Driver> driversIterator = loadedDrivers.iterator();//获取对应的实现类try{while(driversIterator.hasNext()) {driversIterator.next();}} catch(Throwable t) {}return null;}});}

在不显示加载Driver类的情况下，ServiceLoader 会扫描类路径中的 META-INF/services 目录，查找 java.sql.Driver的配置文件，该配置文件中存在com.mysql.cj.jdbc.Driver这一行字符串，找到之后ServiceLoader通过反射的方式去加载Driver类。
在这里插入图片描述
对此我们可以进行验证JDBC的SPI机制，测试类如下

    public static void main(String[] args) {ServiceLoader<Driver> serviceLoader = ServiceLoader.load(Driver.class);Iterator<Driver> iterator = serviceLoader.iterator();while(iterator.hasNext()){ ;Driver driver = (Driver) iterator.next();System.out.println("驱动类的包:"+driver.getClass().getPackage()+"=======加载驱动类"+driver.getClass().getName());}}

运行结果
在这里插入图片描述由此可以得出结论JDBC确实是通过SPI机制去加载com.mysql.cj.jdbc.Driver类。

SPI机制源码

SPI主要是通过 ServiceLoader 类去解析配置文件，然后通过反射的方式创建对应的接口实现类。
ServiceLoader的主要成员

public final class ServiceLoader<S> implements Iterable<S>  
{  // 加载的默认配置文件目录private static final String PREFIX = "META-INF/services/";  // 需要被加载的 SPI 服务实现类private final Class<S> service;  // 该类加载器用于加载服务private final ClassLoader loader;  // 访问控制上下文，用于安全控制private final AccessControlContext acc;  // 按照实例化的顺序缓存服务实例private LinkedHashMap<String,S> providers = new LinkedHashMap<>();  // 懒查询迭代器private LazyIterator lookupIterator;}
  1. 调用ServiceLoader.load 方法时，会根据接口和类加载器创建懒加载迭代器。
ServiceLoader<Service> loader = ServiceLoader.load(Service.class);
//源码如下
public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader)  
{  return new ServiceLoader<>(service, loader);  
}// 构造方法重新加载SPI服务
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;// 重新加载SPI的服务reload();  
}public void reload() {// 清空服务提供者的缓存列表providers.clear();// 根据接口类型和类加载器创建懒加载迭代器，达到懒加载的目的，防止资源被浪费lookupIterator = new LazyIterator(service, loader);
}private LazyIterator(Class<S> service, ClassLoader loader) {this.service = service;this.loader = loader;
}
  1. 获取ServiceLoader 的 iterator

ServiceLoader 类的主要成员包含有LinkedHashMap实现的 providers，providers 用于用于缓存被成功加载的服务实例，key 是接口实现类的全限定名，value 是对应实现类的实例对象。

Iterator<Service> iterator = loader.iterator();
//源码如下
public Iterator<S> iterator() {//返回自定义的迭代器return new Iterator<S>() {// 创建缓存Iterator<Map.Entry<String,S>> knownProviders = providers.entrySet().iterator();public boolean hasNext() {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();}};}

3. 迭代器判断是否有数据

iterator.hasNext()
//源码如下
//判断是否还有数据
public boolean hasNext() {// 一开始缓存为空//（在调用next方法之后才会将服务对象实例放入该缓存，之后调用hasNext就会直接返回true）if (knownProviders.hasNext())return true;//一开始代码会执行到这return lookupIterator.hasNext();
}public boolean hasNext() {//acc访问控制默认为null，代码逻辑执行到这if (acc == null) {return hasNextService();} else {PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {public Boolean run() { return hasNextService(); }};return AccessController.doPrivileged(action, acc);}
}//判断是否还有服务
private boolean hasNextService() {// 判断是否还有服务实现类，有则返回trueif (nextName != null) {return true;}// 配置刚开始为空if (configs == null) {try {//配置文件目录拼接接口名称 META-INF/services + 接口名称// META-INF/services/com.xydp.SPI.ServiceString fullName = PREFIX + service.getName();//根据服务实现类的绝对路径加载配置if (loader == null)configs = ClassLoader.getSystemResources(fullName);elseconfigs = loader.getResources(fullName);} catch (IOException x) {fail(service, "Error locating configuration files", x);}}// 判断集合是否为空或者已经遍历完毕while ((pending == null) || !pending.hasNext()) {if (!configs.hasMoreElements()) {return false;}// 从配置文件解析以下的服务实现类//class com.xydp.SPI.Implementation1//class com.xydp.SPI.Implementation2pending = parse(service, configs.nextElement());}// 遍历集合的服务实现类信息//第一次返回class com.xydp.SPI.Implementation1nextName = pending.next();return true;
}
  1. 获取服务实现类的信息
System.out.println(iterator.next().getClass());
//源码如下
public S next() {// 刚开始缓存为空，所以为false1不执行if (knownProviders.hasNext())return knownProviders.next().getValue();//第一次执行到这return lookupIterator.next();
}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);}
}
//通过反射获取服务实例
private S nextService() {//此时 cn = com.xydp.SPI.Implementation1String cn = nextName;nextName = null;Class<?> c = null;// 使用反射，通过类的全限定名和类加载器得到类c = Class.forName(cn, false, loader);// 创建类的实例对象 S p = service.cast(c.newInstance());// 将实例对象放入缓存// key:com.xydp.SPI.Implementation1// value:Implementation1@28d25987providers.put(cn, p);// 返回实例对象return p;
}

SPI弊端：从源码可以知道SPI不能按需加载，需要通过 Iterator 形式遍历所有的服务实现类，无法根据参数名称来获取具体的服务实现类。

SPI与类加载器

在加载 SPI 服务时，需要指定类加载器 ClassLoader，否则无法找到具体的服务实现类，这是受限于双亲委派机制，该机制规定子类加载器可以使用父类已经加载的类，但是父类加载器无法使用子类已经加载的类。
(1) SPI 接口属于 Java 的核心库，是由顶层父类启动类加载器 BootstrapClassLoader所加载的；
(2 )SPI 的具体实现类是由系统类加载器AppClassLoader 加载的，顶层的父类启动类加载器 BootstrapClassLoader 是无法找到具体实现类的，所以需要指定类加载器 ClassLoader来加载。
主要有以下四种类加载器:

1 启动类加载器(Bootstrap ClassLoader)：启动类加载器是最顶层的类加载器，它负责加载Java核心API和核心类库。启动类加载器是由JVM实现的，不是由Java类实现的。用来加载java核心类库，无法被java程序直接引用。

2 扩展类加载器(extensions class loader):扩展类加载器是启动类加载器的子类加载器，它用来加载 Java 的扩展库。Java 虚拟机的实现会提供 一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。

3 系统类加载器（system class loader）：系统类加载器是扩展类加载器的子类加载器，加载路径主要包括应用程序的CLASSPATH环境变量指定的路径。可以通过ClassLoader.getSystemClassLoader()来获取它。

4 用户自定义类加载器，通过继承 java.lang.ClassLoader类重写findClass()方法的方式实现。

双亲委派机制

1.什么是双亲委派机制？

（1）当加载一个类时，当前类加载器先判断此类是否已经被加载，如果类已经被加载则返回；

（2）如果类没有被加载，则先委托父类加载（父类加载时会判断该类有没有被自己加载过），如果父类加载过则返回；如果没被加载过则继续向上委托；

（3）如果一直委托都无法加载，当前类加载器才会尝试自己加载。

2.双亲委派机制作用/优点

双亲委派机制是Java类加载器中的一个重要机制。它的主要作用有以下几点：

  1. 避免类的重复加载：Java中的类是由类加载器加载的，如果没有双亲委派机制，那么可能会出现多个类加载器加载同一个类的情况，造成资源的浪费。

  2. 保证Java核心API的类型安全：双亲委派机制保证了所有的Java应用都至少会使用java.* 开头的类库，而这些由系统类加载器所加载的类库在程序中有着至关重要的地位，比如java.lang.Object类，没有哪个类可以不使用Object类，所以为了防止用户自定义类篡改这些核心类。

    例如：实现了自定义的String时， 当应用程序通过系统类记载器加载核心类String时，它会首先委托给拓展类加载器，再委托给启动类加载器，启动类加载器就会加载核心String类，由于启动类加载器已经加载了正确的核心String类，所以应用程序不会加载到被篡改的String类。

3.为什么要打破双亲委派机制？

打破双亲委派机制的原因主要有以下几点：

  1. 灵活性：双亲委派机制虽然保证了类的唯一性和安全性，但也限制了Java类加载器的灵活性。有时候，我们需要自定义类加载器来实现一些特殊的功能，比如实现代码的热部署、动态加载第三方插件等。在这些场景下，打破双亲委派机制可以让我们更加灵活地控制类的加载过程。
  2. 隔离性：在某些场景下，**我们可能需要在同一个JVM中运行多个相互隔离的应用。这时候，我们可以使用自定义类加载器来实现类的隔离，从而避免类的冲突和安全问题。**打破双亲委派机制可以让我们更加灵活地控制类的加载过程，从而实现应用的隔离。
  3. 增加了类加载时间：在类加载的过程中，需要不断地查询并委托父类加载器，这意味着类加载所需要的时间可能会增加。在类数量庞大或类加载器层次比较深的情况下，这种时间延迟可能会变得更加明显。

4.如何打破双亲委派机制？

继承java.lang.ClassLoader类重写loadClass()方法来打破双亲委派机制，然后直接从自己的类路径中加载类，而不需要委托给父类加载器进行加载。

5.Tomcat是如何打破双亲委派机制的？

Tomcat是一个Java Web应用服务器，它可以运行多个Web应用。为了实现Web应用的隔离和独立部署，Tomcat使用了自定义类加载器来打破双亲委派机制。

在Tomcat中，每个Web应用都有一个对应的WebappClassLoader，它继承了java.lang.ClassLoader类。WebappClassLoader的主要作用是加载Web应用的类和资源。为了实现类的隔离，WebappClassLoader重写了loadClass方法，而不是findClass方法。在loadClass方法中，WebappClassLoader首先尝试从自己的类路径中加载类，如果找不到，再委托给父类加载器进行加载。这样，每个Web应用都可以使用自己的类加载器来加载类，从而实现了类的隔离。

6.如何自定义类加载器？

继承java.lang.ClassLoader类重写findClass()方法实现自定义类加载器。

这篇关于Java SPI机制源码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1137698。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...
Java 虚拟线程的创建与使用深度解析

Java 虚拟线程的创建与使用深度解析

《Java虚拟线程的创建与使用深度解析》虚拟线程是Java19中以预览特性形式引入,Java21起正式发布的轻量级线程,本文给大家介绍Java虚拟线程的创建与使用,感兴趣的朋友一起看看吧... 目录一、虚拟线程简介1.1 什么是虚拟线程？1.2 为什么需要虚拟线程？二、虚拟线程与平台线程对比代码对比示例：三
阅读更多...
Java中的.close()举例详解

Java中的.close()举例详解

《Java中的.close()举例详解》.close()方法只适用于通过window.open()打开的弹出窗口,对于浏览器的主窗口,如果没有得到用户允许是不能关闭的,：本文主要介绍Java中的.... 目录当你遇到以下三种情况时，一定要记得使用 .close()：用法作用举例如何判断代码中的 input
阅读更多...
Spring Gateway动态路由实现方案

Spring Gateway动态路由实现方案

《SpringGateway动态路由实现方案》本文主要介绍了SpringGateway动态路由实现方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随... 目录前沿何为路由RouteDefinitionRouteLocator工作流程动态路由实现尾巴前沿S
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2