SpringBoot的自动装配原理解析（Starter）

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

这里用的是SpringBoot 2.0.6版本

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

想要了解SpringBoot的自动装配首先需要了解两个注解的作用 @Import 和 @Conditional （下面用到的@ConditionalOnMissingBean注解就是@Conditional的变种）

@Import注解

有时没有把某个类注入到IOC容器中，但在运用的时候需要获取该类对应的bean，此时就需要用到@Import注解。

源代码：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
	/**
	 *需要注入到容器中的类
	 */
	Class<?>[] value();
}

示例如下：

首先创建一个需要注入类

public class MyServiceImpl {
    public MyServiceImpl() {
        System.out.println("MyServiceImpl的构造函数！");
    }
    public void testService() {
        System.out.println("我是通过importSelector导入进来的service");
    }
}

然后定义一个MySelectorBean，需要实现 ImportSelector 接口，然后重写 selectImports()方法，把需要注入到容器中的Bean返回

public class MySelectorBean implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //这里返回需要注入到容器中类的数组
        return new String[]{"com.syt.myspringboot.service.MyServiceImpl"};
    }
}

然后创建一个配置类,这样在项目启动的时候就会把MyServiceImpl注入到IOC容器中

/**
 * 用来演示 @Import可以在springboot启动时自动装配类
 * 两种方式
 * 1：通过实现ImportSelector接口
 * 2：通过实现ImportBeanDefinitionRegistrar接口
 */
@Configuration
@Import(value = {MySelectorBean.class})
public class SelectorConfig {}

启动项目显示: MyServiceImpl的构造函数！

@RestController
public class MyController {
    @Autowired
    private MyServiceImpl myService; 
  
    @GetMapping("/testSelector")
    public String getTest() {
        myService.testService();
        return "success";
    }
}
--------------------------------------------------
 调用 localhost:8080/testSelector
 控制台输出：我是通过importSelector导入进来的service

@Conditional 注解

@Conditional是Spring4新提供的注解，表示仅当所有指定条件都匹配时，组件才能注册bean。

场景：可用于自定义Starter时根据条件判断注入需要的bean

源代码：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

	/**
	 * 参数需要传入一个继承Condition的类，重写matches方法，返回true时表示允许注册，
	 */
	Class<? extends Condition>[] value();

}

首先创建需要注入的bean的类,创建一个接口，然后创建两个实现该接口的类

public interface ListService {
    String showListCmd();
}
------------------------------------------------------------------------------------
@Service
public class LinuxService implements ListService {
    @Override
    public String showListCmd(){
        return "我是linux系统";
    }
}
------------------------------------------------------------------------------------
@Service
public class WindowsService implements ListService {
    @Override
    public String showListCmd() {
        return "我是windows系统";
    }
}

接下来是实现 继承Condition的类，重写matches方法

/**
 * linux环境
 * 实现condition接口重新matches方法
 * 返回true：注入 ，false：不注入
 */
public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
         //获取ioc使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //获取当前环境信息
        Environment environment = context.getEnvironment();
        //获取bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        return context.getEnvironment().getProperty("os.name").contains("Linux");
    }
}
//------------------------------------------------------------------------------------
public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return context.getEnvironment().getProperty("os.name").contains("Windows");
    }
}

用@Conditional注解，选择注入bean的配置类，

/**
 * 演示@Conditional注解的作用
 * 通过实现Condition接口，根据修改的判断条件来选择性的注入Bean
 * 例：WindowsCondition，LinuxCondition
 */
@Configuration
public class MyConditionalConfiguration {
    @Bean(name = "listService")
    @Conditional(WindowsCondition.class)
    public ListService windowsService() {
        return new WindowsService();
    } 
    @Bean(name = "listService")
    @Conditional(LinuxCondition.class)
    public ListService linuxEmailerService() {
        return new LinuxService();
    }
}

启动项目调用

@RestController
public class MyController {
    @Autowired
    private ListService listService;
    @GetMapping("/testConditional")
    public String testConditional() {
        //调用 showListCmd方法
        return listService.showListCmd();
    }
}
返回结果： 我是windows系统

@ConditionalOnMissingBean 注解

@ConditionalOnMissingBean注解作用在@bean定义上，它的作用就是在容器加载它作用的bean时，检查容器中是否存在目标类型（ConditionalOnMissingBean注解的value值）的bean了，如果存在这跳过原始bean的BeanDefinition加载动作。

自动装配原理解析

创建工程首先进入SpringBoot的主类找到@SpringBootApplication注解，进入找到@EnableAutoConfiguration注解 ，进入找到@Import(AutoConfigurationImportSelector.class)注解。

发现@Import注解导入了一个AutoConfigurationImportSelector类，这个类selectImports()方法就是根据Maven依赖导入jar包来筛选配置类然后设置需要创建bean的类。 。

Springboot自动装配的jar包是Spring-Boot-AutoConfigure，项目启动时会到这个jar下寻找spring.factories文件，org.springframework.boot.autoconfigure.EnableAutoConfiguration这个字段就是可以自动配置的key，默认配置总共有110个类，selectImports()方法会根据需要设置创建bean的类。以下是具体源码

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector
org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#selectImports
/**
 *自动配置导入
 *DeferredImportSelector接口就是继承了ImportSelector
 */
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);
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //去mata-info/spring.factories文件中 查询 EnableAutoConfiguration对于值 
		List<String> configurations = getCandidateConfigurations(annotationMetadata,
				attributes);
        //去除重复的配置类，若我们自己写的starter 可能存主重复的
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
        //根据maven 导入的启动器过滤出 需要导入的配置类
		configurations = filter(configurations, autoConfigurationMetadata);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return StringUtils.toStringArray(configurations);
	}
/**
 * 去mata-info/spring.factories文件中查询 EnableAutoConfiguration对于值
 */
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;
	}
}    
-----------------------------------------------------
org.springframework.core.io.support.SpringFactoriesLoader
org.springframework.core.io.support.SpringFactoriesLoader#loadFactoryNames
    
public abstract class SpringFactoriesLoader { 
	public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}
//去mata-info/spring.factories文件中查询 EnableAutoConfiguration对于值的具体实现
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					List<String> factoryClassNames = Arrays.asList(
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
					result.addAll((String) entry.getKey(), factoryClassNames);
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}
}

以redis为例

上边的selectImports()已经加载了RedisAutoConfiguration类

RedisAutoConfiguration这个类就是在mata-info/spring.factories配置中存在的类Springboot会创建对应的Bean进行管例，接下来是查看这个类看看具体还做了哪些操作 。源码：

org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
    /**
     *创建了redisTemplateBean
     *@ConditionalOnMissingBean注解作用在@bean定义上，它的作用就是在容器加载它作用的bean时，检查容器中是否存在目标类型（ConditionalOnMissingBean注解的value值）的bean了，如果存在这跳过原始bean的BeanDefinition加载动作。
     */
	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(
			RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
}

操作:

1：RedisOperations接口定义redis了的操作

2：@EnableConfigurationProperties注解的作用是开启@ConfigurationProperties，RedisProperties类就是用@ConfigurationProperties修饰的类，会读取yml文件到配置到RedisProperties映射。

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    //***省略****
}

3：@Import注解导入了LettuceConnectionConfiguration，JedisConnectionConfiguration两个类，其中JedisConnectionConfiguration是redis连接的具体实现

4：创建了redisTemplate和stringRedisTemplate的bean

接下来主要看一下JedisConnectionConfiguration类

redisConnectionFactory()配置了JedisConnectionFactory的Bean，JedisConnectionFactory配置了redis的连接池。

@Configuration
@ConditionalOnClass({ GenericObjectPool.class, JedisConnection.class, Jedis.class })
class JedisConnectionConfiguration extends RedisConnectionConfiguration {
	@Bean
	@ConditionalOnMissingBean(RedisConnectionFactory.class)
	public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException {
		return createJedisConnectionFactory();
	}

以上就是SpringBoot的自动装配解析。

关于@Import注解和@Conditional注解的使用可以查看项目：https://gitee.com/sytsuccess/myspringboot.git

如果想要自定义一个自己的starter可以查看博客：https://juejin.im/post/5cb880c2f265da03981fc031

希望大佬们提出宝贵意见。

渣渣T-syt
关注
springboot自动装配
qq_46416934的博客
07-29 1007
springboot的自动装配实际上就是为了从spring.factories文件中获取到对应的需要进行自动装配的类，并生成相应的Bean对象，然后将它们交给spring容器来帮我们进行管理这个注解是springboot启动类上的一个注解，是一个组合注解，也就是由其他注解组合起来，它的主要作用就是标记说明这个类是springboot的主配置类，springboot应该运行这个类里面的main()方法来启动程序 这个注解主要由三个子注解组成：这个注解包含了@Configuration，@Configurat
SpringBoot自动装配原理及手写starter教学
weixin_44070630的博客
04-02 1266
想要了解自动装配的原理，我们需要依次了解一下问题： 什么是自动装配？ 为什么要用自动装配，为了解决什么问题？ SpringBoot中如何实现我们的自动装配？每次装配是全部加载还是按需加载？ 如果让我们自己手写starer怎么实现？（考察自动装配的掌握程度） 自动装配 自动装配：在springboot帮助下，通过简单的配置注解即可使用相应的功能点 这么解释显得单一，还体会不到这个概念和用自动装配的好处，简单穿插下关于spring，springboot， springboot的概念，对比才能显示出它本身的优
SpringBoot的starter自动装配原理
逍遥子
10-01 493
还为弄不清楚springBoot的starter的自动装配模式原理而烦扰，看一下这篇文章 以Mybatis为例，浅谈springBoot的starter自动装载原理与实现说不定一下子就豁然开朗了呢，加油 ...
SpringBoot自动装配
爱敲代码的三毛的博客
07-28 1144
SpringBoot自动装配
SpringBoot的自动装配
caiqianzhigai0859的博客
12-30 367
SpringBoot自动装配的一些介绍
springBoot自动装配原理以及starter技术.pdf
11-28
本文将深入解析Spring Boot自动装配的原理，并探讨starter技术。 首先，我们来看`@Import`注解，它是Spring框架的一个核心注解，用于导入其他配置类或组件。当我们在一个@Configuration注解的类中使用`@Import`导入...
SpringBoot自动装配原理（简单易懂）
01-09
SpringBoot自动装配原理详解 SpringBoot作为Java开发中的一款热门框架，因其简化配置、快速启动和集成众多功能的特性，深受开发者喜爱。其中，自动装配是SpringBoot的核心特性之一，它极大地减少了手动配置的工作量...
SpringBoot之自动装配原理
m0_67400973的博客
08-02 884
SpringBoot的核心理念是简化Spring应用的搭建和开发过程，提出了和的思想。开发Spring项目通常要配置xml文件，当项目变得复杂的时候，xml的配置文件也将变得极其复杂。为了解决这个问题，我们将一些常用的通用的配置先配置好，要用的时候直接装上去，不用的时候卸下来，这些就是SpringBoot框架在Spring框架的基础上要解决的问题。只需要在SpringBoot默认的配置文件application.yaml中配置redis连接信息就可以直接自动注入操作redis的Bean。...
Springboot 自动配置及starter原理
qq_44587855的博客
02-26 371
Spring boot的自动配置是通过启动类上的注解实现的。 老生常谈了，如果看过类似的博文很容易定位。 源码 ConfigurationClassParser解析启动类（配置类） AutoConfigurationImportSelector 之后通过对Spring boot启动类的注解解析，其中一个环节的解析就会去解析@Import注解，把这里的AutoConfigurationImportSelector收集起来，到 ...
springBoot的自动装配
HongSuShouyu的博客
03-28 2546
5、在解析@Import注解的时候，会有一个getImport()方法，从主类开始递归解析注解，把所有包含@Import的注解都解析到，然后在processImport()方法中对import的类进行分类，例如AutoConfigurationImportSelect归属于ImportSelect的子类，在后续的过程中会调用DeferredImportSelectorHandler类里面的process方法，来完成整个EnableAutoConfiguration的加载。
Spring Boot 的自动装配
Luoqian00的博客
06-09 290
Spring Boot 的自动装配原理
springboot的自动装配
weixin_44153131的博客
03-21 456
通过引入依赖（Starter），从spring.factories文件中获取到对应的需要进行自动装配的类，并生成相应的Bean对象，然后将它们交给spring容器来帮我们进行管理，这就是springboot的自动装配。指定的生效条（Starters提供的依赖、配置或Spring容器中是否存在某个Bean等）时，实例化该AutoConfiguration类中定义的Bean，并注入Spring容器，就可以完成依赖框架的自动配置。注解的入口程序类所在的basepackage下的所有带有。
spring boot自动装配
fengwuya的博客
11-16 152
spring boot自动装配
SpringBoot 自动装配
最新发布
weixin_45722666的博客
09-02 617
SpringBoot 自动装配原理
SpringBoot面试深度解析：Starter与自动装配原理
“SpringBoot面试题包含了关于SpringBoot核心特性的讨论，特别是Starter和自动装配的原理。” 在SpringBoot框架中，Starter扮演着至关重要的角色。Starter是一种便捷的服务，它旨在简化开发者的工作，特别是在集成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值