【SpringBoot】一步一步走进源码,看一看我们眼中的自动配置

问一个问题:SpringBoot为啥不需要像SSM那样需要繁琐的配置?

默认大于配置 是不是在你脑海中出现了这六个字,那么你知道为啥么?没事,如果不知道,那就继续看下去被。

@SpringBootApplication

@SpringBootApplication
public class Springboot02ConfigAutoconfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot02ConfigAutoconfigApplication.class, args);
    }
}

@SpringBootApplication 这个注解肯定是大家耳熟能详的,但是你点进去看过吗?

@EnableAutoConfiguration

点进去,发现@SpringBootApplication这个注解里面有一大堆的东西,没事,咱们直接切入正题,看@EnableAutoConfiguration:从字面解释:启动自动配置

@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这个注解里面有两个重要的注解:@AutoConfigurationPackage含义是扫描表明该注解的类所有的包以及子包@Import(AutoConfigurationImportSelector.class)

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
		//代码部分省略
}

我们主要说明一下这个注解:@Import(AutoConfigurationImportSelector.class)

@Import(AutoConfigurationImportSelector.class)

科普:@Import是Spring的底层注解,将括号中的类导入到IOC容器中,默认的id是首字母小写。

然后我们点开这个类,找到selectImports()方法。

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered 
{

	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations()
	);
}

我们看到有:getAutoConfigurationEntry(annotationMetadata) 方法方法名的含义:获取自动配置的实体。我们继续点进去。

	protected AutoConfigurationEntry getAutoConfigurationEntry(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 = getConfigurationClassFilter().filter(configurations);
		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;
	}

//这里,我们需要关心一下getSpringFactoriesLoaderFactoryClass()这个方法,
//他返回的是EnableAutoConfiguration.class。
	protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

在点进去,发现里面如下的方法,其中有一个方法是 loadSpringFactories()方法,方法的含义:加载Spring的工厂类

	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) {
		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()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

代码大意:

  • 首先通过getResou rces(FACTORIES_RESOURCE_LOCATION)得到一个资源,我们来看看这个静态变量。这个静态变量就是"META-INF/spring.factories"
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
  • 然后扫描这个路径下的所有jar包,得到一个url。
  • 然后遍历每一个URL,最后把这些URL扫描到的内容,包装成一个Properties对象。
  • 然后把Properties对象的一些值,加载到返回结果中。

相当于把如下的这些组件加载到IOC容器中。
在这里插入图片描述
总结一下:就是将SpringBoot下的"META-INF/spring.factories"中的这些组件加载到IOC容器中。

以HttpEncodingAutoConfiguration为例,解析自动配置原理。

博主正在努力更新,期待您的阅读。。。

评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值