遇到一个问题，报上来一个app加入一个lib，启动就突然失败了。报了一个Autowire错误 NullPointerException。但是奇怪的是，大部分其他的App 加入这个library 之后都风平浪静，一切正常。那么这个app有何特殊之处？
首先要解决这个NullPointerException 为何会出现. 这个出错的是个AutoConfiguration 类
package io.http.env.client;
@Configuration
@AutoConfigureAfter(name = { "com.metadata.MetadataInitializer"})
public class HttpEnvInitializer {
@Autowired
public HttpEnvInitializer(SpellFasterServiceClient client){
client.call()
....
}
}
spring.factories 的配置类似
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
io.montage.env.client.HttpEnvInitializer
这个SpellCasterServiceClient 的bean 应该出现在这个AutoConfig 里
package io.montage.env.client;
@AutoConfigureBefore(name = { "com.metadata.MetadataInitializer" })
public class MFClientInitializer {
@Bean
public SpellFasterServiceClient getSpellFasterServiceClient() {
return SpellFasterServiceClientBuilder.target().build();
}
spring.factories 的配置类似
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
io.montage.env.client.SpellFasterServiceClient
这就是不科学了，构造SpellFasterServiceClient 的顺序在com.metadata.MetadataInitializer 之前，注入句柄的是在com.metadata.MetadataInitializer之后，这看起完全没有问题。
从程序看来，这个运行顺序完全没有问题
MFClientInitializer ->MetadataInitializer->HttpEnvInitializer
但是实际呢,通过debug 可以看到顺序是这样的
HttpEnvInitializer->MFClientInitializer ->MetadataInitializer
这就奇怪了，为啥AutoConfig 的before 和after 这些annotation 不起作用了？
需要看看什么导致了顺序变化，发现有人在Application 类新加了一个@ComponentScan("io.montage.env")，这下恍然大悟。原来和library 添加无关。
@SpringBootApplication
@EnableAsync
@ComponentScan("io.montage.env")
@Import({WebSpringConfig.class})
public class MonitorManagerApplication {
public static void main(String[] args) {
SpringApplication.run(MonitorManagerApplication.class, args);
}
}
这个@ComponentScan("io.montage.env") 纯属画蛇添足。这也解释了为什么只有这个App有问题，而其他的没问题。
下面就要谈谈Configuration和AutoConfiguration的区别
Configuration和AutoConfiguration
他们都是定义Bean 的一种方式。
相同点：
- 他们都用@Configuration 做annotation. 他们同样都可以加 @Bean、@Import、@ImportResource.
- 他们都可以用 @Condition 来控制加载条件.
不同点：
目的：
- @Configuration 是给Application 的用户，直接代码进行配置的。
- AutoConfiguration 是给 Springboot 插件俗称starter用的。
加载的方式:
- @Configuration 加载是由@ComponentScan指定的package，如果没有指定，default 是ApplicationClass 的package 开始。
- AutoConfiguration 是通过 classpath*:META-INF/spring.factories 来被发现。 通过 key org.springframework.boot.autoconfigure.EnableAutoConfiguration. AutoConfiguration 是由 import selector 的方式加载的, 而不是 scan path.
- 顺序：正常情况下, @Configuration 先加载 AutoConfiguration后加载。
请看class ConfigurationClassParser#doProcessConfigurationClass
class ConfigurationClassParser {
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
}
, 先运行下面代码来加载@Configuration
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
然后在运行
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
而EnableAutoConfiguration 定义了AutoConfigurationImportSelector，来load 所有的AutoConfig
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}
有正常就有不正常的情况，看看什么情况下不正常。
异常情况：
AutoConfiguration 可以使用@AutoConfigureOrder 或者 @AutoConfigureBefore、@AutoConfigureAfter
但是下面情况 AutoConfiguration 会破坏顺序，以@Configuraiton 被加载：
- AutoConfiguration的class 也在 scan path（@ComponentScan) ，所以他就被认为既是Configuration，又是AutoConfiguration。所以会被加载两次。 当以Configuration身份时先被加载。 因此 @AutoConfigureBefore and @AutoConfigureAfter 就不起作用了。
- AutoConfiguration定义了 BeanPostProcessor。请看BeanPostProcessorAutoConfiguration的逻辑.
- AutoConfiguration 使用了 ImportBeanDefinitionRegistrar。
- AutoConfiguration 使用 ImportSelector。
请参考AutoConfigurationImportSelector AutoConfigurationImportSelector了解更多细节.
在前面的问题中， 就是由于io.montage.env 在scan path里，因此 @AutoConfigureBefore and @AutoConfigureAfter 不起作用了。
@SpringBootApplication
@EnableAsync
@ComponentScan("io.montage.env")
@Import({WebSpringConfig.class})
public class MonitorManagerApplication {
public static void main(String[] args) {
SpringApplication.run(MonitorManagerApplication.class, args);
}
}
如何判断初始化顺序不正常：
当然加载顺序没有按照预定设想顺序，是比较难以排查的。介绍大家一个简单的方法。
appContext.getBeanDefinitionNames 中找到相关的bean name，以上图为例，如果是spring.factories 中定义的名字 例如io.montage.env.client.HttpEnvInitializer， 那么就是从AutoConfiguration 拿来的，如果是httpEnvInitializer, 这种就是从scan path 里扫描出来的。这样很容易就可以看到到底是怎么被load进来的。
