Java SPI与Spring SPI全面解析（源码级别讲解）

已于 2024-01-22 11:31:09 修改
阅读量1.7k 收藏 27
点赞数 23
文章标签： java spring
于 2024-01-01 22:29:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43599126/article/details/135329933
版权

文章目录

Java SPI with Spring SPI

Java SPI

什么是SPI？

SPI全称（Service Provider Interface）即 服务提供者接口，它是JDK内置的一种服务提供发现机制，这样说可能比较抽象，下面我们来举个例子来类比一下：

Spring项目中，我们写service层的时候都会约定俗成的有一个接口来定义规范，然后通过spring中的依赖注入，可以使用@Autowired等方式注入这个接口实现类的实例对象，之后的调用操作都是对基于这个接口调用。

简单来说就是这样的：

image-20230419004512529

如图所示，接口、实现类都是由服务提供方提供，我们可以把controller看作是服务调用方，调用方只关心接口的调用就好了。

在上面这个例子里，service层和其中的方法我们都可以称之为API，而我们要讨论的SPI和它相比，有类似也有差异，看以下图：

image-20230419124544277

简单来说，就是定义一个接口规范，可以由不同的服务提供者实现，并且，调用方可以通过某种机制来发现服务提供方，并通过这个接口调用它的能力。

通过对比，我们可以看出它们虽然都有着接口这一层面，但还是有很大不同。

API中的接口只是给我们调用方提供一个功能列表，调用方直接调用就完事了，而SPI是定义一个接口规范，提供给服务方实现，然后调用方可以通过某种机制发现服务提供者。

说白了就是我给你接口规范，你只要按照我的规范去实现，我就能通过某种机制发现服务提供者，并且通过这个接口调用它的能力。

SPI有什么用？有什么好处？

简单来说，就是我们定义一个标准接口，让第三方平台去实现这个接口，调用者可以根据配置来动态加载不同的第三方库，实现动态扩展功能。例如： 实现我这个接口的厂商有A、B、C，那么我就可以根据配置来加载其中一个库。

好处就是解耦、可插拔、面向接口编程、动态类加载、扩展性强。

如果这么说还是有点抽象，那么就看下面的案例

定义接口

在这个案例里我们就以智能电风扇为例，一般智能电风扇的核心功能有： 开关、摆头、定时、调节档次。

假设我们有A、B、C三个不同型号的智能电风扇，但是我们的主要功能是一样的，设想一下，如果不同型号的智能电风扇各写各的接口，那么对接起来是不是很麻烦。

那么怎么解决呢？很简单，这个时候就用到了我们的SPI，我先定义一套接口规范，你按照我的接口规范实现，我就能通过某种服务发现机制找到你，使用这种方式的话，后续还有其他型号生产，只要按照这套规范实现，我都能找到。

废话不多说，上代码

新建一个项目，名为fan-spi-demo

image-20230421161445292

接下来新建一个接口，定义接口规范

package com.hmg.spi.service;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-21 16:16
 * @description: fan core service
 */
public interface IFanCoreService {
    /**
     * 获取风扇类型
     * @return 类型
     */
    String getType();

    /**
     * 开关
     */
    void turnOnOff();

    /**
     * 调节风速
     */
    void adjustSpeed();

    /**
     * 摆头
     */
    void frontSway();

    /**
     * 定时
     */
    void timer();
}

这个接口定义好了，后面要给服务提供者实现，用maven把它打成jar包，方便给服务提供者引入

//使用这条命令打包
mvn clean install

打完包之后服务提供者就可以引入了

服务提供者实现

A模块

新建一个服务提供者A 模块，名为fanA-type-provider

image-20230421164105223

引入标准接口jar包

   <dependencies>
        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fan-spi-demo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

创建服务实现类

package com.hmg.spi.service.impl;

import com.hmg.spi.service.IFanCoreService;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-21 16:44
 * @description: A型号风扇实现类
 */
public class AaTypeFanServiceImpl implements IFanCoreService {
    @Override
    public String getType() {
        return "A";
    }

    @Override
    public void turnOnOff() {
        System.out.println("A型号风扇开关");
    }

    @Override
    public void adjustSpeed() {
        System.out.println("A型号风扇调节风速");
    }

    @Override
    public void frontSway() {
        System.out.println("A型风扇摆头");
    }

    @Override
    public void timer() {
        System.out.println("A型风扇定时");
    }
}

在项目的resources目录下创建META-INF/services目录，然后以接口全限定名创建文件，并在文件中写入实现类的全限定类名

image-20230421165631874

这样我们就完成了一个服务提供者的实现，用maven打成jar包，就可以提供给调用方使用了

mvn clean install
B模块

接下来创建服务提供者B模块，和A模块同理

  1. 新建B模块

​ image-20230421173056351

  1. 在pom.xml中引入标准接口jar包

    <dependencies>
        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fan-spi-demo</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

  2. 创建接口实现类

    package com.hmg.spi.service.impl;

import com.hmg.spi.service.IFanCoreService;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-21 17:36
 * @description:  B型号风扇实现类
 */
public class BbTypeFanServiceImpl implements IFanCoreService {
    @Override
    public String getType() {
        return "B";
    }

    @Override
    public void turnOnOff() {
        System.out.println("B型号风扇开关");
    }

    @Override
    public void adjustSpeed() {
        System.out.println("B型号风扇调节风速");
    }

    @Override
    public void frontSway() {
        System.out.println("B型风扇摆头");
    }

    @Override
    public void timer() {
        System.out.println("B型风扇定时");
    }
}

  3. 在resources目录下创建META-INF/services目录，新建一个普通文件，以接口全限定名作为文件名，文件内容就是实现类的全限定类名

    image-20230421174241033

  4. 使用maven打成jar包，提供给调用方使用

mvn clean install
C模块

C模块同理，一样的操作，这里就不再演示了。

服务发现

现在三个服务提供者都实现了接口，下一步就是最关键的服务发现了，不过这一步java中的spi发现机制已经帮我们实现好了。

  1. 新建项目fan-app

    image-20230421233728466

  2. 引入那三个服务提供者jar包

    <dependencies>
    <dependency>
    <groupId>com.hmg.spi</groupId>
    <artifactId>fanA-type-provider</artifactId>
    <version>1.0-SNAPSHOT</version>
    </dependency>

    <dependency>
    <groupId>com.hmg.spi</groupId>
    <artifactId>fanB-type-provider</artifactId>
    <version>1.0-SNAPSHOT</version>
    </dependency>

    <dependency>
    <groupId>com.hmg.spi</groupId>
    <artifactId>fanC-type-provider</artifactId>
    <version>1.0-SNAPSHOT</version>
    </dependency>
 </dependencies>

  3. 编写主程序代码

    按照之前的说法，虽然每个服务提供者都对接口做了实现，但是调用者无需关心具体实现类，我们要做的是通过接口来调用服务提供者实现的方法。

    下面就是关键的服务发现环节，我们编写一个方法，根据型号去调用智能电风扇的开关方法

    package com.hmg.spi;

import com.hmg.spi.service.IFanCoreService;

import java.util.ServiceLoader;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-21 23:37
 * @description: 调用者测试
 */
public class Main {
    /**
     * A型号的风扇
     */
    private final static String A_TYPE = "A";

    public static void main(String[] args) {
        new Main().turnOn(A_TYPE);
    }

    private void turnOn(String type){
        //通过ServiceLoader类的load方法去发现服务提供者并加载
        ServiceLoader<IFanCoreService> fanCoreServices = ServiceLoader.load(IFanCoreService.class);
        fanCoreServices.forEach(fanCoreService -> {
            System.out.println("检测到的类名：" + fanCoreService.getClass().getSimpleName());
            //判断是否是A型号的风扇，是的话直接开启
            if (type.equals(fanCoreService.getType())) {
                fanCoreService.turnOnOff();
            }
        });
    }
}

  4. 测试结果

    image-20230422000649041

ServiceLoader原理

ServiceLoader.load()

  1. ServiceLoader.load()方法

    load()方法帮我们干了什么事呢？他其实就干了一件事，把接口.class和多线程上下文保存到LazyIterator（懒加载迭代器），我怎么知道的？当然是看源码，请看以下图：

    image-20230422134946615

​ 有读者可能会有疑问，线程的上下文类加载器是用来干嘛的？先别急，后面会说到，继续往下走，看源码：

新创建一个ServiceLoader对象，把服务和类加载器都传进去

image-20230422135409724

image-20230422141422168

image-20230422140618171

对于providers和lookupIterator属性，有些读者可能在这里会有疑问，这两个是什么？看图：

image-20230422141722457

从上面创建新的懒加载迭代器点进来看实现，对传进来的参数进行赋值

image-20230422143446258

到目前为止，load()方法就结束了，所以load方法干了什么事应该都有了大致了解。

接下来就是整个ServiceLoader的核心了， 当我们遍历ServiceLoader.load()方法得到的结果后，发现它会调用iterator()方法，为什么？当然是因为ServiceLoader实现了Iterable这个接口，细心的同学应该早就发现了，而整个服务发现的核心就在iterator()这个方法里，接下来让我们一探究竟。

iterator()
hasNext()

image-20230422153625775

lookupIterator.hasNext()

里面的acc是访问控制上下文，ServiceLoader创建的时候用的，前面判断的时候为空，所以这里直接看hasNextService()就好了

image-20230422153946854

hasNextService()

image-20230422155945822

路径前缀，所以这也就是为什么要在resources下创建META-INF/services目录了

image-20230422210540821

parse()

image-20230422161930565

parseLine()

image-20230422162341592

next()

image-20230422200114370

lookupIterator.next()

image-20230422200457152

nextService()

image-20230422203709368

至此，ServiceLoader的整个执行流程源码我们就看完了，在迭代器的迭代过程中，会完成所有实现类的实例化，其实归根结底，还是基于 java 反射去实现的。

小总结

大概的核心流程就是先通过ServiceLoader.load方法清空缓存，并且创建懒加载迭代器，把class对象和类加载器先装到懒加载迭代器，做好真正加载的工作，然后遍历load得到的结果，就来到了iterator()方法，进来就先获取缓存，然后来到hasNext()方法（这个方法主要用于判断缓存中是否有值，如果有直接返回true，没有的话就使用lookupIterator调用hasNext方法，hasNext方法里又调用hasNextService方法获取实现类全限定类名，放到nextName中，然后返回true），判断是否有下一个值完了之后，就到了next()方法，进来也是先判断缓存里是否有值，有的话直接返回，没有就使用lookupIterator调用next方法，next方法中调用nextService()方法（这个方法主要是通过Class.forName加载Class对象，然后通过Class对象的newIntstance()方法实例化实现类对象，最后再放到缓存里（全限定类名作为key，实例化后的实现类对象作为value，大概就是这样了，如果到这还是看不太懂的话，那就多debug看几遍就会了。

应用场景

SPI应用场景有很多，比如： Spring、Common-Logging、JDBC、Dubbo、可插拔架构、框架开发等等

总结

Java中的SPI机制整体上来说还是很不错的，通过接口灵活的将服务调用者与服务提供者分离，提供给第三方实现扩展时还是很方便的，不过它也有缺点，比如不能按需加载，只能一次性全部加载进来，如果加载到某些不需要的实现类，那就会造成资源浪费，还有每一个标准接口都需要创建一个新的文件来存放具体实现类，这是非常不方便的，最后ServiceLoader多线程使用是不安全的，不过整体上来说还是很不错的，提供了一种非常不错的思想。

Spring SPI

简介

看了上面的Java SPI，相信大家对SPI都有大概的认识了，其实Spring SPI也是基于JavaSPI思想来做的，从而实现了自己的SPI。

这里还是使用JavaSPI里的案例（智能电风扇）

定义接口模块

  1. 创建spring项目名为fan-spi-spring

    image-20230423001041981

    这里我还是使用聚合项目，我就不过多阐述这个了

  2. 引入spring依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.26</version>
        </dependency>
    </dependencies>

  3. 定义接口

    package com.hmg.spi.fanspi;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-23 0:28
 * @description: fan core spi service
 */
public interface IFanCoreSpiService {
    /**
     * 获取风扇类型
     * @return 类型
     */
    String getType();

    /**
     * 开关
     */
    void turnOnOff();

    /**
     * 调节风速
     */
    void adjustSpeed();

    /**
     * 摆头
     */
    void frontSway();

    /**
     * 定时
     */
    void timer();
}

  4. 使用maven打包

    mvn clean install

服务提供者实现

A模块

  1. 新建项目，名为fanA-type-provider-spring

    image-20230423004756797

  2. 引入fan-spi-spring项目的依赖

    <dependencies>
        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fan-spi-spring</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

  3. 创建接口实现类

    package com.hmg.spi.service.impl;

import com.hmg.spi.fanspi.IFanCoreSpiService;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-23 0:50
 * @description: A型号风扇spi实现类
 */
public class AaTypeFanCoreSpiServiceImpl implements IFanCoreSpiService {
    @Override
    public String getType() {
        return "A";
    }

    @Override
    public void turnOnOff() {
        System.out.println("A型号风扇开关");
    }

    @Override
    public void adjustSpeed() {
        System.out.println("A型号风扇调节风速");
    }

    @Override
    public void frontSway() {
        System.out.println("A型风扇摆头");
    }

    @Override
    public void timer() {
        System.out.println("A型风扇定时");
    }
}

  4. 在resources目录下创建META-INF目录，并创建spring.factories文件，在文件里写入接口全限定名=实现类全限定类名，多个实现类用逗号隔开，例如：接口全限定名=实现类全限定类名, 实现类全限定类名

    image-20230423192437398

  5. 使用maven打包，提供给调用者使用

mvn clean install
B模块

  1. 新建项目，名为fanB-type-provider-spring

    image-20230423010035417

  2. 引入fan-spi-spring项目的依赖

        <dependencies>
        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fan-spi-spring</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

  3. 创建接口实现类

    package com.hmg.spi.service.impl;

import com.hmg.spi.fanspi.IFanCoreSpiService;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-23 1:02
 * @description: B型号风扇spi实现类
 */
public class BbTypeFanCoreSpiServiceImpl implements IFanCoreSpiService {
    @Override
    public String getType() {
        return "B";
    }

    @Override
    public void turnOnOff() {
        System.out.println("B型号风扇开关");
    }

    @Override
    public void adjustSpeed() {
        System.out.println("B型号风扇调节风速");
    }

    @Override
    public void frontSway() {
        System.out.println("B型风扇摆头");
    }

    @Override
    public void timer() {
        System.out.println("B型风扇定时");
    }
}

  4. 在resources目录下创建META-INF目录，并创建spring.factories文件，在文件里写入接口全限定名=实现类全限定类名，多个实现类用逗号隔开，例如：接口全限定名=实现类全限定类名, 实现类全限定类名

    image-20230423192618051

  5. 使用maven打包，提供给调用者使用

    mvn clean install
C模块

C模块同理，一样的操作，这里就不再演示了。

服务发现

  1. 新建项目fan-app-spring

    image-20230423011245829

  2. 引入三个服务提供者模块的依赖

        <dependencies>
        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fanA-type-provider-spring</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fanB-type-provider-spring</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>com.hmg.spi</groupId>
            <artifactId>fanC-type-provider-spring</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

  3. 编写调用者代码

    package com.hmg.spi;

import com.hmg.spi.fanspi.IFanCoreSpiService;
import org.springframework.core.io.support.SpringFactoriesLoader;

import java.util.List;

/**
 * @author hmg
 * @version 1.0
 * @date 2023-04-23 1:12
 * @description: 调用者测试
 */
public class Main {
    public static void main(String[] args) {
        new Main().turnOn("B");
    }

    private void turnOn(String type){
        //Spring SPI使用SpringFactoriesLoader去发现并加载实现类
        List<IFanCoreSpiService> fanCoreSpiServices =
                SpringFactoriesLoader.loadFactories(IFanCoreSpiService.class, Main.class.getClassLoader());

        fanCoreSpiServices.forEach(iFanCoreSpiService -> {
            System.out.println("检测到的实现类有：" + iFanCoreSpiService.getClass().getSimpleName());
            if (type.equals(iFanCoreSpiService.getType())) {
                iFanCoreSpiService.turnOnOff();
            }
        });
    }
}

  4. 测试

    image-20230423192857763

SpringFactoriesLoader原理

因为ServiceLoader基于图片形式讲解，感觉比较麻烦，所以SpringFactoriesLoader我还是贴代码讲解吧，在代码里加注释。

loadFactories(Class factoryType, @Nullable ClassLoader classLoader)
	public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
        //断言，factoryType为空直接报错factoryType' must not be null
		Assert.notNull(factoryType, "'factoryType' must not be null");
		ClassLoader classLoaderToUse = classLoader;
        //判断是否有类加载器，没有的话就使用SpringFactoriesLoader的
		if (classLoaderToUse == null) {
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
        //加载实现类全限定名，我们进去看下loadFactoryNames()实现，看它怎么加载的实现类全限定名
		List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
		if (logger.isTraceEnabled()) {
			logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
		}
		List<T> result = new ArrayList<>(factoryImplementationNames.size());
		for (String factoryImplementationName : factoryImplementationNames) {
            /**
            * 重点关注instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse)，这里面主要是通过反射实例化对象
            * 接下来我们探究一下它的源码
            *
            **/
			result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
		}
        
        //对结果进行排序
		AnnotationAwareOrderComparator.sort(result);
		return result;
	}
loadFactoryNames
	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
        //判断是否有类加载器，没有的话就使用SpringFactoriesLoader的
		if (classLoaderToUse == null) {
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
        //获取接口全限定名
		String factoryTypeName = factoryType.getName();
        //主要看loadSpringFactories(classLoaderToUse)方法，这里面是找到spring.factories的源码
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}
loadSpringFactories
	private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        //先从缓存里面取，如果有数据直接返回，则继续往下执行（注意：key是classLoader）
		Map<String, List<String>> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		result = new HashMap<>();
		try {
            //根据路径获取所有资源，FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
                
                //加载配置文件拿到实现类全限定名，为什么可以用Properties加载，因为配置是K V的
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
                    //以逗号分隔的实现类全限定类名转成字符串数组
					String[] factoryImplementationNames =
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
					for (String factoryImplementationName : factoryImplementationNames) {
						//重新计算key，不存在则添加，存在则直接返回
						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
								.add(factoryImplementationName.trim());
					}
				}
			}

			//给结果去重
			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
            
            //把结果添加到缓存里，classLoader作为key， 结果集作为value
			cache.put(classLoader, result);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
        //返回结果
		return result;
	}
instantiateFactory

这个方法的实现就很少了，比较简单

	private static <T> T instantiateFactory(String factoryImplementationName, Class<T> factoryType, ClassLoader classLoader) {
		try {
            //通过ClassUtils.forName()加载Class对象
			Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName, classLoader);
            //判断实现类是不是实现了标准接口
			if (!factoryType.isAssignableFrom(factoryImplementationClass)) {
				throw new IllegalArgumentException(
						"Class [" + factoryImplementationName + "] is not assignable to factory type [" + factoryType.getName() + "]");
			}
            
            //先获得构造器，然后再实例化对象
			return (T) ReflectionUtils.accessibleConstructor(factoryImplementationClass).newInstance();
		}
		catch (Throwable ex) {
			throw new IllegalArgumentException(
				"Unable to instantiate factory class [" + factoryImplementationName + "] for factory type [" + factoryType.getName() + "]",
				ex);
		}
	}

到这里SpringFactoriesLoader源码解读也就结束了，整体上还是比较简单的，阅读完源码后来个小总结

小总结

大概说一下核心流程，就是我们在进入loadFactories方法时，第一个核心点就是loadFactoryNames方法里调用的loadSpringFactories方法，它所做的事就是加载实现类全限定名，第二个核心点就是instantiateFactory方法了，它所做的事就是通过反射实例化对象了。

总结

阅读完SpringFactoriesLoader源码发现比JavaSPI的ServiceLoader简洁了不少，不过他们的整体流程相似度还是很高的，还有就是spring spi的所有配置是放到一个文件里的，省去了写一大堆文件的麻烦，而java spi是一个标准接口一个文件，这样的话就比较麻烦了。

JavaSPI 与 SpringSPI有什么区别？

它们最大的区别就是配置文件了，JavaSPI 是一个接口一个配置文件，而Spring SPI是集中在一个配置文件里，也就是spring.factories，还有一个就是java spi是在遍历的时候才真正加载实现类，而spring spi是在loadFactories的时候就加载了。

后端开发萌新
关注
  • 23
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
详解Spring的SPI机制和自定义Springboot的Starter包
m0_73311735的博客
03-22 212
本文会先对JDK的SPI机制和Spring的SPI机制进行说明和演示，最后演示如何自定义Springboot的starter。Springboot2.4.1相信有了前面几篇文章的铺垫，现在自己实现一个starter，简直是信手拈来。自定义starter组件工程结构如下所示。和定义如下。复制代码定义如下。@Bean@Bean@Bean复制代码内容如下。复制代码POM文件内容如下。复制代码最后通过Maven将自定义starter。
剖析 SPI 在 Spring 中的应用
虚幻私塾
06-21 1010
SPI（Service Provider Interface），是Java内置的一种服务提供发现机制，可以用来提高框架的扩展性，主要用于框架的开发中，比如Dubbo，不同框架中实现略有差异，但核心机制相同，而Java的SPI机制可以为接口寻找服务实现。SPI机制将服务的具体实现转移到了程序外，为框架的扩展和解耦提供了极大的便利。得益于SPI优秀的能力，为模块功能的动态扩展提供了很好的支撑。本文会先简单介绍Java内置的SPI和Dubbo中的SPI应用，重点介绍分析Spring中的SPI机制，对比Spring
一文读懂Spring的SPI机制
热门推荐
听得到微笑的博客
05-22 1万+
一. 从类加载说起 Java中的类加载器负载加载来自文件系统、网络或者其他来源的类文件。jvm的类加载器默认使用的是双亲委派模式。三种默认的类加载器Bootstrap ClassLoader、Extension ClassLoader和System ClassLoader（Application ClassLoader）每一个中类加载器都确定了从哪一些位置加载文件。于此同时我们也可以通过继承 java.lang.classloader 实现自己的类加载器。 Bootstrap ClassLoader：负责
Spring高手之路14——深入浅出：SPI机制在JDK与Spring Boot中的应用
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
09-06 1万+
Spring Boot不仅是简化Spring应用开发的工具，它还融合了许多先进的机制。本文深入探讨了Spring Boot中与Java的标准SPI相似的机制，揭示了它的工作原理、应用场景及与标准SPI的异同。文章通过实际代码示例为你展示了如何在Spring Boot中使用这一机制，并以形象的比喻帮助你理解其背后的思想。
SpringBoot源码解读与原理分析(四)SPI机制
挑灯日记 记录自己
03-05 993
模拟一套Dao接口的不同数据库访问支持。
【spring系列】SPI详解
qq_35789269的博客
12-15 6476
SPI机制
死磕Spring，什么是SPI机制，对SpringBoot自动装配有什么帮助
m0_46638350的博客
02-25 1908
1. SPI是一个机制，流程由三个组件构成ServiceLoader，就是ClassLoader；Service，是接口，作为文件（在META-INF/services目录下）的名称ServiceProvider，是接口的实现类，作为文件（在META-INF/services目录下）的内容2. SPI执行流程ServiceLoader通过classpath路径，加载指定的Service文件，然后使用里面合适的内容ServiceProvider。
Spring SPI介绍
0
03-08 538
SPI全名，翻译过来就是“服务提供接口”，再说简单就是提供某一个服务的接口， 提供给服务开发者或者服务生产商来进行实现。Java SPI 是JDK内置的一种动态加载扩展点的实现。这个机制在一般的业务代码中很少用到，但是在底层框架中却被大量使用，包括JDBC、Dubbo、Spring框架、日志接口中都有用到，不同的是有的使用Java原生的实现，有的框架则自己实现了一套SPI机制.
java SPI和spring SPI
m0_74642813的博客
06-30 390
SPI 即 Service Provider Interface，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。SPI将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。很多框架都使用了Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。SPI机制在实际开发中使用得场景也有很多。
Java/Spring/Dubbo三种SPI机制到底谁更好？下面给大家详细介绍
欢迎来到我的博客
07-15 357
看到这里，你应该就知道开头问题的答案了，mysql-connector 的 jar 表中正是通过 SPI 的方式实现了 java 的 Driver 接口，所以我们的服务可以在运行时获取到 mysql 的驱动类，从而连接 mysql。SPI 的本质是将接口的实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载对应接口的实现类。这样就可以在运行时，获取接口的实现类。设计一个接口，将接口的实现类写在配置文件中，服务通过读取配置文件来发现实现类，进行加载实例化然后使用。
基于Java的mica-auto注解自动生成Java SPI和Spring Boot配置设计源码
最新发布
05-22
mica-auto是一个使用注解自动生成Java SPI和Spring Boot配置的工具，旨在简化开发过程中的配置工作，提高开发效率。该项目还提供了文档和示例代码，帮助开发者快速上手。记得在右上角点个star关注更新！
Java SPI 机制（SPI实战+ServiceLoader源码分析+SPI 应用场景+破坏双亲委派）
06-21
Java SPI 机制详解 Java SPI 机制，全称 Service Provider Interface，是 Java 内置的服务发现机制。SPI 机制的主要思想是解耦，通过提供一个标准接口，允许第三方提供实现类，而无需在程序中硬编码。SPI 机制广泛...
深度解析Dubbo的可扩展机制SPI源码：从理论到实践，打造高效、稳定的分布式服务框架
01-11
下面我们将从理论到实践，详细解析Dubbo SPI的源码及其工作原理。 首先，我们来看一下Dubbo SPI架构图。Dubbo SPI由ExtensionLoader、ExtensionFactory、Adaptive Extension等组件构成。ExtensionLoader是接口的...
Spring源码总结.pdf
02-13
Spring框架是Java后端开发中不可或缺的部分，它提供了一个全面的编程和配置模型，使得开发企业级应用变得简单。在Spring源码中，容器的加载方式、XML属性配置的解析过程以及自定义标签的处理是核心知识点。 1. **...
dubbo源码解析(2.7.x)
06-30
本课程会详细讲解dubbo源码，会从框架设计，与spring集成，dubbo spi和自适应拓展原理, 服务导出, 服务引入, 服务目录, 服务路由, 集群, 负载均衡, 服务调用过程几个章节去讲解，让学员感受小小的dubbo涉及的技术和...
深入剖析Spring Boot 的SPI机制
Trouvailless的博客
08-19 294
{}复制代码本文详细的讲解了java和Spring的SPI机制，SPI技术将服务接口与服务实现进行分离实现解耦，从而提升程序的可扩展性。如有疑问，请随时反馈。
spring 的SPI
qq_33378714的博客
10-10 295
spi
剖析下 SPI 在 Spring 中的应用
Java技术攻略的博客
02-27 268
SPI技术将服务接口与服务实现分离以达到解耦，极大的提升程序的可扩展性。本文重点介绍了Java内置SPI和Dubbo SPI以及Spring SPI三者的原理和相关源码；首先演示了三种SPI技术的实现，然后通过演示代码深入阅读了三种SPI的实现源码；其中重点介绍了Spring SPI的两种实现方式：spring.handlers和spring.factories，以及使用spring.factories实现的分库分表策略加载。希望通过阅读本文可以让读者对SPI有更深入的了解。
深入剖析 Spring Boot 的 SPI 机制
良月柒
02-15 89
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 3.5 分钟。来自：juejin.cn/post/7132742686099898398Java SPI实现示例说明创建动态接口实现类1实现类2相关测试运行结果：源码分析Spring SPISpring 示例定义接口相关实现相关测试类输出结果源码分析SPI(Service Provider Interface)是JDK内置的一种...
java api与spi的区别，用表格回答
07-15
| | Java API | SPI（Service Provider Interface） | |-------|----------------------------------|-------------------------------------------------------| | 定义 | Java API是Java语言提供的一系列接口和类，用于开发Java应用程序。 | SPI是一种机制，用于允许在运行时动态添加、替换或扩展应用程序的组件。 | | 目的 | 提供核心功能和标准化的编程接口 | 允许第三方开发者扩展应用程序的功能或替换默认实现 | | 使用方式 | 开发者通过引入和使用Java API来实现具体的功能。 | 开发者通过实现SPI接口并提供相关的配置文件来扩展或替换应用程序的组件。 | | 编译依赖 | Java API通常是作为编译时依赖包含在项目中。 | SPI通常是作为运行时依赖，可以通过配置文件指定具体的实现。 | | 可替换性 | Java API的实现通常是固定的，不容易替换。 | SPI允许在运行时动态替换或扩展组件，提高了灵活性和可拓展性。 | 需要注意的是，Java API是Java语言提供的一套标准化接口和类，开发者使用这些API来实现具体的功能。而SPI是一种机制，提供了一种动态扩展或替换应用程序组件的方式，允许第三方开发者在运行时添加、替换或扩展应用程序的功能。SPI通常通过实现特定的接口并提供相关的配置文件来实现扩展或替换，提高了应用程序的灵活性和可拓展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

后端开发萌新

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值