前言
在最初接触spring 的时候，还是使用xml进行装配，我记得很清楚，当时分别配置了spring-dao.xml , spring-service.xml , spring-controller.xml。然后把所有需要用到的扫包，注入bean，以及配置，全都一股脑的塞进xml中，虽然出发点很好，不用在java代码中硬编码了，但是xml的可读性并不是很好，那阵子，真是痛苦的要命。
正文
后来逐渐的接触到了spring boot，发现这个东西开发起来简单的要命，几乎自己不需要过多的考虑spring 与别的框架整合的问题，所有的一切spring boot已经帮我们做好了，只需要在application.properties 配置一下就完事。
但是spring boot 因为大部分的东西，已经不需要我们在着手了，所以对我们而言，“易学难精”。所以我决定好好把spring boot的原理搞清楚，今天就来说一说自动装配。
这里提前说一下，Spring boot的注入一共有四种方式：
1.通过 spring 模式注解 装配
2.通过@Enable* 注解进行装配
3.通过条件注解装配
4.通过工厂类去加载
下面我会逐一说到以上这几点。
通过 spring 模式注解 装配
模式注解的方式，尽管我们刚开始接触spring，spring mvc 框架，我们也应该会知道他们到底是怎么使用的。
以@Component为首 派生的 @Controller，@Service， @Repository。分别对应了我们工程中的controller层，业务层，和数据持久层，这里我就不做过多结束了，只要把注解放在类上就可以被自动的注入到spring 的context中。
通过@Enable* 注解进行装配
很多人会问为什么有了模式注解的装备，还需要@Enable* 这个注解呢？
这个问题问的非常好，纵观整个Web的发展，我们可以看出来，是一个化繁为简的模块化趋势。
所以@Enable* 也是具有同样道理的，例如@EnableWebMvc就是一个web组件的集合。
@Enable*注解有很多种：
例如说 @EnableAutoConfiguration，@EnableWebMvc，@EnableCaching，@EnableAsync等。
@Enable* 的注入主要又可以分成两种：
1.使用注解的方式注入
2.使用接口编程的方式注入
Tips:但是不管是哪一种方式都是通过 @Enable* 注解定义上的@Import注解引入的。
使用注解的实现（是在Serlet3.0出现的）就是说在@Enable*的@Import注解中，加载的那个类是被@Configuration注入的，例如@EnableWebMvc。
代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.web.servlet.config.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Import;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
//这就是上面说的哪个@Import注解，我们继续查看下DelegatingWebMvcConfiguration 这个类
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}DelegatingWebMvcConfiguration 代码如下（只是摘取了部分，有所省略）：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.web.servlet.config.annotation;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
public DelegatingWebMvcConfiguration() {
}
@Autowired(
required = false
)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
if (!CollectionUtils.isEmpty(configurers)) {
this.configurers.addWebMvcConfigurers(configurers);
}
}
protected void configurePathMatch(PathMatchConfigurer configurer) {
this.configurers.configurePathMatch(configurer);
}
protected void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
this.configurers.configureContentNegotiation(configurer);
}
//省略了之后的方法
}在这里可以很清楚的看到使用@Configuration（这个注解是替代原来在spring xml中注入而出现的注解）进行注入，虽然可以实现功能，但是每次只能注入指定的Bean。
使用编程的方式（是在Serlet3.1出现的）是在@Enable*的@Import注解中，加载的那个类，实现了ImportSelector接口，并且重写 selectImports(AnnotationMetadata importingClassMetadata)方法，可以将需要注入的class名称通过条件筛选后放在一个数组中通过返回值进行注入，这是一个我们一直在用的注解，但是为什么我们并不能在朝夕相处的spring boot 中找到相关的代码呢？因为Spring boot 对其进行了封装，下面我们慢慢顺藤摸瓜的去找一下。
新创建一个工程之后，映入眼帘的就是启动类 *Application.java:
代码如下：
package com.harry.springtest;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringtestApplication {
public static void main(String[] args) {SpringApplication.run(SpringtestApplication.class, args);
}
}在main方法中只有一个类的启动方法，那么我们就应该把关注点放在@SpringBootApplication上了
@SpringBootApplication 注解代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.boot.autoconfigure;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.context.TypeExcludeFilter;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.core.annotation.AliasFor;
@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 {
@AliasFor(
annotation = EnableAutoConfiguration.class
)
Class<?>[] exclude() default {};
@AliasFor(
annotation = EnableAutoConfiguration.class
)
String[] excludeName() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackages"
)
String[] scanBasePackages() default {};
@AliasFor(
annotation = ComponentScan.class,
attribute = "basePackageClasses"
)
Class<?>[] scanBasePackageClasses() default {};
}
在这里我们可以看出来@SpringBootApplication是一个组合注解里面运用到了@EnableAutoConfiguration，我们在继续看一下@EnableAutoConfiguration：
package org.springframework.boot.autoconfigure;
//省略应该引入的包
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
private static final AutoConfigurationImportSelector.AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationImportSelector.AutoConfigurationEntry();
private static final String[] NO_IMPORTS = new String[0];
private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
private ConfigurableListableBeanFactory beanFactory;
private Environment environment;
private ClassLoader beanClassLoader;
private ResourceLoader resourceLoader;
public AutoConfigurationImportSelector() {
}
}
//省略以下的所有方法。DeferredImportSelector继承了ImportSelector
spring 条件装配
条件装配一共有两种方法，可以供我们使用：
1.使用@Profile注解
2.使用@Conditional注解
@Profile只是一个站在大局上的条件装配，通过环境变量的某些值，或者是系统变量某些定值，我们可以使用不同的实现方法。这就类似于我们定义了一个接口，通过多态，定义了两个实现类实现了相同的这个接口，但是我们可以通过环境变量去决定，到底是使用哪一个实现类去实现这个方法。
@Conditional注解，就更佳的灵活一些，类似于我们平常代码中的if else 通过判断出来的boolean值，决定到底是不是应该注入这个bean。
@Conditional代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
Class<? extends Condition>[] value();
}我们可以看出来，需要往这个注解中加入一个值，这个值要实现Condition接口。
Condition接口的代码如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.springframework.context.annotation;
import org.springframework.core.type.AnnotatedTypeMetadata;
@FunctionalInterface
public interface Condition {
//关键之处
boolean matches(ConditionContext var1, AnnotatedTypeMetadata var2);
}关键的地方，就在这里了，我们在实现了这个接口的时候，得去重写这个match方法，如果需要注入的地方，就应该返回true，如果是觉得不符合条件，不应该注入的就返回false。
spring boot 通过封装 @Conditional 还有一些派生注解，如下：
@ConditionalOnBean（如果在当前context中存在这个bean，实例化bean）
@ConditionalOnClass（如果在classpath中有这个class，实例化 bean）
@ConditionalOnExpression（当表达式为true的时候，实例化一个bean）
@ConditionalOnMissingBean（如果在当前context中不存在这个bean，实例化一个bean）
@ConditionalOnMissingClass（如果在classpath中没有这个class，实例化一个bean）
@ConditionalOnNotWebApplication（不是web应用,实例化bean）
spring 工厂加载机制
在auto-configuration这个jar包下，或者其他自动注入的jar下，我们都可以看到spring.factories这个文件,例如说下图：
正是通过这个文件，我们把需要注入的类的全路径配在这里，但是问题来了，谁去读这个文件的呢？
在AutoConfigurationImportSelector.class中，我们可以看到以下方法：
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
}我们继续刨根问底的看看SpringFactoriesLoader.loadFactoryNames 这个方法：
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}继续看loadSpringFactories 这个方法：
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
//就在这个地方将META-INF/spring.factories读入进来的。
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryClassName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryName = var9[var11];
result.add(factoryClassName, factoryName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var13) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
}
}
}这下子终于真相大白了。
后记
通过这一次动手实践，根据源码追根溯源，我才终于明白，年轻真的得多看看源码，因为源码能带给我们的不光是在使用过程中减少bug的出现，以下解决bug的事件，更重要的是在设计上以及代码规范上的潜移默化，虽然说现在有一些还不是理解的很透彻，但是不积跬步，无以至千里。
在这里也要感觉 慕课网上小马哥的Spring Boot 2.0深度实践之核心技术篇。
在收听的过程中受益匪浅。