SpringBoot学习（五）：自动配置的源码实现（二）Spring容器对自动配置的加载

最新推荐文章于 2024-08-22 22:39:12 发布
最新推荐文章于 2024-08-22 22:39:12 发布
阅读量446 收藏
点赞数
分类专栏： springboot 文章标签： spring boot
原文链接：https://blog.csdn.net/u010013573/article/details/86743857
版权

概述

  • 在第一篇文章：SpringBoot学习（五）：自动配置的源码实现（一）@EnableAutoConfiguration详解中已经介绍过@EnableAutoConfiguration注解的设计，而Spring容器对自动化配置的加载是基于@EnableAutoConfiguration注解的这个设计来实现的，接下来具体分析该过程

1. 应用程序添加@EnableAutoConfiguration注解

  • 在应用程序主类（即SpringApplication.run方法被调用的main方法所在的类）添加使用@SpringBootApplication注解，该注解包含@EnableAutoConfiguration注解或者也可以直接使用@EnableAutoConfigure注解。@EnableAutoConfigure通过@Import注解来导入AutoConfigurationImportSelector；如下为一个应用代码配置示例：

    @SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        // ... customize application settings here
        application.run(args);
    }
}

     

2. ConfigurationClassPostProcessor处理@EnableAutoConfiguration注解

ConfigurationClassPostProcessor的调用

  1. BeanFactory的创建：Spring框架调用ApplicationContext.refresh方法启动Spring容器：先会创建BeanFactory，扫描包，获取使用了@Configuration或者其他配置性质的注解，如@SpringBootApplication，@Import等注解，的类，生成BeanDefinition并注册到BeanFactory中；

  2. BeanFactoryPostProcessor执行：BeanFactory后置处理器对BeanFactory中的BeanDefinition进行加工，如注解处理。对于@Configuration等属于配置性质的注解的处理，则是交给ConfigurationClassPostProcessor来完成：

    • ConfigurationClassPostProcessor为BeanFactoryPostProcessor接口的实现类：从BeanFactory获取所有创建好的BeanDefinition列表，遍历该列表并筛选出所在类使用了@Configuration，@Import等配置性质注解的BeanDefintion 

    • 使用ConfigurationClassParser的parse方法处理该类的注解，其中会创建一个类型为ConfigurationClass的对象configClass来包装当前这个配置类（应用主类就是一个配置类），使用configClass作为参数，调用doProcessConfigurationClass方法来处理该类包含的注解。其中@Import注解的处理主要在processImports方法定义。

      /**
 * Apply processing and build a complete {@link ConfigurationClass} by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or {@code null} if none found or previously processed
 */
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
		throws IOException {

	if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
		// Recursively process any member (nested) classes first
		processMemberClasses(configClass, sourceClass);
	}

	// Process any @PropertySource annotations
	
	...
	
	// Process any @ComponentScan annotations
	
	...

	// Process any @Import annotations
	processImports(configClass, sourceClass, getImports(sourceClass), true);

	// Process any @ImportResource annotations
	
	...

    // 注意@Bean注解的方法的处理，
    // 这里针对每个方法产生MethodMetadata对象，
    // 将该对象放到configClass对象的beanMethods集合中
    // 之后在使用ConfigurationClassBeanDefinitionReader来生成bean对象。
	// Process individual @Bean methods
	
	...

	// Process default methods on interfaces
	
	...

	// Process superclass, if any
	
	...

	// No superclass -> processing is complete
	return null;
}

       

@Import(AutoConfigurationImportSelector.class)注解的处理

  • @EnableAutoConfiguration内部包含@Import(AutoConfigurationImportSelector.class)注解，AutoConfigurationImportSelector为DeferredImportSelector接口的实现类，会在BeanFactory对所有BeanDefinition处理后执行来进行SpringBoot自动配置类的加载、导入，并基于@Conditional条件化配置来决定是否将该配置类内部定义的Bean注册到Spring容器。

  • @Import注解需要通过ConfigurationClassParser的processImports方法来处理。processImports方法的实现如下：

    private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
		Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

	if (importCandidates.isEmpty()) {
		return;
	}

	if (checkForCircularImports && isChainedImportOnStack(configClass)) {
		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
	}
	else {
		this.importStack.push(configClass);
		try {
			for (SourceClass candidate : importCandidates) {
			
			    // 处理ImportSelector接口的实现类
			    // @EnableAutoConfiguration注解对应的AutoConfigurationImportSelector就是在这里处理。
			    
				if (candidate.isAssignable(ImportSelector.class)) {
					// Candidate class is an ImportSelector -> delegate to it to determine imports
					Class<?> candidateClass = candidate.loadClass();
					ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
					ParserStrategyUtils.invokeAwareMethods(
							selector, this.environment, this.resourceLoader, this.registry);
							
				  // DeferredImportSelector：延迟导入
					if (selector instanceof DeferredImportSelector) {
					
    					// 延迟导入selector
    					// 通过handler方法，
    					// 存到DeferredImportSelectorGrouping这个组中，
    					// 即Group接口的实现类，
    					// 在parse方法处理完所有BeanDefintions后，再处理
    					this.deferredImportSelectorHandler.handle(
    								configClass, (DeferredImportSelector) selector);
					}
					else {
						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
						Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
						processImports(configClass, currentSourceClass, importSourceClasses, false);
					}
				}
				
				// 处理ImportBeanDefinitionRegistrar接口的实现类
				
				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
					// Candidate class is an ImportBeanDefinitionRegistrar ->
					// delegate to it to register additional bean definitions
					Class<?> candidateClass = candidate.loadClass();
					ImportBeanDefinitionRegistrar registrar =
							BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
					ParserStrategyUtils.invokeAwareMethods(
							registrar, this.environment, this.resourceLoader, this.registry);
					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
				}
				
				// 正常使用@Configuration注解的配置类的处理
				else {
					// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
					// process it as an @Configuration class
					this.importStack.registerImport(
							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
					processConfigurationClass(candidate.asConfigClass(configClass));
				}
			}
		}
	
	    ...
	    
	}
}

     

  • 对于@Import注解导入的类，分三种情况进行处理：

    • 实现了ImportSelector接口的类，其中AutoConfigurationImportSelector类的处理属于这种类型。

    • 由源码可知，由于AutoConfigurationImportSelector为DeferredImportSelector接口的实现类，故将AutoConfigurationImportSelector放到ConfigurationClassParser类的成员属性deferredImportSelectorHandler内部的deferredImportSelectors集合中。

    • 在ConfigurationClassParser在parse方法中，对所有BeanDefinitions处理完之后，再遍历deferredImportSelectorHandler的deferredImportSelectors集合，通过deferredImportSelector来获取SpringBoot自动配置类列表并处理；

  • 实现了ImportBeanDefinitionRegistrar接口的类，如在mybatis框架中@MapperScan的注解处理器MapperScannerRegistrar就是实现了ImportBeanDefinitionRegistrar接口；
  • 使用@Configuration注解的类，其中应用代码的配置类和AutoConfigurationImportSelector导入的每个自动配置类都是在这里处理，其处理逻辑主要在processConfigurationClass方法定义：

    • ConfigurationClass类型对象的创建：创建一个类型为ConfigurationClass对象configurationClass来包装该配置类，其中ConfigurationClass的设计目的为：通过统一的方式来封装使用了@Configuration注解的类，从而方便内部对使用了@Configuration注解的类的处理；

    • 配置类的注解处理：将该configurationClass对象作为processConfigurationClass方法的参数，调用processConfigurationClass方法来处理该配置类所包含的注解：如@PropertySource，@ComponentScan，@Import（此处递归调用processImports）等，内部@Bean注解的方法生成beanMethod对象并放到configurationClass的beanMethods集合。并且将该configurationClass对象放到ConfigurationClassParser的成员属性configurationClasses集合，这样这个集合就包含了应用中所有的使用@Configuration注解的类对应的ConfigurationClass类型的对象；

    • @Bean方法对象创建：在ConfigurationClassPostProcessor中，将ConfigurationClassParser的configurationClasses集合交给ConfigurationClassBeanDefinitionReader，ConfigurationClassBeanDefinitionReader负责遍历configurationClasses集合，对每个configurationClass，遍历configurationClass的beanMethods集合，即针对每个@Bean注解的方法，生成对应的BeanDefinition注册到Spring容器。

3. AutoConfigurationImportSelector：自动配置类的导入

  • 由2的分析可知，AutoConfigurationImportSelector添加到了ConfigurationClassParser的成员属性deferredImportSelectorHandler的deferredImportSelectors集合中，然后在ConfigurationClassParser的parse方法处理完其他BeanDefinitions后调用，具体调用deferredImportSelectorHandler.process方法，如下：

     public void parse(Set<BeanDefinitionHolder> configCandidates) {
 
     // 处理其他使用@Configuration注解的类
     
 	for (BeanDefinitionHolder holder : configCandidates) {
 		BeanDefinition bd = holder.getBeanDefinition();
 		try {
 			if (bd instanceof AnnotatedBeanDefinition) {
 				parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
 			}
 			else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
 				parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
 			}
 			else {
 				parse(bd.getBeanClassName(), holder.getBeanName());
 			}
 		}
 		catch (BeanDefinitionStoreException ex) {
 			throw ex;
 		}
 		catch (Throwable ex) {
 			throw new BeanDefinitionStoreException(
 					"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
 		}
 	}
 	
 	
     // 延迟执行deferredImportSelector定义的类的处理
 	this.deferredImportSelectorHandler.process();
 }

     

  • DeferredImportSelectorHandler：ConfigurationClassParser的一个内部私有类，该类内部维护了一个类型为DeferredImportSelectorHolder的deferredImportSelectors列表。在SpringBoot中该deferredImportSelectors列表大小其实就是1，即包含一个AutoConfigurationImportSelector对象。

DeferredImportSelectorHandler的process方法：自动配置类导入的内部实现

1. 功能设计

  1. 通过DeferredImportSelector从spring-boot-autoconfigure包的META-INF/spring.factories文件中获取EnableAutoConfiguration作为key，对应的自动配置类列表，如下：

    # Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

...

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

...

    在spring-boot-autoconfigure项目对应的RedisAutoConfiguration如下：

    @Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@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;
	}

}

     

  2. 然后遍历类名列表，加载、导入对应的配置类，相当于在应用中添加了使用@Configuration注解的配置类，然后创建Configuration类型的对象configurationClass来包装该配置类，最后将configurationClass对象交给ConfigurationClassParser的processImports方法来进行递归调用。

  3. processImports方法的作用如前文所分析：对于配置类（即不是ImportSelector接口实现类和ImportBeanDefinitionRegistrar接口实现类），调用processConfigurationClass方法处理该自动配置类上面的其他注解，并将该自动配置类内部使用@Bean注解的方法，条件化生成bean注册到Spring容器，从而可以提供特定功能组件的默认实现，实现SpringBoot的自动配置功能，即应用代码可以直接通过@Autowried注入某个功能组件，而不需要显示配置。

2. 实现

（1）DeferredImportSelectorHandler：DeferredImportSelector处理器，是使用DeferredImportSelector完成自动配置类导入的功能主类

  • DeferredImportSelectorHandler的类定义如下： 
    private class DeferredImportSelectorHandler {

	@Nullable
	private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();

    ...

	public void process() {
		List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
		this.deferredImportSelectors = null;
		try {
			if (deferredImports != null) {
				DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
				deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);

				// 遍历deferredImports集合并注册到DeferredImportSelectorGroupingHandler表示的组中
				deferredImports.forEach(handler::register);
				
				// 具体为通过DeferredImportSelectorGrouping来汇总这些deferredImports
				handler.processGroupImports();
			}
		}
		finally {
			this.deferredImportSelectors = new ArrayList<>();
		}
	}

}

     

  • 主要通过DeferredImportSelectorGroupingHandler来对deferredImportSelectors集合进行包装，表示deferredImportSelectors集合的deferredImportSelector属于同一个组，然后通过processGroupImports方法来完成以上所述的功能设计。

（2）DeferredImportSelector的分组Group的体系结构设计：自底向上分析

  1. DefaultDeferredImportSelectorGroup：同一组的自动配置类相关信息的汇总，实际加载的执行器。

    private static class DefaultDeferredImportSelectorGroup implements Group {

	private final List<Entry> imports = new ArrayList<>();

	// 实际执行自动配置类信息加载
	// selector.selectImports返回自动配置类的类全限定名列表
	
	@Override
	public void process(AnnotationMetadata metadata, DeferredImportSelector selector) {
		for (String importClassName : selector.selectImports(metadata)) {
			this.imports.add(new Entry(metadata, importClassName));
		}
	}

	@Override
	public Iterable<Entry> selectImports() {
		return this.imports;
	}
}

class Entry {

		private final AnnotationMetadata metadata;

		private final String importClassName;

       ...
}

    1. DeferredImportSelector.Group接口实现，包含一个Entry列表，每个Entry对应一个自动配置类，包含配置类名importClassName和注解信息metadata；

    2. process方法：调用给定的DeferredImportSelector的selectImports方法，从META-INF/spring.factories获取key为EnableAutoConfiguration对应的自动配置类（类全限定名），对每个自动配置类，创建对应的Entry实例，然后保存到imports集合。

    3. selectImports的实现：SpringBoot提供的DeferredImportSelector接口的实现类AutoConfigurationImportSelector，对selectImports方法的实现：

      @Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
	if (!isEnabled(annotationMetadata)) {
		return NO_IMPORTS;
	}
	AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
			.loadMetadata(this.beanClassLoader);
			
	// 核心实现在getAutoConfigurationEntry
	
	AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(
			autoConfigurationMetadata, annotationMetadata);
	return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

/**
 * Return the {@link AutoConfigurationEntry} based on the {@link AnnotationMetadata}
 * of the importing {@link Configuration @Configuration} class.
 * @param autoConfigurationMetadata the auto-configuration metadata
 * @param annotationMetadata the annotation metadata of the configuration class
 * @return the auto-configurations that should be imported
 */
protected AutoConfigurationEntry getAutoConfigurationEntry(
		AutoConfigurationMetadata autoConfigurationMetadata,
		AnnotationMetadata annotationMetadata) {
	if (!isEnabled(annotationMetadata)) {
		return EMPTY_ENTRY;
	}
	AnnotationAttributes attributes = getAttributes(annotationMetadata);
	
    // getCandidateConfigurations：
    // 这里完成从META-INF/spring.factories文件获取配置类列表
    
	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方法的实现：使用SpringFactoriesLoader.loadFactoryNames方法，从META-INF/spring.factories文件获取key为EnableAutoConfiguration对应的配置类列表：

      /**
 * Return the auto-configuration class names that should be considered. By default
 * this method will load candidates using {@link SpringFactoriesLoader} with
 * {@link #getSpringFactoriesLoaderFactoryClass()}.
 * @param metadata the source metadata
 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
 * attributes}
 * @return a list of candidate configurations
 */
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;
}

/**
 * Return the class used by {@link SpringFactoriesLoader} to load configuration
 * candidates.
 * @return the factory class
 */
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
	return EnableAutoConfiguration.class;
}

       

  2. DeferredImportSelectorGrouping：同一组自动配置类信息的加载和汇总的管理器，类定义如下：

    private static class DeferredImportSelectorGrouping {

	private final DeferredImportSelector.Group group;

	private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>();

	...
	
	/**
	 * Return the imports defined by the group.
	 * @return each import with its associated configuration class
	 */
	public Iterable<Group.Entry> getImports() {
		for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
		
		// 将每个DeferredImportSelector作为DefaultDeferredImportSelectorGroup的process方法的参数
		// 在DefaultDeferredImportSelectorGroup内部完成配置类信息加载和保存汇总
			
			this.group.process(deferredImport.getConfigurationClass().getMetadata(),
					deferredImport.getImportSelector());
		}
		return this.group.selectImports();
	}
}
    1. 包含一个DeferredImportSelector集合和DefaultDeferredImportSelectorGroup的一个引用；。

    2. getImports方法：遍历DeferredImportSelector集合，将每个DeferredImportSelector作为参数，调用DefaultDeferredImportSelectorGroup的process方法，在DefaultDeferredImportSelectorGroup内部使用DeferredImportSelector完成配置类信息的加载并保存汇总。

  3. DeferredImportSelectorGroupingHandler：包含多个自动配置类的组，通过map维护组名和组管理器DeferredImportSelectorGrouping的映射。 DeferredImportSelector的分组Group的体系结构设计的主类。
    类定义如下，核心方法为processGroupImports：

    private class DeferredImportSelectorGroupingHandler {

    // key为组名，value为一个组DeferredImportSelectorGrouping
	private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();

	private final Map<AnnotationMetadata, ConfigurationClass> configurationClasses = new HashMap<>();

	public void register(DeferredImportSelectorHolder deferredImport) {
		Class<? extends Group> group = deferredImport.getImportSelector()
				.getImportGroup();
		DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
				(group != null ? group : deferredImport),
				key -> new DeferredImportSelectorGrouping(createGroup(group)));
		grouping.add(deferredImport);
		this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
				deferredImport.getConfigurationClass());
	}

	public void processGroupImports() {

	   // 在处理主类的@EnableAutoConfiguration注解时，
       // 已经添加好的deferredImportSelector集合所在的组
		for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {

            // getImports返回的是Group.Entry列表
       	    // 即配置类的列表，
       	    // 每个Entry表示一个自动配置类，
       	    // 包含配置类的全限定名和注解信息
			grouping.getImports().forEach(entry -> {

				// 对每个自动配置类生成一个对应的ConfigurationClass对象
				ConfigurationClass configurationClass = this.configurationClasses.get(
						entry.getMetadata());
				try {

                    // 当做一个正常的使用@Configuration注解的配置类来处理，
           			// 调用processImports方法处理该配置类的@Import注解
					processImports(configurationClass, asSourceClass(configurationClass),
							asSourceClasses(entry.getImportClassName()), false);
				}
				catch (BeanDefinitionStoreException ex) {
					throw ex;
				}
				catch (Throwable ex) {
					throw new BeanDefinitionStoreException(
							"Failed to process import candidates for configuration class [" +
									configurationClass.getMetadata().getClassName() + "]", ex);
				}
			});
		}
	}

    ...

}

    1. grouping.getImports().forEach：遍历自动配置类列表，对每个自动配置类，跟处理应用代码中使用@Configuration注解的类一样，创建ConfigurationClass类型的configurationClass对象来包装该自动配置类，将configurationClass对象作为参数调用ConfigurationClassParser的processImports方法

    2. processImports方法：由于自动配置类就是使用@Configuration注解的类，所以直接调用ConfigurationClassParser的processConfigurationClass方法，跟ConfigurationClassPostProcessor处理应用代码中@Configuration注解的类一样，处理该自动配置类的注解，包括@PropertySource，@ComponentScan，@Import，内部方法@Bean等注解的处理，具体在前面已经描述过。

SpringBoot-自动配置源码解析
Qi.zheng
08-18 1万+
接着上一篇博客《 SpringBoot-快速搭建WEB工程》提出的需要分析的三个方面：我们来深入的探究SpringBoot是如何在没有一个配置文件的情况下为我们启动好一个完整的WEB工程的，首先我们从@SpringBootApplication 开始这里的分析会剖出一些次要的信息沿着主干走，所以可能会有一些略过的地方。以下源码截取自spring-boot-1.4.0.RELEASE@Target(E
Spring Boot面试杀手锏————自动配置原理
热门推荐
Morty的技术乐园
11-07 19万+
引言 不论在工作中，亦或是求职面试，Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外，如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然，作为Spring Boot的精髓，自动配置原理的工作过程往往只有在“面试”的时候才能用得上，但是如果在工作中你能够深入的理解Spring Boot的自动配置原理，将无往不利。 Spr...
SpringBoot —— @ImportResource
看了就会暴富的博客！
11-26 738
用法 在启动类上增加@ImportResource注解，引入对应配置文件。 如果不使用@ImportResource()注解，程序根本不能对我们spring的配置文件进行加载，所以我们需要将spring配置文件加载到容器里。 示例 @ImportResource({"classpath:xxx.xml"}) public class XXXApplication { public static void main(String[] args) { SpringApplica
SpringBoot加载配置文件源码解析
zhangweiocp的专栏
10-12 585
SpringBoot通过事件广播机制通知ConfigFileApplicationListener这个监听器来加载properties和yaml文件。关于SpringBoot事件编程模型可参考：SpringBoot事件编程模型解析。 SpringBoot一站式启动过程中，会经过环境准备阶段： ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArgume...
第四章 ：springBoot自动配置原理，加载过程
小爷欣欣
03-03 1713
1，springboot启动时加载住配置类，开启了自动配置功能 点开程序启动要走的第一个注解： 可以看到： 有个： @EnableAutoConfiguration 这个注解的作用：利用： @AutoConfigurationImportSelector（扫描器）给容器中导入一些组件，有那些组件呢？ 可以把上面的注解一级一级点进去，在AutoConfigurationIm...
jeecg boot笔记(一)-使用模糊查询
小飞的博客
09-10 2963
1、引入 JInput importJInputfrom'@/components/jeecg/JInput.vue' 2、使用 <j-inputplaceholder="请输入名称"v-model="queryParam.name"></j-input>
SpringBoot 2 系列五：自动配置源码分析
jianfeng_rpm的博客
12-18 233
目录自动配置原理理解引导加载自动配置类@SpringBootApplication@EnableAutoConfiguration`@AutoConfigurationPackage` 自动配置包注解`AutoConfigurationImportSelector`按需自动配置定制化配置自动配置流程总结 自动配置原理理解 SpringBoot 自动加载所有配置，按照需要加载，如果手动配置了，就以用户配置的为主。每一个配置类都会绑定配置一个 xxxProperties 类，每个 xxxProperties 类
springboot之三：原理分析之自动配置condition
09-06
这些文件可能包含了示例代码或者Spring Boot自动配置的相关源码，可以帮助我们更深入地理解条件判断如何工作，以及如何自定义条件注解来适应特定的场景。 在实际开发中，我们可以利用这些条件注解来实现细粒度的...
【SpringBoot源码】SpringBoot自动配置原理
最新发布
xajh_czbk的博客
08-22 854
EnableAutoConfiguration注解通过@Import(AutoConfigurationImportSelector.class)向容器中导入了AutoConfigurationImportSelector组件，它实现了DeferredImportSelector，并间接实现了ImportSelector接口，重写了selectImports()方法，帮助我们返回所有需要被注册为bean的类全限定类名的数组集合。//...
SpringBoot 源码学习——SpringBoot 自动装配源码解析 +Spring 如何处理配置类的
m0_71563599的博客
09-20 446
SpringBoot 通过 SPI 的机制，在我们程序员引入一些 starter 之后，扫描外部引用 jar 包中的文件，将文件中配置的类型信息加载到 Spring 容器，实现引入 starter 即可开启相关功能的操作，大大简化了程序员手动配置 bean，即开即用。SpringBoot 并不是 Spring 的替代品，而是利用 Spring 加上约定大于配置的思想，方便程序员开发的框架。所以其底层还是 Spring 那一套。
Spring源码 - DeferredImportSelector实现分析
it_lihongmin的博客
06-26 3522
在分析DeferredImportSelector之前，根据名字Deferred（延迟的）ImportSelector。ImportSelector则是将selectImports返回的字符串数组，注册成为Bean，详细过程可以参见：Spring源码-ImportSelector实现分析。那么有几个问题：1）、怎么延迟的；2）、执行时机，或者在什莫时候被调用的；3）、返回后的字符串数组，怎么注册成Bean（或者Beandefinition）。 之前在分析Spring源码时，并没有分析D...
SpringBoot自动装配原理分析二：执行的时机ConfigurationClassParser
zhengguofeng0328的博客
07-17 1229
SpringBoot自动装配原理分析二：执行的时机ConfigurationClassParser
Springboot 加载配置文件源码分析
wbo
11-21 923
Springboot 加载配置文件源码分析 本文的分析是基于springboot 2.2.0.RELEASE。 本篇文章的相关源码位置:https://github.com/wbo112/blogdemo/tree/main/springbootdemo/springboot-profiles springboot加载配置文件如application.yml是通过org.springframework.boot.context.config.ConfigFileApplicationListener这个
@EnableAutoConfiguration处理逻辑
温安适的专栏
07-10 422
这个系列分为5篇 1. @Component，@Service等注解是如何被解析的 2.@Enable驱动原理 3.@EnableAutoConfiguration处理逻辑 4.spring，springBoot事件（最晚20200719） 5.自定义springboot starter（最晚20200726） 引言 工作中，我们直接或间接的，用到@EnableAutoConfiguration注解。 今天，我们就聊聊@EnableAutoConfiguration的处理逻辑。 找核
maven项目转成spring boot项目有两种方式
徐建的专栏
12-27 1万+
maven项目转成spring boot项目有两种方式：1、继承方式，pom.xml文件中配置 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEAS
Failed to introspect Class [org.springframework.boot.autoconfigure.异常的解决
m0_37837382的博客
06-01 5万+
最近在看spring-boot，有看到利用redis，将session放到缓存中，实现分布式系统的session共享，引入下图的jar包 加入了启用redisHttpSesion的配置。 配置redis java.lang.IllegalStateException: Failed to introspect Class [org.springframework.boot.autoc...
SpringBoot 多数据源配置分析
lkr_lkr的博客
05-25 494
SpringBoot 多数据源配置分析前言application.properties 方式配置bean.xml 方式配置多数据源设置默认数据源 前言 我们配置主从数据源的时候，就需要多数据源配置。 application.properties 方式配置 #数据库连接 Master spring.datasource.master.username=root spring.datasource.master.password=12345678 spring.datasource.master.jdbc-ur
Spring Boot注解——@ConditionalOnMissingBean和@ConditionalOnBean
MADE_哒哒
02-18 2602
@ConditionalOnMissingBean和@ConditionalOnBean作用是相反的 主要介绍@ConditionalOnMissingBean @Configuration public class RedisConfig { @Bean @ConditionalOnMissingBean(name="redisTemplate") public Redi...
springBean注册之@Import注解解析
clyu的博客
04-05 442
前言 本文重点研究@Import注解的使用与源码解析 从 SpringIOC源码：@Configuration配置类解析过程一文中，Spring通过一系列操作后，会使用ConfigurationClassParser类的processImports方法解析@Import，本文源码讲解就从这里开始 一、@Import的使用 说明：只能标注在类上，属性是 Class<?>[] value...
Spring Boot Environment源码解析：分散配置实战与扩展
掌握Spring Boot的Environment源码可以帮助开发者更好地管理应用程序的配置，实现灵活的环境切换，同时理解如何在生产环境中扩展和定制这个核心组件，对于提升项目的可维护性和适应性具有重要意义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值