springboot自动装配@Import原理

最新推荐文章于 2024-06-07 16:18:42 发布
最新推荐文章于 2024-06-07 16:18:42 发布
阅读量2.1k 收藏 3
点赞数 1
分类专栏： java springboot 文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l1006841574/article/details/103792087
版权

springboot启动main方法中都会加@SpringBootApplication这个注解，就把这个注解作为入口，研究下springboot自动装配的原理。
springboot使用的版本号是2.2.1.RELEASE

文章目录

@SpringBootApplication

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
	//...
}

元注解的用法自行百度，网上教程很多。我们重点关注@EnableAutoConfiguration这个注解。首先看下@SpringBootConfiguration:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
	//...
}

@SpringBootConfiguration其实就是一个@Configuration配置注解。

@EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	//...
}

这里有两个注解@AutoConfigurationPackage和@Import。

@AutoConfigurationPackage

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

这里也用到了@Import注解，下面统一讲解下@Import注解。

@Import

@Import的使用

先理解@Import的使用，之后的内容方便理解。

https://www.cnblogs.com/zhoading/p/12194960.html

@Import(AutoConfigurationPackages.Registrar.class)

public abstract class AutoConfigurationPackages {
		//...
		static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
				@Override
				public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
						register(registry, new PackageImport(metadata).getPackageName());
				}
				@Override
				public Set<Object> determineImports(AnnotationMetadata metadata) {
						return Collections.singleton(new PackageImport(metadata));
				}
		}
}

下面举个demo来讲解下这个Registrar的源码到底干了什么。

新建demo类

先模仿springboot新建几个demo类，同时附上对应于springboot中的类：

  • LoggerService -> 一个普通的bean
public class LoggerService {
	//...
}
  • LoggerMyRegistrar -> AutoConfigurationPackages.Registrar
public class LoggerMyRegistrar implements ImportBeanDefinitionRegistrar {
	    @Override
	    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		        Class beanClass = LoggerService.class;
		        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(beanClass);
		        String beanName = StringUtils.uncapitalize(beanClass.getSimpleName());
		        registry.registerBeanDefinition(beanName, rootBeanDefinition);
		    }
}
  • EnableMyConfig -> AutoConfigurationPackage
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Import({LoggerMyRegistrar.class})
public @interface EnableMyConfig {
    	Class<?>[] exclude() default {};
}
  • EnableDemoMain -> 启动类
@SpringBootApplication
@EnableMyConfig
public class EnableDemoMain {
	    public static void main(String[] args) {
		        ConfigurableApplicationContext context = SpringApplication.run(EnableDemoMain.class,args);
		        System.out.println(context.getBean(LoggerService.class));
	    }
}
原理分析

LoggerService类上没有加任何的注解，但在main方法输出中，却能得到LoggerService这个Bean，原因就是LoggerMyRegistrar在起作用，这个类相对于springboot中的AutoConfigurationPackages.Registrar.class。具体流程如下：

  1. 启动类上加了@EnableMyConfig注解，EnableMyConfig中@Import(LoggerMyRegistrar.class)引入LoggerMyResitrar这个类。
  2. LoggerMyResitrar实现ImportBeanDefinitionRegistrar接口中的registerBeanDefinitions方法。
    该方法的第一个参数是元数据，可参考这篇博客，详细了解下spring元数据，嫌麻烦的可以打个断点调试下看看该参数的具体值是多少。第二个参数是bean注册中心，详细可参考这篇博客，bean注册中心。
  3. registry.registerBeanDefinition(beanName, beanDefinition)最终通过这个方法注入需要的bean。
  4. 通过调试可知，源码中register(registry, new PackageImport(metadata).getPackageName())是把启动类所在的包下面的类都给注入。

@Import(AutoConfigurationImportSelector.class)

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
		//...
		@Override
		public String[] selectImports(AnnotationMetadata annotationMetadata) {
				if (!isEnabled(annotationMetadata)) {
						return NO_IMPORTS;
				}
				AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
				AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata);
				return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
		}
}

下面举个demo来讲解下这个ImportSelector的源码到底干了什么。

新建demo类

先模仿springboot新建几个demo类，同时附上对应于springboot中的类：

  • CacheService -> 一个普通的bean
public class CacheService {
	//...
}
  • CacheImportSelector -> AutoConfigurationImportSelector
public class CacheImportSelector implements ImportSelector {
	    @Override
	    public String[] selectImports(AnnotationMetadata annotationMetadata) {
	    		//可以加自定义判断逻辑
		        Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(EnableMyConfig.class.getName());
		        return new String[]{CacheService.class.getName()};
	    }
}
  • EnableMyConfig -> EnableAutoConfiguration
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Import({CacheImportSelector.class})
public @interface EnableMyConfig {
    	Class<?>[] exclude() default {};
}
  • EnableDemoMain -> 启动类
@SpringBootApplication
@EnableMyConfig
public class EnableDemoMain {
	    public static void main(String[] args) {
		        ConfigurableApplicationContext context = SpringApplication.run(EnableDemoMain.class,args);
		        System.out.println(context.getBean(CacheService.class));
	    }
}
原理分析

CacheService类上没有加任何的注解，但在main方法输出中，却能得到CacheService这个Bean，原因就是CacheImportSelector在起作用，这个类相对于springboot中的AutoConfigurationImportSelector。具体流程如下：

  1. 启动类上加了@EnableMyConfig注解，EnableMyConfig中@Import(CacheImportSelector.class)引入CacheImportSelector这个类。

  2. CacheImportSelector实现ImportSelector接口中的selectImports方法。
    该方法的第一个参数是元数据，可参考这篇博客，详细了解下spring元数据，嫌麻烦的可以打个断点调试下看看该参数的具体值是多少。

  3. 方法返回需要注入的bean类全路径字符串数组。

深入研究源码原理
  • AutoConfigurationImportSelector实现的接口DeferredImportSelector
    public interface DeferredImportSelector extends ImportSelector {
		//...
}
    最终实现的还是ImportSelector接口。
  • AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader)
    final class AutoConfigurationMetadataLoader {
		protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties";
		
		static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
					return loadMetadata(classLoader, PATH);
		}		

		static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
				try {
							Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
									: ClassLoader.getSystemResources(path);
							Properties properties = new Properties();
							while (urls.hasMoreElements()) {
									properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
							}
							return loadMetadata(properties);
				}
				catch (IOException ex) {
							throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
				}
		}
		//...
    可以查看下META-INF/spring-autoconfigure-metadata.properties配置文件：
    //...
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration.ConditionalOnClass=
com.couchbase.client.java.Cluster,com.couchbase.client.java.CouchbaseBucket
//...
    文件内容很长，我随便选了一行，key的构成：自动配置的类全名.条件=值，其中条件ConditionalOnClass这个类应该很熟悉，不懂的可以百度springboot条件注解。可以查看下org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration源码，对照下配置文件中的内容方便理解：
    @Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ CouchbaseBucket.class, Cluster.class })
@Conditional(CouchbaseAutoConfiguration.CouchbaseCondition.class)
@EnableConfigurationProperties(CouchbaseProperties.class)
public class CouchbaseAutoConfiguration {
		//...
}
    CouchbaseAutoConfiguration源码中用了@ConditionalOnClass({ CouchbaseBucket.class, Cluster.class })和配置文件中的内容一对比，刚好匹配。
    这段代码的意思是：注入配置文件META-INF/spring-autoconfigure-metadata.properties中满足条件的Bean。当然自己可以对该文件进行扩展，在项目resources文件夹下新建META-INF/spring-autoconfigure-metadata.properties配置文件，添加自己的内容，就可以扩展。
  • getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata)
    protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
			if (!isEnabled(annotationMetadata)) {
					return EMPTY_ENTRY;
			}
			AnnotationAttributes attributes = getAttributes(annotationMetadata);
			List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
			configurations = removeDuplicates(configurations);
			Set<String> exclusions = getExclusions(annotationMetadata, attributes);
			checkExcludedClasses(configurations, exclusions);
			configurations.removeAll(exclusions);
			configurations = filter(configurations, autoConfigurationMetadata);
			fireAutoConfigurationImportEvents(configurations, exclusions);
			return new AutoConfigurationEntry(configurations, exclusions);
}
    以上代码可以打断点调试，看看那些参数值分别是多少。重点看getCandidateConfigurations(annotationMetadata, attributes)：
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
			List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
					getBeanClassLoader());
			Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
					+ "are using a custom packaging, make sure that file is correct.");
			return configurations;
	}
	protected Class<?> getSpringFactoriesLoaderFactoryClass() {
			return EnableAutoConfiguration.class;
	}
	//...
}
  • SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class)
    public final class SpringFactoriesLoader {
		public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
		//...
		public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
				String factoryTypeName = factoryType.getName();
				return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
		}

		private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
				//...
				try {
						Enumeration<URL> urls = (classLoader != null ?
								classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
								ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
						result = new LinkedMultiValueMap<>();
						//...
						return result;
				}
				catch (IOException ex) {
						//...
				}
		}
}
    里面用到了 META-INF/spring.factories这个配置文件，这个配置文件在spring-boot-autoconfigure-2.2.1.RELEASE.jar/META-INF/spring.factories，文件中找到org.springframework.boot.autoconfigure.EnableAutoConfiguration:
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
...
    看到这，可能依然不是很明白。
    总结：通过META-INF/spring.factories文件里的配置，key为org.springframework.boot.autoconfigure.EnableAutoConfiguration，找到对应的值，把这些类注入。 当然META-INF/spring.factories该文件也是可以扩展的。SPI也是使用了类似的原理，数据库链接串就是用到了SPI，不懂的可自行百度。

扩展资料

  • spring元数据

https://blog.csdn.net/f641385712/article/details/88765470

  • spring的bean注册中心

https://blog.csdn.net/f641385712/article/details/89518940

  • @Import注解的使用

https://www.cnblogs.com/zhoading/p/12194960.html

低调路人甲
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springBoot自动装配原理以及starter技术.pdf
11-28
总结，Spring Boot的自动装配和starter技术大大简化了Java应用的配置，通过`@Import`注解和自动配置机制，我们可以高效地管理Bean的生命周期。理解这些原理对于优化和调试Spring Boot应用至关重要。
Springboot自动装配实现过程代码实例
08-19
Springboot自动装配实现过程代码实例 Springboot自动装配实现过程代码实例是指在Spring Boot项目中实现自动装配的过程，包括创建自定义注解、配置类和自动装配Bean的过程。 知识点一：自定义注解 在Spring Boot...
Spring Boot 自动装配原理
林心涯的博客
01-20 3589
Spring Boot 自动装配原理 每次问到 Spring Boot， 面试官非常喜欢问这个问题：“讲述一下 SpringBoot 自动装配原理？”。 我觉得我们可以从以下几个方面回答： 什么是 SpringBoot 自动装配？ SpringBoot 是如何实现自动装配的？如何实现按需加载？ 如何实现一个 Starter？ 前言 使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring
Springboot自动装配原理
qq_45813393的博客
11-09 4670
Springboot自动装配原理
解密Spring Boot：揭秘自动装配背后的原理与机制
最新发布
忆~遂愿的博客
06-07 2394
《解密Spring Boot：揭秘自动装配背后的原理与机制》是深入探讨Spring Boot框架内部工作原理。它详细解释了Spring Boot如何实现自动装配，并揭示了其背后的原理和机制。通过分析Spring Boot的源代码和核心组件，读者将了解到Spring Boot是如何通过自动装配实现简化开发、提高效率的。这本书提供了对Spring Boot自动装配的全面理解，为开发人员提供了更深入的洞察力，帮助他们更好地利用Spring Boot框架开发高效、可靠的应用程序。
springboot自动装配原理
qq_26905813的博客
08-25 1242
step4：虽然127个场景的自动配置springboot一股脑全加载了，但是哪些生效哪些不生效，按照条件装配规则（@Conditional），最终会按需配置，那么接下来就要了解下“按需配置”了。众所周知，@SpringBootApplication注解标明这个类是主配置类，它是一个组合注解，springboot通过运行这个类里面的main()方法来启动程序。step1：要给容器里面导入哪些，看这个selectImports方法返回的string数组里面有哪些，就导入哪些。
SpringBoot自动装配原理
my_air的博客
05-31 2168
1.什么是SpringBoot? 对于spring框架，我们接触得比较多的应该是spring mvc、和spring。而spring的核心在于IOC（控制反转对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系）和DI（依赖注入IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 s
SpringBoot的自动装配原理
落的博客
01-05 1085
SpringBoot 定义了一套接口规范，这套规范规定：SpringBoot 在启动时会扫描外部引用 jar 包中的META-INF/spring.factories文件，将文件中配置的类型信息加载到 Spring 容器（此处涉及到 JVM 类加载机制与 Spring 的容器知识），并执行类中定义的各种操作。对于外部 jar 来说，只需要按照 SpringBoot 定义的标准，就能将自己的功能装置进 SpringBoot。
SpringBoot启动及自动装配原理过程详解
08-19
SpringBoot启动及自动装配原理过程详解 SpringBoot启动及自动装配原理过程详解是 SpringBoot 框架中一个非常重要的机制，它控制着整个应用程序的启动和自动装配过程。下面将详细介绍 SpringBoot 启动及自动装配...
Springboot 自动装配原理图文
12-04
Springboot 自动装配原理图文，里面描述了整个Springboot的装配流程和所有相关的组件。
springboot自动装配原理和注解.emmx
07-18
使用mindmaster打开
Springboot @Import 详解
08-26
主要介绍了Springboot @Import 详解，仔细看了下Springboot关于@Import的处理过程，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详细解读Spring Boot中@Import三种使用方式
wdj_yyds的博客
11-23 1004
Import是一个非常有用的注解，它的长处在于你可以通过配置来控制是否注入该Bean，也可以通过条件来控制注入哪些Bean到Spring容器中。、、等等统一采用的都是借助@Import注解来实现的。下面我们就通过示例来了解@Import三种用法！
17-SpringBoot自动配置-@Import详解
DevOps海洋的渔夫@专栏
03-07 883
17-SpringBoot自动配置-@Import详解@Import详解@Enable*底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到 IOC 容...
SpringBoot 注解 @Import 的原理-ConfigurationClassPostProcessor 源码解析
谈谈1974
07-01 1967
文章目录1. @Import 详解1.1 @Import 的作用1.2 @Import 的使用方式2. @Import 注册目标类的流程 1. @Import 详解 1.1 @Import 的作用 1.2 @Import 的使用方式 2. @Import 注册目标类的流程
Springboot的@import
a3337779的博客
08-05 177
Import注解，顾名思义，导入，即把类加入Spring IOC容器。有多种方式能让类加IOC容器管理，如@Bean、@Component等，@Import是另外一种方式，更加快捷。
深入探究Spring Boot自动配置原理及SPI机制：实现灵活的插件化开发
Apple_Boy的博客
09-17 719
在传统的Spring应用程序中，我们需要手动配置各种组件、依赖和属性，以满足应用程序的需求。这通常涉及编写大量的XML配置文件或Java配置类，并进行复杂的依赖注入和组件装配。这种手动配置过程可能非常繁琐且容易出错。而Spring Boot的自动配置机制通过约定大于配置的原则，基于应用程序的依赖和配置信息，自动推断和配置应用程序所需的各种组件。它通过提供默认的配置和装配规则，减少了我们的工作量，使得我们可以更专注于业务逻辑的开发。接下来就讲解一下自动配置的原理实现。
Springboot中SPI机制及自动装配
ChengXuYuanH__的博客
09-27 1633
SpringBoot 自动装配原理
springboot自动装配的底层原理
04-23
SpringBoot自动装配的底层原理是通过条件注解和Spring的反射机制实现的。在SpringBoot的启动过程中，会扫描所有的类路径，并找到有特定注解的类或者方法，根据这些类或方法的情况，自动地对Spring容器中的Bean进行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值