功能分析

传统的Spring项目会有很多的配置文件，比如我们要使用Redis，一般除了对应的依赖的jar包我们还需要在application.xml里面配置JedisConnectionFactory、JedisPoolConfig、RedisTemplate。但是如果使用SpringBoot的话，系统会根据pom.xml里面的jar包，自动生成这些类并且注入到IOC容器当中。

1. 传统Spring项目中需要配置

<bean id="jedisConnectionFactory" class="...JedisConnectionFactory"></bean>
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"></bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"></bean>

2. 而使用SpringBoot的话，除了pom.xml引入相应的jar包外，只需要在application.properties配置对应的属性值即可

概述

自动装配的过程：

1. 通过各种注解+继承，引入包含自动装配核心方法的类
2. SpringApplication.run(Application.class, args)在运行时，调用自动装配方法
3. 自动装配方法会读取spring-boot-autoconfigure.jar里面的spring.factories配置文件，配置文件中有所有自动装配类的配置类的类名
4. 生成对应功能的Configuration类，这些功能配置类要生效的话，会去classpath中找是否有该类的依赖类（也就是pom.xml必须有对应功能的jar包才行）
5. 配置类里再通过判断生成最后的功能类，并且配置类里面注入了默认属性值类，功能类可以引用并赋默认值。生成功能类的原则是自定义优先，没有自定义时才会使用自动装配类。

综上所述，要想自动装配一个类需要满足2个条件：

1. spring.factories里面有这个类的配置类（一个配置类可以创建多个围绕该功能的依赖类）
2. pom.xml里面需要有对应的jar包

自动装配的结果：

1. 根据各种判断和依赖，最终生成了业务需要的类并且注入到IOC容器当中了
2. 自动装配生成的类赋予了一些默认的属性值

注解引用线路图

复合注解+@import加载了对应的类进来，然后在程序启动方法里面，间接调用自动加载类的方法

@SpringBootApplication -->@EnableAutoConfiguration -->@Import(EnableAutoConfigurationImportSelector.class)
-->extends AutoConfigurationImportSelector -->selectImports() -->getExcludeAutoConfigurationsProperty()
通过注解引用，最终在SpringApplication.run()方法的时候，会调用selectImports()，最终加载自动装配

private List<String> getExcludeAutoConfigurationsProperty() {
            RelaxedPropertyResolver resolver = new RelaxedPropertyResolver(this.environment, "spring.autoconfigure.");
    }

Redis自动装配示例

1. 从spring-boot-autoconfigure.jar/META-INF/spring.factories中获取120多个默认功能配置类，其中包括redis的功能配置类RedisAutoConfiguration的全限定名

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

2. RedisAutoConfiguration配置类生效的一个条件是@ConditionalOnClass ：JedisConnection.class, RedisOperations.class, Jedis.class,所以会去classpath下去查找对应的class文件

@Configuration
@ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class })
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
        @Bean
        @ConditionalOnMissingBean(RedisConnectionFactory.class)
        public JedisConnectionFactory redisConnectionFactory()
                throws UnknownHostException {
            return applyProperties(createJedisConnectionFactory());
        }
}

3. 如果pom.xml有对应的jar包,就能匹配到对应依赖class:JedisConnection.class, RedisOperations.class, Jedis.class

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

4. 匹配成功，这个功能配置类才会生效，同时会注入默认的属性配置类@EnableConfigurationProperties(RedisProperties.class)

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String password;
    private int port = 6379;

5. Redis功能配置里面会根据条件生成最终的JedisConnectionFactory、RedisTemplate,条件就是IOC环境里面，没有用户自定义的@ConditionalOnMissingBean(RedisConnectionFactory.class)、RedisTemplate

@Configuration
@ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class })
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
        @Bean
        @ConditionalOnMissingBean(RedisConnectionFactory.class)
        public JedisConnectionFactory redisConnectionFactory()
                throws UnknownHostException {
            return applyProperties(createJedisConnectionFactory());
        }

        @Bean
        @ConditionalOnMissingBean(name = "redisTemplate")
        public RedisTemplate<Object, Object> redisTemplate(
                RedisConnectionFactory redisConnectionFactory)
                        throws UnknownHostException {
            RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
}

6. 最终创建好的默认装配类，会通过功能配置类里面的 @Bean注解，注入到IOC当中

核心注解

@SpringBootApplication整合了3个注解：SpringBootConfiguration、EnableAutoConfiguration、ComponentScan

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {
}

1. @SpringBootConfiguration：实际上就是@Configuration，表明这是一个IOC容器的配置类，相当于说明该bean是一个spring中的xml文件。

@Configuration
public class ShiroConfig {
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
}

2. @ComponentScan：指定了Spring中的指定MVC环境扫描包和Spring IOC的扫描包，扫描路径就是该类所在的所有包。SpringBoot的注解扫描所有的同路径下的类，@Controller类归位MVC类，其它类为Spring的类

常规mvc配置指定包
<context:component-scan base-package="com.test.Action" />  

Spring也要指定Spring的注解类的扫描路径
<context:component-scan base-package="com.test" />

3. @EnableAutoConfiguration：表示开启Spring Boot自动配置功能，Spring Boot会根据应用的依赖、自定义的bean、classpath下有没有某个类等等因素来猜测你需要的bean，然后注册到IOC容器中。

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

4. @Conditional注解表示在满足某种条件后才初始化一个bean或者启用某些配置。自定义编写条件类，实现Condition接口，并覆盖它的matches()方法,比如MyService类依赖于JdbcTemplateCondition.class个条件类，而JdbcTemplateCondition.class调节类的满足条件是在classpath下面可以加载JdbcTemplate这个类。

@Conditional(JdbcTemplateCondition.class)
@Service
public MyService service() {
    ......
}

public class JdbcTemplateCondition implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        try {
        conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate");
            return true;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return false;
    }
}

5. @ConditionalOnClass：表示只要在classpath下找得到对应的class文件，该配置类、或者方法才会生效。
   比如classpath中有Billy.class，这个配置类才生效，也就是Fighter这个Bean才会注入到IOC容器中

@Configuration
@ConditionalOnClass({Billy.class})
public class VanConfig {
    @Bean
    public Fighter billy(){
        return new Billy();
    }
}

5. @ConditionalOnBean：表示在IOC环境下，containsBean为true的时候，才通过。
   例如下面，即使classpath下存在Test.class，但是Test.class没有注入到IOC中，也会报错。HelloService注入失败。

    @Bean
    @ConditionalOnBean(Test.class)
    public HelloService test(){
        return new HelloService();
    }

6. @ConditionalOnMissingBean 这个是个很厉害的注解，实现默认配置时自定义优先。如果上下文（IOC环境）中已经有这个Bean了就忽略，没有这个Bean的话，才执行返回默认自动装配Bean。
   比如我们应用要依赖Animal接口，如果我们手动注入一个animal，那么就以注入的bean为准，如果未注入，则会被@ConditionalOnMissingBean检测到，就使用默认的AutoConfigAnimal作为bean。

@RestController
public class MyRun {
    @Autowired
    private Animal animal;

    @RequestMapping("/auto/home")
    public String home(){
        return animal.eat();
    }
}

@Component("animal")
public class Human implements Animal{
    public String eat() {
        return "eat rice";
    }
}

@Configuration
public class TestConfig {
    @Bean
    @ConditionalOnMissingBean(Animal.class)
    public Animal test(){
        return new AutoConfigAnimal();
    }
}

public class AutoConfigAnimal implements Animal{
    public String eat() {
        return "eat anything";
    }
}

依赖的注解（Redis示例）

• @SpringBootApplication：sb项目应用启动类的注解，其实是3个注解的组合：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan，其中在自动装配中起作用的是第二个

• @EnableAutoConfiguration：表示SB应用启动自动装配的功能（包括加载对应的Bean到IOC容器中，且根据默认配置对属性赋值）

• @Import(EnableAutoConfigurationImportSelector.class)：这个注解比较厉害，可以把没有注册到IOC中的Bean强行注册到IOC中,表示启动自动配置功能需要引入EnableAutoConfigurationImportSelector.class才行

• @Configuration

• @ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class }):表示让RedisAutoConfiguration配置类起作用的话，必须有包含这些类的jar包才行

• @EnableConfigurationProperties(RedisProperties.class)：表示默认引用RedisProperties.class里面的配置

• @ConditionalOnMissingBean(RedisConnectionFactory.class)：表示如果用户没有自定义注入RedisConnectionFactory.class类，才会使用默认的JedisConnectionFactory

代码逻辑：

自动装配的过程

1. 通过各种注解实现了类与类之间的依赖关系，容器在启动的时候Application.run，会调用EnableAutoConfigurationImportSelector.class的selectImports方法（其实是其父类的方法）

2. selectImports方法最终会调用SpringFactoriesLoader.loadFactoryNames方法来获取一个全面的常用BeanConfiguration列表

3. loadFactoryNames方法会读取FACTORIES_RESOURCE_LOCATION（也就是spring-boot-autoconfigure.jar 下面的spring.factories），获取到所有的Spring相关的Bean的全限定名ClassName，大概120多个

4. selectImports方法继续调用filter(configurations, autoConfigurationMetadata);这个时候会根据这些BeanConfiguration里面的条件，来一一筛选，最关键的是
   @ConditionalOnClass，这个条件注解会去classpath下查找，jar包里面是否有这个条件依赖类，所以必须有了相应的jar包，才有这些依赖类，这个时候这些功能配置类才会生效

5. 功能配置类生效后，会获取到依赖的默认属性值类，里面有一些该功能的默认属性值

6. 功能配置类里面配置了最终的功能Bean，这个时候会通过@ConditionalOnMissingBean先判断用户是否自定义了，如果用户没有自定义，就创建一个默认的功能类，并且注入到IOC中

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
            Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            List<String> result = new ArrayList<String>();
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                String factoryClassNames = properties.getProperty(factoryClassName);
                result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
            }
            return result;
    }

spring.factories 文件：

org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

参考博客

https://www.jianshu.com/p/83693d3d0a65