spring boot自动装配源码分析

绝地灬酷狼 2022-09-09 11:52 198阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*  前言
 *  1. @SpringBootApplication
 *  2.@EnableAutoConfiguration
 *   *  2.1 @AutoConfigurationPackage
     *  2.2 @Import(AutoConfigurationImportSelector.class)
 *  总结

--------------------

# 前言 #

在没有spring boot的年代，有幸体验到了ssm 整合配置的痛苦，那个时候，要想将springmvc ，spring ，mybatis整合起来，需要配置一堆的xml文件，说不痛苦那是假的。spring boot 面市之后，你还别说，是真的香，想用啥组件的时候，找找它的starter，引入starter依赖，就能整合在一起了，也没有那堆xml配置文件了，其实依赖starter就能整合，得益于spring boot 自动装配特性，starter中存在自动配置类，项目启动的时候，能够自动装配对应组件的一些对象啥的，本文主要就是看看spring boot 自动装配到底是怎么搞得。

# 1. @SpringBootApplication #

我们都知道，创建一个spring boot项目的时候，都会有一个主启动类，该类上面需要有一个@SpringBootApplication 注解，就像下面这个启动类一样

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

那么我们需要看看这个 @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 { }

由三个注解组成的  
@SpringBootConfiguration：spring boot 配置类，里面有个@Configuration 注解，这个注解大家应该都熟悉，spring的配置类注解  
@EnableAutoConfiguration： 自动装配的注解，今天主角儿。  
@ComponentScan：组件扫描注解  
接下来我们看看@EnableAutoConfiguration注解

# 2.@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 { };
    }

由@AutoConfigurationPackage 注解和@Import(AutoConfigurationImportSelector.class) 注解组成。里面还有2个属性，都是指定需要排除的类。  
@AutoConfigurationPackage 从名字上看是自动配置package  
@Import 这个注解更牛逼，可以导入4种类型的类， 可以导入 配置类，ImportSelector实现类，ImportBeanDefinitionRegistrar实现类，普通类。  
我们挨个看看这两个注解

## 2.1 @AutoConfigurationPackage ##

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Import(AutoConfigurationPackages.Registrar.class)
    public @interface AutoConfigurationPackage { }

有个@Import注解，这里导入的是个registrar类型的  
我们看下AutoConfigurationPackages.Registrar 代码

/** * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing * configuration. */
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports { 
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) { 
    		register(registry, new PackageImport(metadata).getPackageName());
    	}
    	@Override
    	public Set<Object> determineImports(AnnotationMetadata metadata) { 
    		return Collections.singleton(new PackageImport(metadata));
    	}
    }

看下上面的注释，说是为了存储 基本的package  
看下registerBeanDefinitions 方法，从名字上就是注册bean的。  
`new PackageImport(metadata).getPackageName()` 就是为了获取 你主启动类所在的包。

public static void register(BeanDefinitionRegistry registry, String... packageNames) { 
    	if (registry.containsBeanDefinition(BEAN)) { // AutoConfigurationPackages.class.getName()
    		BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
    		ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
    		constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
    	}
    	else { 
    		GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
    		beanDefinition.setBeanClass(BasePackages.class);
    		beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
    		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    		registry.registerBeanDefinition(BEAN, beanDefinition);
    	}
    }

判断，如果注册表中存在AutoConfigurationPackages 这个bean的话，就向设置一下它构造的第一参数值是 主启动类所在的包。  
如果不存在的话，先创建BasePackages这个类对应beanDefinition ，在设置构造第一个参数值是主启动类所有在包。  
默认是不存在。  
我们看下这个BasePackages

static final class BasePackages { 
    	private final List<String> packages;
    	private boolean loggedBasePackageInfo;
    	BasePackages(String... names) { 
    		List<String> packages = new ArrayList<>();
    		for (String name : names) { 
    			if (StringUtils.hasText(name)) { 
    				packages.add(name);
    			}
    		}
    		this.packages = packages;
    	}
    }

其实就是将主启动类的包，塞到它packages 这个集合中，BasePackages 还提供了一个get方法，用来获取packages 里面的值的。  
说白了，**这个BasePackages 就是存储主启动类对应包的，如果后续有哪些组件想获取base package 就可以找到BasePackages bean，获取存储的主启动类package。这也是spring boot 主启动类要放在外层的原因，因为一些组件默认是扫面主启动类所在包下面的类。**  
好了，了解了@AutoConfigurationPackage 注解的作用，我们在来看下`@Import(AutoConfigurationImportSelector.class)`

## 2.2 @Import(AutoConfigurationImportSelector.class) ##

主要就是看下AutoConfigurationImportSelector

@Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) { 
    	if (!isEnabled(annotationMetadata)) { 
    		return NO_IMPORTS;
    	}
    	// 加载元数据
    	AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    			.loadMetadata(this.beanClassLoader);
    	//spi找出那些EnableAutoConfiguration 对应的类 / 也就是自动配置类
    	AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(
    			autoConfigurationMetadata, annotationMetadata);
    	//将需要加载的自动配置类返回
    	return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }

这里selectImports方法核心作用就是找到你那些自动配置类 ，返回给spring，让spring给你实例化，加载配置。  
我们直接看下getAutoConfigurationEntry 方法，该方法就是找自动配置类的。

protected AutoConfigurationEntry getAutoConfigurationEntry(
    		AutoConfigurationMetadata autoConfigurationMetadata,
    		AnnotationMetadata annotationMetadata) { 
    	if (!isEnabled(annotationMetadata)) { 
    		return EMPTY_ENTRY;
    	}
    	// 获取注解下的属性值
    	AnnotationAttributes attributes = getAttributes(annotationMetadata);
    	// 到spring.factories中找出所有的EnableAutoConfiguration 实现类，就是那些自动配置类
    	List<String> configurations = getCandidateConfigurations(annotationMetadata,
    			attributes);
    	// 去重
    	configurations = removeDuplicates(configurations);
    	// 找出那些需要排除掉的
    	Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    	//校验
    	checkExcludedClasses(configurations, exclusions);
    	// 移除那些排除掉的 configuration
    	configurations.removeAll(exclusions);
    	// 拿 AutoConfigurationImportFilter 进行过滤
    	configurations = filter(configurations, autoConfigurationMetadata);
    	// 通知 AutoConfigurationImportListener
    	fireAutoConfigurationImportEvents(configurations, exclusions);
    	// 封装AutoConfigurationEntry 对象返回
    	return new AutoConfigurationEntry(configurations, exclusions);
    }

getAutoConfigurationEntry 方法的每行代码都做了注释，最核心的还是调用getCandidateConfigurations 方法找到自动装配类。  
找到之后，先排除掉你在注解中配置的那些需要排除的自动装配类，接着使用你自定义的AutoConfigurationImportFilter 过滤器过滤一下，最后才将剩下的封装 AutoConfigurationEntry 对象返回，到上一个方法中也是取得AutoConfigurationEntry 的configurations 属性返回的。  
接下来我们看下 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;
    }

使用的spring spi 来加载的，spring spi 原理与jdk 提供spi是一样的，都是根据接口 去文件中找对应的实现。  
这里简单说下spi 的原理：  
就拿jdbc 来说吧，jdk 提供了一个Driver驱动接口，然后由各大数据库厂商 做响应的实现，mysql 提供的MysqlDriver，orcale提供的OrcaleDriver（这里不一定真实存在），比如说我项目中 使用了mysql的驱动，jdbc 创建连接的时候需要我的驱动，但是它不知道我用的是哪家的驱动，这个时候 就需要在项目中配置一个文件，告诉一下jdbc 我用的是MysqlDriver  
所以在mysql的驱动jar 的META-INF/services文件夹下面就有一个java.sql.Driver 文件， 这个文件名就是jdbc driver接口的全类名，表示是里面内容是java.sql.Driver 接口的实现，里面内容就是com.mysql.jdbc.Driver ，表示mysql的驱动实现是com.mysql.jdbc.Driver 这个类。

spring spi不一样的是路径是META-INF，然后文件名也是统一的spring.factories ，里面内容采用的是 接口全类名=接口实现类全类名 的格式。  
它这边就是加载的EnableAutoConfiguration 全类名`org.springframework.boot.autoconfigure.EnableAutoConfiguration`对应的实现。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16]  
多个实现类就用英文逗号隔开就行了。  
可以看到它的实现类都是AutoConfiguration 结尾的，这个是一个约定俗成的，如果你要写一个自动配置类，最好是以AutoConfiguration 结尾，见名知意。  
随便拿出来一个看下。

@Configuration
    @ConditionalOnClass({  EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
    		AnnotatedElement.class })
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration { }

都是带有@Configuration 注解的，这个spring 就能够知道了，他是个配置类。

# 总结 #

@EnableAutoConfiguration 自动装配注解由两个注解组成， @AutoConfigurationPackage 这个注解主要是为了将主启动类对应包 存储到BasePackages 这个bean对象中，@Import(AutoConfigurationImportSelector.class) 主要就是通过spi找出那些自动装配配置类，交个spring 实例化，加载。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAJOeggeWHuuacquadpQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/3793df0e05d143b7aff88da5dc942a68.png