springboot框架介绍(自动配置)

喜欢ヅ旅行 2022-10-18 11:18 206阅读 0赞

### springboot框架介绍 ###

*  Spring简介
 *  什么是Spring Boot
 *  SpringBoot特性
 *   *  1.自动装配
     *  2.起步依赖
     *  3.Actuator对运行状态监控
 *  Springboot 自动装配
 *   *  1. @SpringBootApplication注解
     *   *  1.1 @SpringBootConfiguration
         *  1.2 @ComponentScan
         *  1.3 自动装配灵魂注解---@EnableAutoConfiguration
 *  参考文章:

# 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`里面是什么:  
![Redission源码][Redission]

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详解][springboot]  
[ spring-boot是什么][spring-boot]  
[SpringBoot自动装配原理分析][SpringBoot]  
[Spring Boot架构篇 - @AutoConfigurationPackage][Spring Boot_ - _AutoConfigurationPackage]

[Redission]: /images/20221014/f7a9f19196f44d9fbe8ded9391db9485.png
[springboot]: https://zhuanlan.zhihu.com/p/39843380
[spring-boot]: https://blog.csdn.net/qq_31655965/article/details/71258191
[SpringBoot]: https://blog.csdn.net/Dongguabai/article/details/80865599
[Spring Boot_ - _AutoConfigurationPackage]: https://blog.csdn.net/qq_34561892/article/details/109099448