spring boot 之自动装配

桃扇骨 2022-02-12 23:47 280阅读 0赞

### 前言 ###

在最初接触spring 的时候，还是使用xml进行装配，我记得很清楚，当时分别配置了spring-dao.xml , spring-service.xml , spring-controller.xml。然后把所有需要用到的扫包，注入bean，以及配置，全都一股脑的塞进xml中，虽然出发点很好，不用在java代码中硬编码了，但是xml的可读性并不是很好，那阵子，真是痛苦的要命。

### 正文 ###

后来逐渐的接触到了spring boot，发现这个东西开发起来简单的要命，几乎自己不需要过多的考虑spring 与别的框架整合的问题，所有的一切spring boot已经帮我们做好了，只需要在application.properties 配置一下就完事。  
但是spring boot 因为大部分的东西，已经不需要我们在着手了，所以对我们而言，“易学难精”。所以我决定好好把spring boot的原理搞清楚，今天就来说一说自动装配。  
这里提前说一下，Spring boot的注入一共有四种方式：

> 1.通过 spring **模式注解** 装配  
> 2.通过@Enable\* 注解进行装配

3.通过条件注解装配  
4.通过工厂类去加载

下面我会逐一说到以上这几点。

##### 通过 spring 模式注解 装配 #####

模式注解的方式，尽管我们刚开始接触spring，spring mvc 框架，我们也应该会知道他们到底是怎么使用的。  
以@Component为首 派生的 @Controller，@Service， @Repository。分别对应了我们工程中的controller层，业务层，和数据持久层，这里我就不做过多结束了，只要把注解放在类上就可以被自动的注入到spring 的context中。

##### 通过@Enable\* 注解进行装配 #####

很多人会问为什么有了模式注解的装备，还需要@Enable\* 这个注解呢？  
这个问题问的非常好，纵观整个Web的发展，我们可以看出来，是一个化繁为简的模块化趋势。  
所以@Enable\* 也是具有同样道理的，例如@EnableWebMvc就是一个web组件的集合。  
@Enable\*注解有很多种：  
例如说 @EnableAutoConfiguration，@EnableWebMvc，@EnableCaching，@EnableAsync等。  
@Enable\* 的注入主要又可以分成两种：

> 1.使用注解的方式注入

2.使用接口编程的方式注入  
Tips:但是不管是哪一种方式都是通过 @Enable\* 注解定义上的@Import注解引入的。

使用注解的实现（是在Serlet3.0出现的）就是说在@Enable\*的@Import注解中，加载的那个类是被@Configuration注入的，例如@EnableWebMvc。  
代码如下：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.web.servlet.config.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.context.annotation.Import;
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    //这就是上面说的哪个@Import注解，我们继续查看下DelegatingWebMvcConfiguration 这个类
    @Import({DelegatingWebMvcConfiguration.class})
    public @interface EnableWebMvc {
    }

DelegatingWebMvcConfiguration 代码如下（只是摘取了部分，有所省略）：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.web.servlet.config.annotation;
    
    import java.util.List;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.format.FormatterRegistry;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.lang.Nullable;
    import org.springframework.util.CollectionUtils;
    import org.springframework.validation.MessageCodesResolver;
    import org.springframework.validation.Validator;
    import org.springframework.web.method.support.HandlerMethodArgumentResolver;
    import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
    import org.springframework.web.servlet.HandlerExceptionResolver;
    
    @Configuration
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
        private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    
        public DelegatingWebMvcConfiguration() {
        }
    
        @Autowired(
            required = false
        )
        public void setConfigurers(List<WebMvcConfigurer> configurers) {
            if (!CollectionUtils.isEmpty(configurers)) {
                this.configurers.addWebMvcConfigurers(configurers);
            }
    
        }
    
        protected void configurePathMatch(PathMatchConfigurer configurer) {
            this.configurers.configurePathMatch(configurer);
        }
    
        protected void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
            this.configurers.configureContentNegotiation(configurer);
        }
    
    //省略了之后的方法
    
    }

在这里可以很清楚的看到使用@Configuration（这个注解是替代原来在spring xml中注入而出现的注解）进行注入，虽然可以实现功能，但是每次只能注入指定的Bean。

使用编程的方式（是在Serlet3.1出现的）是在@Enable\*的@Import注解中，加载的那个类，实现了ImportSelector接口，并且重写 selectImports(AnnotationMetadata importingClassMetadata)方法，可以将需要注入的class名称通过条件筛选后放在一个数组中通过返回值进行注入，这是一个我们一直在用的注解，但是为什么我们并不能在朝夕相处的spring boot 中找到相关的代码呢？因为Spring boot 对其进行了封装，下面我们慢慢顺藤摸瓜的去找一下。  
新创建一个工程之后，映入眼帘的就是启动类 \*Application.java:  
代码如下：

package com.harry.springtest;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringtestApplication {
    
        public static void main(String[] args) {SpringApplication.run(SpringtestApplication.class, args);
        }
    
    }

在main方法中只有一个类的启动方法，那么我们就应该把关注点放在@SpringBootApplication上了  
@SpringBootApplication 注解代码如下：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.boot.autoconfigure;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.boot.SpringBootConfiguration;
    import org.springframework.boot.context.TypeExcludeFilter;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.context.annotation.ComponentScan.Filter;
    import org.springframework.core.annotation.AliasFor;
    
    @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 {
        @AliasFor(
            annotation = EnableAutoConfiguration.class
        )
        Class<?>[] exclude() default {};
    
        @AliasFor(
            annotation = EnableAutoConfiguration.class
        )
        String[] excludeName() default {};
    
        @AliasFor(
            annotation = ComponentScan.class,
            attribute = "basePackages"
        )
        String[] scanBasePackages() default {};
    
        @AliasFor(
            annotation = ComponentScan.class,
            attribute = "basePackageClasses"
        )
        Class<?>[] scanBasePackageClasses() default {};
    }

在这里我们可以看出来@SpringBootApplication是一个组合注解里面运用到了@EnableAutoConfiguration，我们在继续看一下@EnableAutoConfiguration：

package org.springframework.boot.autoconfigure;
    
    //省略应该引入的包
    
    public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
        private static final AutoConfigurationImportSelector.AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationImportSelector.AutoConfigurationEntry();
        private static final String[] NO_IMPORTS = new String[0];
        private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
        private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
        private ConfigurableListableBeanFactory beanFactory;
        private Environment environment;
        private ClassLoader beanClassLoader;
        private ResourceLoader resourceLoader;
    
        public AutoConfigurationImportSelector() {
        }
    }
    //省略以下的所有方法。

DeferredImportSelector继承了ImportSelector

##### spring 条件装配 #####

条件装配一共有两种方法，可以供我们使用：

> 1.使用@Profile注解

2.使用@Conditional注解

@Profile只是一个站在大局上的条件装配，通过环境变量的某些值，或者是系统变量某些定值，我们可以使用不同的实现方法。这就类似于我们定义了一个接口，通过多态，定义了两个实现类实现了相同的这个接口，但是我们可以通过环境变量去决定，到底是使用哪一个实现类去实现这个方法。  
@Conditional注解，就更佳的灵活一些，类似于我们平常代码中的if else 通过判断出来的boolean值，决定到底是不是应该注入这个bean。  
@Conditional代码如下：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.context.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Conditional {
        Class<? extends Condition>[] value();
    }

我们可以看出来，需要往这个注解中加入一个值，这个值要实现Condition接口。  
Condition接口的代码如下：

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.context.annotation;
    
    import org.springframework.core.type.AnnotatedTypeMetadata;
    
    @FunctionalInterface
    public interface Condition {
        //关键之处
        boolean matches(ConditionContext var1, AnnotatedTypeMetadata var2);
    }

关键的地方，就在这里了，我们在实现了这个接口的时候，得去重写这个match方法，如果需要注入的地方，就应该返回true，如果是觉得不符合条件，不应该注入的就返回false。  
spring boot 通过封装 @Conditional 还有一些派生注解，如下：

> @ConditionalOnBean（如果在当前context中存在这个bean，实例化bean）

@ConditionalOnClass（如果在classpath中有这个class，实例化 bean）  
@ConditionalOnExpression（当表达式为true的时候，实例化一个bean）  
@ConditionalOnMissingBean（如果在当前context中不存在这个bean，实例化一个bean）  
@ConditionalOnMissingClass（如果在classpath中没有这个class，实例化一个bean）  
@ConditionalOnNotWebApplication（不是web应用,实例化bean）

##### spring 工厂加载机制 #####

在auto-configuration这个jar包下，或者其他自动注入的jar下，我们都可以看到spring.factories这个文件,例如说下图：  
![a.png][]  
正是通过这个文件，我们把需要注入的类的全路径配在这里，但是问题来了，谁去读这个文件的呢？  
在AutoConfigurationImportSelector.class中，我们可以看到以下方法：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
            List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
        }

我们继续刨根问底的看看SpringFactoriesLoader.loadFactoryNames 这个方法：

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
            String factoryClassName = factoryClass.getName();
            return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
        }

继续看loadSpringFactories 这个方法：

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 {
                    //就在这个地方将META-INF/spring.factories读入进来的。
                    Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                    LinkedMultiValueMap result = new LinkedMultiValueMap();
    
                    while(urls.hasMoreElements()) {
                        URL url = (URL)urls.nextElement();
                        UrlResource resource = new UrlResource(url);
                        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                        Iterator var6 = properties.entrySet().iterator();
    
                        while(var6.hasNext()) {
                            Entry<?, ?> entry = (Entry)var6.next();
                            String factoryClassName = ((String)entry.getKey()).trim();
                            String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                            int var10 = var9.length;
    
                            for(int var11 = 0; var11 < var10; ++var11) {
                                String factoryName = var9[var11];
                                result.add(factoryClassName, factoryName.trim());
                            }
                        }
                    }
    
                    cache.put(classLoader, result);
                    return result;
                } catch (IOException var13) {
                    throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
                }
            }
        }

这下子终于真相大白了。

### 后记 ###

通过这一次动手实践，根据源码追根溯源，我才终于明白，年轻真的得多看看源码，因为源码能带给我们的不光是在使用过程中减少bug的出现，以下解决bug的事件，更重要的是在设计上以及代码规范上的潜移默化，虽然说现在有一些还不是理解的很透彻，但是不积跬步，无以至千里。  
在这里也要感觉 慕课网上小马哥的[Spring Boot 2.0深度实践之核心技术篇][Spring Boot 2.0]。  
在收听的过程中受益匪浅。

[a.png]: /images/20220213/d6599679e8544334be02eb280b6a3e03.png
[Spring Boot 2.0]: https://coding.imooc.com/class/252.html