springboot自动装配原理+手写stater

@SpringBootApplication注解是个组合注解，其内部的@EnableAutoConfiguration注解是自动装配的关键， 看到@Enable**这类注解我们都已近很熟悉了，前一篇有提到关于@Enable**注解的作用和@Import注解的作用，不懂的可以看一下前一篇的内容 CSDNhttps://mp.csdn.net/mp_blog/creation/editor/131975839。@EnableAutoConfiguration内部的@Import(AutoConfigurationImportSelector.class)注解，执行内部的selectImports方法，其返回的类全名字符串数组就是需要注入spring容器的类。

@EnableAutoConfiguration注解源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

 
AutoConfigurationImportSelector类中的selectImports方法源码如下：

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

由源码可见，最关键的是getAutoConfigurationEntry 方法：继续分析源码。

	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //这行代码就是获取"META-INF/spring.factories配置文件中的自动装配的类
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

getCandidateConfigurations方法就是获取"META-INF/spring.factories配置文件中的自动装配的类，源码如下：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
//loadFactoryNames中有写死的路径META-INF/spring.factories
		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) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();

        //loadSpringFactories真正的加载配置文件
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

loadSpringFactories方法中写死了 META-INF/spring.factories加载路径

 private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                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 factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

此方法加载的是依赖中的jar 包下的META-INF/spring.factories文件中的，例如，springmvc中的

spring-boot-autoconfigure这个类，mybatis等也是这个原理。

org.springframework.boot.autoconfigure.EnableAutoConfiguration这个key下的所有类。

如下图：

回到我们的核心方法中

	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //这行代码就是获取"META-INF/spring.factories配置文件中的自动装配的类
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        //去重
		configurations = removeDuplicates(configurations);
        //去掉排除的类
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
        //移除被排除的类
		configurations.removeAll(exclusions);
        //根据META-INF/spring-autoconfigure-metadata.properties配置的条件进行过滤
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

removeDuplicates进行去重，因为加载依赖中的配置，很有可能不同配置文件中个有重复配置的问题。

这行代码是去掉排除的类

Set<String> exclusions = getExclusions(annotationMetadata, attributes);

举例：如下如果在启动类@SpringBootApplication注解中排除掉redis的配置类，那么RedisAutoConfiguration.class就会出现在exclusions这个set中

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

接下来再分析configurations = getConfigurationClassFilter().filter(configurations);这个过滤配置类。

private static class ConfigurationClassFilter {

		private final AutoConfigurationMetadata autoConfigurationMetadata;

		private final List<AutoConfigurationImportFilter> filters;

		ConfigurationClassFilter(ClassLoader classLoader, List<AutoConfigurationImportFilter> filters) {
			this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(classLoader);
			this.filters = filters;
		}





List<String> filter(List<String> configurations) {
			long startTime = System.nanoTime();
			String[] candidates = StringUtils.toStringArray(configurations);
			boolean skipped = false;
			for (AutoConfigurationImportFilter filter : this.filters) {
				boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
				for (int i = 0; i < match.length; i++) {
					if (!match[i]) {
						candidates[i] = null;
						skipped = true;
					}
				}
			}
			if (!skipped) {
				return configurations;
			}
			List<String> result = new ArrayList<>(candidates.length);
			for (String candidate : candidates) {
				if (candidate != null) {
					result.add(candidate);
				}
			}
			if (logger.isTraceEnabled()) {
				int numberFiltered = configurations.size() - result.size();
				logger.trace("Filtered " + numberFiltered + " auto configuration class in "
						+ TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
			}
			return result;
		}

	}

过滤器的初始化代码：写死了"META-INF/spring-autoconfigure-metadata.properties"这个路径

final class AutoConfigurationMetadataLoader {

	protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties";

	private AutoConfigurationMetadataLoader() {
	}

	static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
		return loadMetadata(classLoader, PATH);
	}

还是以redis为例，redis的过滤条件是ConditionalOnClass

需要在classpath下有org.springframework.data.redis.core.RedisOperations这个类，只有我们加入redis的stater，就不会过滤了。

 好了，主线路分析完了。

如果让我们自己写一个stater，比如MyStater ,我们只需要在META-INF/spring.factories中配置一行，当前项目的java配置类如MyStaterConfig即可。key就是org.springframework.boot.autoconfigure.EnableAutoConfiguration =com.xx.MyStaterConfig

当然也可以加过滤条件:

在META-INF/目录下创建 spring-autoconfigure-metadata.properties配置文件

配置内容举例：

com.xx.MyStaterConfig.ConditionOnBean=com.xx.xx.A

可选配置：如果需要一些配置提示可以按照格式写一个配置提示：

additional-spring-configuration-metadata.json这里提一嘴，有兴趣的小伙伴可以自行百度。

然后install到maven仓库，其它项目需要的时候加入MyStater的依赖即可。