当前位置：首页 > AI与科技 > 正文内容

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

admin21小时前AI与科技7

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 。

大概可以把 @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 {
}