死磕Spring，什么是SPI机制，对SpringBoot自动装配有什么帮助

最新推荐文章于 2024-05-06 19:02:54 发布
最新推荐文章于 2024-05-06 19:02:54 发布
阅读量1.8k 收藏 23
点赞数 3
文章标签： spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46638350/article/details/129214228
版权

文章目录

如果没时间看的话，在这里直接看总结

1. SPI是一个机制，流程由三个组件构成

  • ServiceLoader，就是ClassLoader；
  • Service，是接口，作为文件（在META-INF/services目录下）的名称
  • ServiceProvider，是接口的实现类，作为文件（在META-INF/services目录下）的内容

2. SPI执行流程

  • ServiceLoader通过classpath路径，加载指定的Service文件，然后使用里面合适的内容ServiceProvider

一、Java SPI的概念和术语

SPI（Service Provider Interface）：基于ClassLoader，发现并加载服务，机制
SPI由三个组件构成：Service、Service Provider、ServiceLoader

  • Service：是一个公开的接口或抽象类，定义了一个抽象的功能模块（文件名称）
  • Service Provider：是Service的实现类（文件内容）
  • ServiceLoader：是SPI机制中的核心组件，负责在运行时发现并加载Service Provider
    在这里插入图片描述

二、看看Java SPI是如何诞生的

  1. 在Java SPI出现之前，Class.forName（）要自己根据需求写驱动类
    在这里插入图片描述

  2. JDBC要求Driver实现类在类加载的时候，能将自身的实例对象自动注册到DriverManager中，从而加载数据库驱动。
    在这里插入图片描述

  3. Java SPI逐渐融入JDBC
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

三、Java SPI应该如何应用

  1. 规范的配置文件
    在这里插入图片描述
    在这里插入图片描述
  2. Service Provider类必须具备无参的默认构造方法
    在这里插入图片描述
    在JDBC中的对应实现
    在这里插入图片描述
  3. 保证能加载到配置文件和Service Provider类
    在这里插入图片描述
    在JDBC中的对应实现
    在这里插入图片描述
    总结：上述除了导包需要自己动手以外，其他的手续都是导包之后，Java SPI自动完成的

四、从0开始，手撸一个SPI的应用实例

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

总体流程
在这里插入图片描述

五、SpringBoot自动装配

参考视频：每一帧都是干货！15分钟的视频花2小时看
参考文章：springboot自动装配到底是什么意思？
参考文章：建立META-INF/spring.factories文件的意义何在
参考文章：springboot自动装配原理-以redis为例
参考文章：聊聊 SpringBoot 自动装配原理
参考文章：spring.factories 文件的位置

1. 手动装配Redis实例

  • 加入pom依赖
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
	<version>2.0.9.RELEASE</version>
</dependency>

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>
  • 配置xml的bean的配置
 //配置连接池
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="minIdle" value="10"></property>
        <property name="maxTotal" value="20"></property>
    </bean>
    
    //配置连接工厂
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="47.104.128.12"></property>
        <property name="password" value="123456"></property>
        <property name="database" value="0"></property>
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>


    //配置 redisTemplate 模版类
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory"  ref="jedisConnectionFactory"/>
        <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！  -->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
         <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
    </bean>
  • 导入配置
    @ImportResource(locations = “classpath:beans.xml”) 可以导入xml的配置文件

2. SpringBoot自动配置Redis实例

  • 引入依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  • 配置Redis服务器
spring:
	redis:
		database:0
		host:127.0.0.1
		port:6379
		password:123456
  • 直接使用RedisTemplate或StringRedisTemplate
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
  • 提出问题：自动配置
  • 我们除了通过maven引入一个starter外，其他什么也没有做，但是呢，SpringBoot就自动完成了Redis的配置，将相关的Bean对象注册到IOC容器中了。那么SpringBoot是如何做到这一点的呢？这就是这篇博客所要说明的问题了。

2. 自动配置，一切从注解@SpringBootApplicaiton说起

  • @SpringBootApplication注解
    在这里插入图片描述
  • 下面我们逐步分析@EnableAutoConfiguration的自动配置
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
 
    Class<?>[] exclude() default {};
 
    String[] excludeName() default {};
}

AutoConfigurationImportSelector.class的selectImports方法

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata){
	if(!isEnabled(annotationMetadata))
		return NO_IMPORTS;
	AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
			.loadMetadata(this.beanClassLoader);
	//SpringBoot自动配置的入口方法
	AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(
			autoConfigurationMetadata, annotationErtadata);
	return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  • selectImports（）方法中引用的getAutoConfigurationEntry（）
protected AutoConfigurationEntry getAutoConfigurationEntry(
		AutoConfigurationMetadata autoConfigurationMetadata,
		AnnotationMetadata annotationMetadata){
	//1. 获取annotationMetadata的注解@EnableAutoConfiguration的属性
	AnnotationAttributes attributes = getAttributes(annotationMetadata);
	//2. 从资源文件Spring.factories中获取EnableAutoConfiguration对应的所有的类
	List<String> configurations = getCandidateConfigurations(
		annotationMetadata, attributes);
	//3. 通过在注解@EnableAutoConfiguration设置exclude的相关属性，可以排除指定的自动配置类
	Set<String> exclusions = getExclusions(anntationMetadata, attributes);
	checkExcludedClasses(configurations, exclusions);
	configurations.removeAll(exclusions);
	//4. 根据注解@Conditional来判断是否需要排除某些自动配置类
	configurations filter = filter(configurations, autoConfigurationMetadata);
	//5. 触发AutoConfiguration导入的相关事件
	fireAutoCOnfigurationImportEvents(configurations, exclusions);
	return new AutofigurationEntry(configurations, exclusions);
}
  • getAutoConfigurationEntry（）引用的getCandidateConfigurations（）
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
		AnnotationAttributes attributes){
	//通过SpringFactories机制，从配置文件Spring.factories中找出所有的自动配置类
	List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
			EnableAutoConfiguration.class, getBeanClassLoader());
	Assert.notEmpty(configurations,"No auto configuration classes found");
	return configurations;
}

SpringFactoriesLoader.loadFactoryNames方法调用loadSpringFactories方法从所有的jar包中读取META-INF/spring.factories文件信息。

	// 参数：
 	// Class<?> factoryType：需要被加载的工厂类的class
 	// ClassLoader classLoader：类加载器
	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			// 若没传入类加载器，使用该本类的类加载器
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
		// class.getName():获取该类的全类限定名字
		String factoryTypeName = factoryType.getName();
		// loadSpringFactories(classLoaderToUse) 返回是Map
		// Map.getOrDefault(A,B): A为Key，从Map中获取Value，若Value为Null，则返回B 当作返回值
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

loadSpringFactories（）方法调用ClassLoader.getSystemResources（）获取META-INF/spring.factories文件

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap result = (MultiValueMap)cache.get(classLoader);
        if(result != null) {
            return result;
        } else {
            try {
                Enumeration ex = classLoader != null?classLoader.getResources("META-INF/spring.factories"):ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result1 = new LinkedMultiValueMap();
 
                while(ex.hasMoreElements()) {
                    URL url = (URL)ex.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
 
                    while(var6.hasNext()) {
                        Entry entry = (Entry)var6.next();
                        List factoryClassNames = Arrays.asList(StringUtils.commaDelimitedListToStringArray((String)entry.getValue()));
                        result1.addAll((String)entry.getKey(), factoryClassNames);
                    }
                }
 
                cache.put(classLoader, result1);
                return result1;
            } catch (IOException var9) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var9);
            }
        }
    }

下面是spring-boot-autoconfigure这个jar中spring.factories文件部分内容，选择带有EnableAutoConfiguration自动配置类。

org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
 
# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnClassCondition
 
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\

六、Spring SPI机制与Spring Factories机制做对比

  • 联系：Spring Factories自动装配借用了SPI机制，SPI机制本身就是一种思想，不是特定的技术。
  • 区别：如下
    在这里插入图片描述

七、这里是给我自己提个醒

META-IF/spring.factories是在Maven引入的Jar包中，每一个Jar都有自己META-IF/spring.factories，所以SpringBoot是去每一个Jar包里面寻找META-IF/spring.factories，而不是我的项目中存在META-IF/spring.factories（当然也可以存在，但是我项目的META-IF/spring.factories肯定没有类似以下这些东西）
在这里插入图片描述

后端漫漫
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
剖析 SPI 在 Spring 中的应用
虚幻私塾
06-21 1003
SPI（Service Provider Interface），是Java内置的一种服务提供发现机制，可以用来提高框架的扩展性，主要用于框架的开发中，比如Dubbo，不同框架中实现略有差异，但核心机制相同，而Java的SPI机制可以为接口寻找服务实现。SPI机制将服务的具体实现转移到了程序外，为框架的扩展和解耦提供了极大的便利。得益于SPI优秀的能力，为模块功能的动态扩展提供了很好的支撑。本文会先简单介绍Java内置的SPI和Dubbo中的SPI应用，重点介绍分析Spring中的SPI机制，对比Spring
未来的组织形态是什么样的-冯仑.JPG
01-04
未来的组织形态是什么样的-冯仑.JPG
Spring高手之路14——深入浅出：SPI机制在JDK与Spring Boot中的应用
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
09-06 1万+
Spring Boot不仅是简化Spring应用开发的工具，它还融合了许多先进的机制。本文深入探讨了Spring Boot中与Java的标准SPI相似的机制，揭示了它的工作原理、应用场景及与标准SPI的异同。文章通过实际代码示例为你展示了如何在Spring Boot中使用这一机制，并以形象的比喻帮助你理解其背后的思想。
重学SpringBoot3-SPI机制
最新发布
CoderJia的学习之路
05-06 790
SPI（Service Provider Interface）即服务提供者接口，是一种服务发现机制，允许开发者和框架发现和加载可用的服务实现，而不需要在代码中硬编码具体的实现。这种机制使得软件系统能够更加灵活和可扩展。在 Java 平台上，SPI 通常是通过类实现的，但 Spring Boot 对这一概念进行了扩展，以支持其自动配置和模块化架构。Spring Boot 的 SPI 机制不仅强化了框架的自动配置能力，还提供了一种灵活且强大的方式来扩展和定制应用程序的行为。
Java/Spring/Dubbo三种SPI机制到底谁更好？下面给大家详细介绍
欢迎来到我的博客
07-15 333
看到这里，你应该就知道开头问题的答案了，mysql-connector 的 jar 表中正是通过 SPI 的方式实现了 java 的 Driver 接口，所以我们的服务可以在运行时获取到 mysql 的驱动类，从而连接 mysql。SPI 的本质是将接口的实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载对应接口的实现类。这样就可以在运行时，获取接口的实现类。设计一个接口，将接口的实现类写在配置文件中，服务通过读取配置文件来发现实现类，进行加载实例化然后使用。
深入剖析Spring Boot 的SPI机制
Trouvailless的博客
08-19 289
{}复制代码本文详细的讲解了java和Spring的SPI机制，SPI技术将服务接口与服务实现进行分离实现解耦，从而提升程序的可扩展性。如有疑问，请随时反馈。
java SPI和spring SPI
m0_74642813的博客
06-30 375
SPI 即 Service Provider Interface，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。SPI将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。很多框架都使用了Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。SPI机制在实际开发中使用得场景也有很多。
java spi与自动装配
qq_39035267的博客
03-10 139
Springboot中SPI机制及自动装配_fuhao_home的博客-CSDN博客。
死磕spring源码系列-SpringAop十分钟快速入门
08-30
死磕spring源码系列-SpringAop十分钟快速入门
死磕spring源码系列-深度解析spring aop
08-30
死磕spring源码系列-深度解析spring_aop
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
SPI入门级Demo（四：服务实现者-乘法服务）
08-10
NULL 博文链接：https://fanyc.iteye.com/blog/2202850
战略和文化是什么，以及如何落地-彭蕾.JPG
01-04
战略和文化是什么，以及如何落地-彭蕾.JPG
Java SPI机制详解
热门推荐
ws13575291650的博客
02-07 1万+
Java SPI机制详解1、什么是SPI？2、SPI的用途Driver实现Mysql DriverManager实现spi工具类`ServiceLoader`将自己注册到驱动管理器的驱动列表中当获取连接的时候调用驱动管理器的连接方法从列表中获取。 1、什么是SPI？ SPI 全称为 (Service Provider Interface) ， 是JDK内置的一种服务提供发现机制,是一种动态替换发现的机制。 比如有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。我们经常遇到的就是java.sql.
Java ServiceLoader与Spring工厂加载器
乔志勇笔记
08-06 1888
现在Spring boot来到了Jar世界，原来它是管理war世界的王者，所以，他也很可能带来了Jar打包规则的改变。Jar世界从OSGI到Java Service Loader以及Java 9的模块化，折腾了很长时间，现在看看Spring是如何折腾Jar包的动态加载的： 控制反转IOC不仅可以在类级别进行，而且可以在模块级别进行，虽然OSGi技术已经存世了很长时间了，但是，在Java中也可以像在...
【SPI机制】SpringBoot中的SPI机制
后端研发工程师Marion的博客
08-08 1401
一、参考资料 spring-boot中的SPI 机制 springboot中SPI机制
JAVA SPI和Spring SPI
weixin_41615516的博客
07-02 2692
Java SPI作用及原理 在程序开发的时候，开发人员并不想对某些功能的实现写死，需要开放一些口子让其他部门或者第三方接入的时候灵活实现。这个时候就需要JAVA SPI机制。SPI机制可以帮助开发人员从配置文件中加载指定接口的实现类，这样就可以在不改动实现类的代码的前提下，更换或者添加接口的不同实现。可以做到灵活插拔。 spi的使用分为两种，可以使用java内置的spi，也可以使用spring封装的spi。 使用spi的步骤 1.创建接口和他的多个实现类 2.在项目的Resource.
springboot-starter SPI机制
zhaoyang10的专栏
07-22 1689
springboot-starter中的SPI 机制 https://juejin.im/post/5d2c80da6fb9a07ec42b8bd4
SpringCLoud如何保证系统的可用性？通过什么？
09-20
### 回答1： SpringCloud可以通过多种方式来保证系统的可用性，其中包括： 1. 服务注册与发现：通过Eureka、Consul等注册中心，实现服务的自动注册与发现，保证服务的高可用性。 2. 负载均衡：通过Ribbon、Feign等负载均衡组件，实现请求的分发，避免单点故障。 3. 熔断器：通过Hystrix等熔断器组件，实现服务的自动降级，避免服务雪崩。 4. 配置中心：通过Config等配置中心，实现配置的集中管理，避免配置错误导致系统不可用。 5. 服务网关：通过Zuul、Spring Cloud Gateway等服务网关，实现请求的统一入口，提高系统的安全性和可用性。 ### 回答2： Spring Cloud 是一个开源的微服务框架，它可以帮助开发者构建具有高可用性的系统。Spring Cloud 中通过以下几种方式来保证系统的可用性： 1. 服务注册与发现：通过使用服务注册与发现组件，如Eureka、Consul等，可以让服务能够自动注册到注册中心，并能够发现其他服务的信息。服务发现的机制可以保证当某个服务发生故障或下线时，其他服务能够找到可用的服务实例，从而保证系统的可用性。 2. 负载均衡：Spring Cloud提供了负载均衡的解决方案，如Ribbon、LoadBalancer等。通过使用负载均衡器，可以将请求分发到不同的服务实例上，从而实现服务的高可用性和提升系统的性能。 3. 服务容错：通过使用Hystrix等容错组件，可以在服务之间进行隔离和容错处理。当某个服务出现故障或超时时，Hystrix可以实现快速失败和降级处理，从而保证系统的可用性。 4. 服务监控与运维：Spring Cloud提供了丰富的监控和运维工具，如Spring Boot Admin、Sleuth等。通过这些工具，可以实时监控和追踪服务的运行情况，及时发现并解决问题，从而提高系统的可用性。 5. 容器化和自动化部署：Spring Cloud可以与容器化技术如Docker等集成，通过容器化部署可以快速创建和部署服务。同时，结合自动化部署工具如Jenkins等，可以实现系统的快速更新和部署，减少系统宕机的风险，保证系统的可用性。 总之，Spring Cloud 提供了一系列的组件和工具，通过服务注册与发现、负载均衡、服务容错、监控运维以及容器化和自动化部署等方式，来保证系统的可用性和稳定性。 ### 回答3： Spring Cloud是一个用于构建分布式系统的框架，它提供了一系列的组件和工具来帮助开发人员构建具有高可用性的系统。 Spring Cloud通过以下几个方面来保证系统的可用性： 1. 服务注册与发现：Spring Cloud提供了服务注册与发现的功能，开发人员可以将微服务注册到注册中心，并通过注册中心来发现其他微服务。这样，当某个微服务出现故障或下线时，注册中心可以将新的可用实例通知给其他微服务，从而保证系统的可用性。 2. 负载均衡：Spring Cloud中集成了负载均衡的功能，通过负载均衡算法将请求分发到多个可用的服务实例上，从而均衡系统的负载。当某个服务实例出现故障时，负载均衡机制会自动将请求转发给其他可用的服务实例，从而保证系统的可用性。 3. 服务熔断与降级：Spring Cloud提供了服务熔断与降级的功能，当某个微服务出现不可用或响应过慢的情况时，可以通过熔断机制来快速切换到备用服务，从而保证系统的可用性。同时，还可以通过降级策略来减少对故障服务的依赖，提高系统的可用性。 4. 分布式追踪与监控：Spring Cloud集成了分布式追踪与监控的组件，可以对系统的各个微服务进行监控和追踪。通过监控和追踪，可以实时了解系统的运行状态，并及时发现并处理潜在的故障，从而保障系统的可用性。 综上所述，Spring Cloud通过服务注册与发现、负载均衡、服务熔断与降级以及分布式追踪与监控等多个方面来保证系统的可用性。开发人员可以根据具体需求选择适合的组件和工具，并合理设计和实施架构来保证系统的稳定运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值