springboot框架介绍(自动配置)

Spring简介

在了解Springboot前, 我们先简单了解下Spring.
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构. Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

什么是Spring Boot

Spring Boot是Spring 为了简化Spring Web开发设计的一个全新框架, 和传统的Spring MVC相比，增加了开发效率,该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置; 做到开箱即用. 可以非常快速地新建一个项目; 大家都知道 "boot"是启动的意思, 所以springboot简单来讲就是一个启动Spring项目的工具;

SpringBoot特性

1.自动装配

Spring Boot自动配置，就是程序需要什么装配什么。比如当程序的pom文件引入了Redis的起步依赖，Spring Boot就会在程序中自动引入默认的Redis的配置RedisTemplate

2.起步依赖

传统的开发过程中，向项目添加依赖常常会选择版本，解决版本冲突，十分耗费精力。而使用Spring Boot的起步依赖，只需要加入Spring-boot-starter-web的依赖，便会自动引入Spring MVC功能的相关依赖.

3.Actuator对运行状态监控

Spring Boot提供了Actuator组件，并提供了程序运行状态的监控功能，这种设计可以让开发人员能够知道注入了哪些Bean，它们的运行状态是怎么样的.

以上就是Springboot简单的介绍. 下面我们来深入了解下他自动装配的特性

Springboot 自动装配

Springboot 自动装配需要依赖注解来完成

1. @SpringBootApplication注解

首先从@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 {}

1.1 @SpringBootConfiguration

此注解比较简单,表明该类是一个Spring的配置类,也作为Spring一个组件

1.2 @ComponentScan

用于类或接口上主要是指定扫描路径，Spring会把指定路径下带有指定注解的类自动装配到bean容器里。会被自动装配的注解包括@Controller、@Service、@Component、@Repository等等。

1.3 自动装配灵魂注解—@EnableAutoConfiguration

我们先进入@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 {};
}

除去一些元注解,我们看到还有两个注解

1. @AutoConfigurationPackage

• 它是负责保存标注相关注解的类的所在包路径。使用一个BasePackage类，保存这个路径。然后使用@Import注解将其注入到ioc容器中。这样，可以在容器中拿到该路径。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};
}

再来看一下 Registrar.class类, 它是一个静态内部类

 static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }
		// 注册初始化Bean定义,获取packageNames
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }
    }

其实就是注册了autoConfigurationPackages这个名字的bean。

现在包扫描路径获取到了，那具体加载哪些组件呢，看看下面这个重点注解
@Import({AutoConfigurationImportSelector.class})

@Import注解就是给Spring容器中导入一些组件，这里传入了一个组件的选择器:AutoConfigurationImportSelector

AutoConfigurationImportSelector类中 selectImports方法

  // 选择导入的组件,返回组件路径
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 判断是否禁止自动导入
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
			// 获取自动导入配置
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

在往下看 this.getAutoConfigurationEntry(annotationMetadata) 这个方法源码

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            /**
             * 获取所有候选配置类EnableAutoConfiguration
             */
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

在看源码 this.getCandidateConfigurations(annotationMetadata, attributes)这个方法

    /**
     * 获取所有候选配置类EnableAutoConfiguration
	 * 使用了内部工具使用SpringFactoriesLoader，查找classpath上所有jar包中的
	 * META-INF\spring.factories，找出其中key为
	 * org.springframework.boot.autoconfigure.EnableAutoConfiguration 
	 * 的属性定义的工厂类名称。
	 * 虽然参数有annotationMetadata,attributes,但在 AutoConfigurationImportSelector 的
	 * 实现 getCandidateConfigurations()中，这两个参数并未使用
	 * 返回应该被自动配置的类名称
     */
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;
}

/**
 * 查看上面的调用方法 loadFactoryNames()
 */
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}
/**
 * 查看上面的调用方法 loadSpringFactories() 加载spring.factories
 */
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 {
             Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
             LinkedMultiValueMap result = new LinkedMultiValueMap();

             // ...省略部分代码
             cache.put(classLoader, result);
             return result;
         } catch (IOException var13) {
             throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
         }
     }
 }

主要就是看类加载器加载 spring.factories配置. 这个配置有什么特别之处呢?

我们选择Redission.jar包, 在来看下 META-INF/spring.factories里面是什么:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.redisson.spring.cache.RedissonCacheStatisticsAutoConfiguration

RedissonCacheStatisticsAutoConfiguration 源码

@Configuration
@AutoConfigureAfter({CacheAutoConfiguration.class})
@ConditionalOnBean({CacheManager.class})
@ConditionalOnClass({MeterBinder.class})
public class RedissonCacheStatisticsAutoConfiguration {
    public RedissonCacheStatisticsAutoConfiguration() {
    }

    @Bean
    public RedissonCacheMeterBinderProvider redissonCacheMeterBinderProvider() {
        return new RedissonCacheMeterBinderProvider();
    }
}

解析到这里, 我们应该大概明白springboot自动装配是怎么样的流程了, Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，这些自动配置类都是以AutoConfiguration结尾来命名的, 它实际上就是一个JavaConfig形式的IOC容器配置类，

参考文章:

开发框架springboot详解
spring-boot是什么
SpringBoot自动装配原理分析
Spring Boot架构篇 - @AutoConfigurationPackage