前述

在解析spring boot starter自动装配机制之前，我们先来回顾一下web工程是如何搭建的：

1. gradle/pom文件中引入项目依赖jar包；

2. 配置web.xml，Servlet配置，拦截器设置，Listener配置…;

3. 数据库连接，配置spring事务；

4. 配置视图解析器；

5. 开启注解，自动扫描功能

6. 配置完成后部署tomcat，调试等…

   …

在搭建这些环境的时候是非常耗时间耗精力的，而且有时还会缺斤少两，连蹦bug…

而有了springboot之后，所有的环境配置就会非常便捷。

​

自动配置原理

我们先来搭建一个最简单的springboot工程，如下：

application.properties文件如下：

server.port=8080

这样，我们就搭好了一个最简单的springboot工程，随后就可以启动了。

我们或许有点好奇，明明自己就只配置了一个端口号，剩下的自己啥也没配，为啥这个web程序就可以启动了？？为什么？？？

​

接下来，我们来分析以下，以下是我的思路分析过程（为了防止后面看着看着就迷路，我先来个大纲）：

1. SpringbootApplication启动类的注解@SpringBootApplication，即程序入口；
2. @EnableAutoConfiguration注解（bean的装配与加载）重点；
3. @ComponentScan注解（bean的扫描与发现）

​

程序入口

我们先来看一下主程序入口：

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

如以上代码，很常见，是一个main方法启动类，与javaEE程序不同的是，它被一个@springbootApplication注解修饰，那么这个注解何德何能，可以让一个web应用跑起来呢？

走进@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 {@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 {};@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;}

我们暂时不要关注这个类的方法，我们先看看这个类上的几个注解：

• @SpringBootConfiguration：在这里可以理解为是一个@Configuration注解；
• @EnableAutoConfiguration：自动装配的核心！！用作bean的装配与加载
• @ComponentScan：扫描包，用作bean的发现（此处扫描当前main下面app的所在包及其下属包）

​

@EnableAutoConfiguration

我们来看看它究竟做了什么事：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";Class<?>[] exclude() default {};String[] excludeName() default {};}

点进去之后可以发现有两个比较重要的注解：

• @AutoConfigurationPackage：其作用是自动配置的包；
• @Import：他的作用是导入需要自动配置的组件；

@AutoConfigurationPackage如下：

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

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {@Overridepublic void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));}@Overridepublic Set<Object> determineImports(AnnotationMetadata metadata) {return Collections.singleton(new PackageImports(metadata));}}

以上代码的作用就是：

加载启动类所在的包下的主类与子类的所有组件注册到spring容器。

那么问题来了，要搜集并注册到spring容器的那些beans来自哪里？

我们的@import注解就排上用场了，我们也可以细心的发现，@import注解里包括了一个AutoConfigurationImportSelector.class类，那么这个类具体是干嘛的呢？

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {...//选择导入@Overridepublic String[] selectImports(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return NO_IMPORTS;}AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}
}

getAutoConfigurationEntry（）如下：

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);}
//候选者方法如下
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {//扫描所有jar包类路径下  META‐INF/spring.factories 所有EnableAutoConfiguration的值 把扫描到的这些文件的内容包装成properties对象 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;}
//获取被@EnableAutoConfiguration修饰的类
protected Class<?> getSpringFactoriesLoaderFactoryClass() {return EnableAutoConfiguration.class;}

META‐INF/spring.factories 所有EnableAutoConfiguration的值:

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
...略

看了以上代码，我们可以发现``AutoConfigurationImportSelector`干了这么几件事：

1. 扫描所有jar包类路径下 META‐INF/spring.factories ；
2. 把扫描到的这些文件的内容包装成properties对象 ；
3. 从properties中获取到EnableAutoConfiguration.class类（类名）对应的值。

​

来小结一下：

@EnableAutoConfiguration这个注解干了那些事？

• 通过@import注解，引入了AutoConfigurationImportSelector这个类；
• AutoConfigurationImportSelector这个类扫描了所有被@EnableAutoConfiguration修饰的类；
• 通过上面扫描到的类，通过@AutoConfigurationPackage将其扫描到的类装配到容器中；

​

接下来我们来看一下被@EnableAutoConfiguration修饰的类长什么样：

以下解析是以HttpEncodingAutoConfiguration为例解释自动装配的原理的。

@Configuration(proxyBeanMethods = false)//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件 
@EnableConfigurationProperties(ServerProperties.class)//启动指定类的 ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把 HttpEncodingProperties加入到ioc容器中   
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果 满足指定的条件，整个配置类里面的配置就会生效；    判断当前应用是否是web应用，如果是，当前配置类生效   
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类 CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；   
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) //判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的 //即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {//与SpringBoot的配置文件映射 private final Encoding properties;//只有一个有参构造器的情况下，参数的值就会从容器中拿，与上述的@EnableConfigurationProperties引进来的文件相呼应。 public HttpEncodingAutoConfiguration(ServerProperties properties) {this.properties = properties.getServlet().getEncoding();}@Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取 @ConditionalOnMissingBean //判断容器没有这个组件？public CharacterEncodingFilter characterEncodingFilter() {CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();filter.setEncoding(this.properties.getCharset().name());filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));return filter;}...略}
}

ServerProperties文件如下

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {/*** Server HTTP port.*/private Integer port;/*** Network address to which the server should bind.*/private InetAddress address;@NestedConfigurationPropertyprivate final ErrorProperties error = new ErrorProperties();...略
}

首先我们来分析一下：

1. @Configuration与@bean的结合使用相当于是：创建一个基于java代码的配置类，可以用来替代相应的xml配置文件。

2. @EnableConfigurationProperties：引入外部文件，与springboot的配置文件形成映射。

3. 其余就是各种@condition条件，达到条件之后，这个类才生效；

   下面是一些condition条件的具体应用：

   @Conditional扩展注解	作用（判断是否满足当前指定条件）
   @ConditionalOnJava	系统的java版本是否符合要求
   @ConditionalOnBean	容器中存在指定Bean；
   @ConditionalOnMissingBean	容器中不存在指定Bean；
   @ConditionalOnExpression	满足SpEL表达式指定
   @ConditionalOnClass	系统中有指定的类
   @ConditionalOnMissingClass	系统中没有指定的类
   @ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
   @ConditionalOnProperty	系统中指定的属性是否有指定的值
   @ConditionalOnResource	类路径下是否存在指定资源文件
   @ConditionalOnWebApplication	当前是web环境
   @ConditionalOnNotWebApplication	当前不是web环境
   @ConditionalOnJndi	JNDI存在指定项

​

@ComponentScan注解（bean的扫描与发现）

这块就是扫描springboot app程序的所在包，好像也没什么可说的。

总结

springboot的自动状态，我们大致可总结为这么几个步骤：

1. 主程序中的@springbootApplication修饰；

2. 在@EableAutoConfiguration注解中（实现bean的装配与加载），实现了以下两步：

   • @Import引入的AutoCongurationImportSelector负责找到需要导入bean；
   • @AutoConfigurationPackage负责将其bean加载到容器中；

   被@EableAutoConfiguration修饰的注解：

   • 通过@Conguration与@bean使用java的方式配置bean；
   • @EnableConfigurationProperties引入配置文件属性，与spring boot的配置文件相映射（这也是为什么你在application.yml里面配置文件的时候可以生效）;
   • @Conditionxx条件，满足则存在；

3. @CompomentScan扫描包。（实现bean的扫描与发现）