Java框架学习04（SpringBoot自动装配原理）

Java框架学习04（SpringBoot自动装配原理）

1、什么是 自动装配？

2、 是如何实现自动装配的？如何实现按需加载？

3、如何实现一个 ？

前言

使用过 的小伙伴Java框架学习04（SpringBoot自动装配原理），一定有被 XML 配置统治的恐惧。即使 后面引入了基于注解的配置，我们在开启某些 特性或者引入第三方依赖的时候java中spring原理，还是需要用 XML 或 Java 进行显式配置。

举个例子。没有 Boot 的时候，我们写一个 Web 服务，还首先需要进行如下配置。

@Configuration
public class RESTConfiguration
{
    @Bean
    public View jsonTemplate() {
        MappingJackson2JsonView view = new MappingJackson2JsonView();
        view.setPrettyPrint(true);
        return view;
    }
    @Bean
    public ViewResolver viewResolver() {
        return new BeanNameViewResolver();
    }
}

-.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context/ http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc/ http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <context:component-scan base-package="com.howtodoinjava.demo" />
    <mvc:annotation-driven />
    <!-- JSON Support -->
    <bean name="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
    <bean name="jsonTemplate" class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
</beans>

但是， Boot 项目，我们只需要添加相关依赖，无需配置，通过启动下面的 main 方法即可。

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

并且，我们通过 Boot 的全局配置文件 .或.yml即可对项目进行设置比如更换端口号，配置 JPA 属性等等。为什么 Boot 使用起来这么酸爽呢？ 这得益于其自动装配。自动装配可以说是 Boot 的核心，那究竟什么是自动装配呢？

1、什么是 自动装配？

现在提到自动装配的时候Java框架学习04（SpringBoot自动装配原理），一般会和 Boot 联系在一起。但是，实际上 早就实现了这个功能。 Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。

定义了一套接口规范，这套规范规定： 在启动时会扫描外部引用 jar包中的META-INF/.文件，将文件中配置的类型信息加载到 容器（此处涉及到 JVM类加载机制与 的容器知识），并执行类中定义的各种操作。对于外部 jar 来说，只需要按照 定义的标准，就能将自己的功能装置进 。

没有 Boot 的情况下，如果我们需要引入第三方依赖，需要手动配置，非常麻烦。但是，Boot 中java中spring原理，我们直接引入一个 即可。比如你想要在项目中使用 redis 的话，直接在项目中引入对应的 即可。

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

引入 之后，我们通过少量注解和一些简单的配置就能使用第三方组件提供的功能了。

自动装配可以简单理解为：通过注解或者一些简单的配置就能在 Boot 的帮助下实现某块功能。

2、 是如何实现自动装配的？

先看一下 的核心注解 n 。

b

大概可以把 @n看作是 @、@ion、@ 注解的集合。根据 官网，这三个注解的作用分别是：

@ion 是实现自动装配的重要注解，我们以这个注解入手。

3、@ion:实现自动装配的核心注解

ion 只是一个简单地注解，自动装配核心功能的实现实际是通过 类。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage //作用：将main包下的所有组件注册到容器中
@Import({AutoConfigurationImportSelector.class}) //加载自动装配类 xxxAutoconfiguration
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

现在重点分析下 类到底做了什么？

:加载自动装配类

类的继承体系如下：

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
}
public interface DeferredImportSelector extends ImportSelector {
}
public interface ImportSelector {
    String[] selectImports(AnnotationMetadata var1);
}

可以看出， 类实现了 接口，也就实现了这个接口中的 方法，该方法主要用于获取所有符合条件的类的全限定类名，这些类需要被加载到 IoC 容器中。

private static final String[] NO_IMPORTS = new String[0];
public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // <1>.判断自动装配开关是否打开
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
          //<2>.获取所有需要装配的bean
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

这里我们需要重点关注一下Entry()方法，这个方法主要负责加载自动配置类的。

该方法调用链如下：

现在我们结合

结合Entry()的源码来详细分析一下：

private static final AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationEntry();
AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        //<1>.
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            //<2>.
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            //<3>.

            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            //<4>.
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

第 1 步:

判断自动装配开关是否打开。默认.boot.ion=true，可在 . 或 .yml 中设置

第 2 步：

用于获取ion注解中的 和 。

第 3 步

获取需要自动装配的所有配置类，读取META-INF/.

spring-boot/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

从下图可以看到这个文件的配置内容都被我们读取到了。的作用就是按需加载组件。

不光是这个依赖下的META-INF/.被读取到java中spring原理，所有 Boot 下的META-INF/.都会被读取到。

所以，你可以清楚滴看到， druid 数据库连接池的 Boot 就创建了META-INF/.文件。

如果，我们自己要创建一个 Boot ，这一步是必不可少的。

第 4 步：

到这里可能面试官会问你:“.中这么多配置，每次启动都要全部加载么？”。

很明显，这是不现实的。debug 到后面你会发现， 的值变小了。

因为，这一步有经历了一遍筛选，@ 中的所有条件都满足，该类才会生效。

@Configuration
// 检查相关的类：RabbitTemplate 和 Channel是否存在
// 存在才会加载
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
}

有兴趣的可以详细了解下 Boot 提供的条件注解

4、如何实现一个

光说不练假把式，现在就来撸一个 ，实现自定义线程池

第一步，创建--boot-工程

第二步，引入 Boot 相关依赖

第三步，创建

第四步，在--boot-工程的 包下创建META-INF/.文件

最后新建工程引入--boot-

测试通过！！！

总结

Boot 通过@ion开启自动装配，通过 r 最终加载META-INF/.中的自动配置类实现自动装配

自动配置类其实就是通过@按需加载的配置类，想要其生效必须引入-boot--xxx包实现起步依赖