Spring BeanDefinition 深入解读

justlikeyou
886 阅读14分钟

BeanDefinition

AnnotatedBeanDefinition

注解相关Bean的定义信息

  1. 具有通用BeanDefinition
  2. 具有AnnotationMetadata(类和注解相关元信息)以及MethodMetadata(工厂方法元信息)
  3. AnnotationMetadata具有AnnotatedTypeMetadata，后者有包含了MergedAnnotations (MergedAnnotation的迭代器模式)

相关核心依赖类图如下，所以想深入了解注解驱动的元数据构造，则需要深入理解各个组件的作用，特别是MergedAnnotation

annotation

MergedAnnotation

见名知意，这个接口表示合并的注解元信息。为什么是合并的呢？因为注解可以通过元标注的方式实现类似Class继承的操作。

代码演示场景

//自定义注解声明
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
public @interface MyConfiguration {

    @AliasFor(annotation = Configuration.class)
    String value() default "";

    @AliasFor(annotation = Configuration.class)
    boolean proxyBeanMethods() default true;

}

//定义一个列声明自定义注解，扩展了@Configuration
@MyConfiguration(value = "z3", proxyBeanMethods = false)
public class MergedAnnotationDemo{}

判断是否存在相关API

在合并的元信息中判断某些注解是否存在

present-api

//注解依赖关系 MyConfiguration <- Configuration <- Component <- Indexed
//from静态方法用来构造合并的Annotations元信息
MergedAnnotations annotations = MergedAnnotations.from(MergedAnnotationDemo.class);
//1. 是否直接标注该注解，元标注的不算 ，这里 Indexed并不是直接标注在MyConfiguration上，所有返回false
displayApi("isDirectlyPresent", annotations.isDirectlyPresent(Indexed.class)); 
 //2. 是否元标注或者直接标志该注解,Indexed是MyConfiguration的元标注注解，返回true
displayApi("isPresent", annotations.isPresent(Indexed.class));
//3. 是否是元标注注解，Indexed是元标注注解 ，返回true
displayApi("isMetaPresent", annotations.get(Configuration.class).isMetaPresent());

//output
isDirectlyPresent  = false
isPresent  = true
isMetaPresent  = true

注解位置相关API

在合并注解元信息中找到指定注解和当前申明的AnnotatedElement的位置信息

//距离当前source(MergedAnnotationDemo.class)的位置信息
//1.Configuration有是元标注在MyConfiguration上，所有返回 1
displayApi("getDistance", annotations.get(Configuration.class).getDistance());
//2. 同理，MyConfiguration <- COnfiguration <- Component 
//  当前MergedAnnotation和指定注解的距离。直接标注为0，元标注为1，依次向上叠加
displayApi("getDistance", annotations.get(Component.class).getDistance());  //2
displayApi("getDistance", annotations.get(Indexed.class).getDistance()); //3
//javadoc中声明 是在stream中排序时使用,missing的annotation返回 -1 , 直接标注、元标注返回0
displayApi("getAggregateIndex", annotations.get(Target.class).getAggregateIndex());

//output
getDistance  = 1
getDistance  = 2
getDistance  = 3
getAggregateIndex  = 0

获取特定注解相关元信息API

在合并注解元信息中获取相关注解或者对象信息

//获取注解/元注解资源
 // 获取这个合并注解的源(无视层级)
displayApi("getSource", annotations.get(Indexed.class).getSource());
 //获取元标注的源注解信息
displayApi("getMetaSource", annotations.get(Indexed.class).getMetaSource().getType());
//获取distance为0的元信息 -> MyConfiguration
displayApi("getRoot", annotations.get(Indexed.class).getRoot().getType()); 
//获取所有元标注的Class信息
displayApi("getMetaTypes", annotations.get(Indexed.class).getMetaTypes()); 

//output
getSource  = class blog.spring.definition.MergedAnnotationDemo
getMetaSource  = interface org.springframework.stereotype.Component
getRoot  = interface blog.spring.anno.MyConfiguration
getMetaTypes  = [interface blog.spring.anno.MyConfiguration, interface org.springframework.context.annotation.Configuration, interface org.springframework.stereotype.Component, interface org.springframework.stereotype.Indexed]

获取注解属性相关API

//AnnotationAttribute相关API
//1. 判断某属性是否有默认值
displayApi("hasNonDefaultValue", annotations.get(Component.class).hasNonDefaultValue("value")); 
//2. 有获取注解属性的各种get方法，getString,getByte...
displayApi("getString", annotations.get(Configuration.class).getBoolean("proxyBeanMethods")); 
//3. 通用获取方法，可以指定类型信息
displayApi("getValue", annotations.get(Configuration.class).getValue("proxyBeanMethods",Boolean.class));

//4. 可以过滤有默认值的属性
displayApi("filterDefaultValues", annotations.get(Configuration.class).filterDefaultValues().getDefaultValue("proxyBeanMethods", Boolean.class));
//5. 通过Predicate进行属性名称过滤
displayApi("filterAttributes", annotations.get(Configuration.class).filterAttributes(s -> s.equals("z3")).getDefaultValue("proxyBeanMethods", Boolean.class)); //过滤属性名称
//6. withNonMergedAttributes()方法只能获取当前注解的属性信息，元标注的信息将不会被运用
displayApi("withNonMergedAttributes", annotations.get(Configuration.class).withNonMergedAttributes().getValue("value")); 
//6. 将注解属性信息转化成Map,AnnotationAttributes
displayApi("asAnnotationAttributes", annotations.get(MyConfiguration.class).asAnnotationAttributes().getString("value"));
displayApi("asMap", annotations.get(MyConfiguration.class).asMap(annotation -> new ConcurrentHashMap<>()).getClass().getSimpleName());

//7. 从合并注解元信息中获取合成的注解
Configuration configuration = annotations.get(Configuration.class).synthesize();

//8. 可以通过反射获取合并注解的相关属性，并可以在运行时动态修改注解属性值
System.out.println("before"+configuration.value());
displaySynthesizeInvocationHandler(configuration);
System.out.println("after"+configuration.value());

//解析合成的注解代理对象，注解代理信息
//默认注解会通过 AnnotationInvocationHandler进行代理处理
//Spring的MergedAnnotations则是通过 SynthesizedMergedAnnotationInvocationHandler来进行处理
//可以通过反射获取InvocationHandler中的被代理对象相关属性信息
private static void displaySynthesizeInvocationHandler(Configuration configuration) {
  InvocationHandler synthesizeInvocationHandler = Proxy.getInvocationHandler(configuration);
  ReflectionUtils.doWithFields(synthesizeInvocationHandler.getClass(), field -> {
    field.setAccessible(true);
    Object fieldVal = field.get(synthesizeInvocationHandler);
    //这里的valueCache是SynthesizedMergedAnnotationInvocationHandler代理中缓存的所有合并的注解属性信息
    if (field.getName().equals("valueCache")) {
      Map<String, Object> annotationFieldVal = (Map<String, Object>) fieldVal;
      annotationFieldVal.computeIfPresent("value", (k, v) -> v + "_proxy");
    }
  });
}

MergedAnnotations

是MergedAnnotation的迭代器模式，提供获取MergedAnnotations相关信息的工具类

MergedAnnotations#from

//from方法，构造成MergedAnnotations,可以从任意注解元素，并可以指定搜索方式和过滤来进行复杂注解信息查询
MergedAnnotations annotations = MergedAnnotations.from(MergedAnnotationDemo.class);
//可以通过get(String annotationType) 获取对应的MergedAnnotation信息。
MergedAnnotation annotation = MergedAnnotations.get(Configuration.class);

AnnotatedTypeMetadata

包含了MergedAnnotations，并提供了一些属性访问的工具方法，底层还是通过MergedAnnotations方法进行实现

AnnotatedTypeMetadata

ClassMetadata和AnnotationMetadata

这两个相比上面的底层注解API来说更加出场率高，分别代表了我们的类元信息和注解元信息。其中AnnotationMetadata继承了ClassMetadata , 通过ASM的放射来加载相关元信息。是AnnotatedBeanDefinition的重要元数据来源。

ClassMetadata

类信息描述，提供获取类名称，和一系列类描述信息，比如是否是接口，是否抽象类，可以获取成员的类型信息..

image-20201215173648088

AnnotationMetadata

包含注解的类元信息，是ClassMetadata的子类。并提供获取/判断注解类型相关辅助方法

//获取所有直接声明的Annotation Name
public default java.util.Set org.springframework.core.type.AnnotationMetadata.getAnnotationTypes()
//获取所有元注解
public default java.util.Set org.springframework.core.type.AnnotationMetadata.getMetaAnnotationTypes(java.lang.String)
//判断是否有直接声明的Annotation
public default boolean org.springframework.core.type.AnnotationMetadata.hasAnnotation(java.lang.String)
//  判断是否有元注解
public default boolean org.springframework.core.type.AnnotationMetadata.hasMetaAnnotation(java.lang.String)
// 判断是否有注解标注的方法
public default boolean org.springframework.core.type.AnnotationMetadata.hasAnnotatedMethods(java.lang.String)

AnnotatedBeanDefinition

注解类型的BeanDefinition，一般有两部分信息，一是通过类元信息AnnotationMetdata , 或者通过工厂方法(@Bean) MethodMetadata构成。其实现有一下几种

  • AnnotatedGenericBeanDefinition : 通用注解BeanDefinition，通用注解元信息,@Bean。。
  • ConfigurationClassBeanDefinition ：配置Class BeanDefinition，表示Configuration Class的注解元信息
  • ScannedGenericBeanDefinition : 扫描的BeanDefinition，通过ComponentScan扫描的Bean的注解元信息

获取AnnotationMetadata的两种方式

使用类加载的方式

效率低，类加载需要使用ClassLoader加载字节码文件并在JVM中生成Class对象

AnnotationMetadata annotationMetadata = AnnotationMetadata.introspect(AnnotationMetadataDemo.class);

使用ASM直接读取字节码文件

直接使用字节码框架进行字节码文件读取，这里就是通过ASM的ClassReader来读取字节码资源

public class ClassReaderByASMDemo {

    public static void main(String[] args) throws IOException {
        //1. 创建MetadataReaderFactory
        CachingMetadataReaderFactory readerFactory = new CachingMetadataReaderFactory();
        //2. 使用ClassReader解析字节码获取MetadataReader对象
        MetadataReader metadataReader = readerFactory.getMetadataReader("blog.spring.definition.AnnotationMetadataDemo");
        //3. 从reader中获取注解元信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //4. 读取所有的注解属性信息
        System.out.println(annotationMetadata.getAllAnnotationAttributes(MyConfiguration.class.getName()));
    }
}

相关核心类图如下。

  1. 通过MetadataReaderFactory获取MetadataReader (SimpleMetadataReader)
  2. SimpleMetadataReader通过SimpleAnnotationMetadataReadingVisitor和ASMClassReader来加载字节码文件
  3. 返回AnnotationMetadata对象

load-annotation

AbstractBeanDefinition

是BeanDefinition的一个抽象实现类，提供了基本接口方法实现，包含了构造器参数，属性参数，class相关信息，是否懒加载，primary等等..

GenericBeanDefinition

提供了层次性的BeanDefinition实现。可以设置Parent BeanDefinition

RootBeanDefinition

表示一个最顶层的BeanDefinition，所有的BeanDefinition经过MergeBeanDefinition阶段之后都是这个类型。

BeanDefinition的构造方式

直接new相关的实现类

   public static void main(String[] args) {
 				 //1. 直接new BeanDefinition相关实现类
     		// 通用BeanDefinition
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
     		// 注解式BeanDefinition
        AnnotatedGenericBeanDefinition beanDefinitionWithAnnotated = new AnnotatedGenericBeanDefinition(User.class);
        beanDefinition.setBeanClassName(User.class.getName());
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        propertyValues.add("name", "lazylittle");
        propertyValues.add("age", 11);
     		//设置属性
        beanDefinition.setPropertyValues(propertyValues);
        beanDefinitionWithAnnotated.setPropertyValues(propertyValues);

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
     		//注册并查找
        beanFactory.registerBeanDefinition("user", beanDefinition);
        beanFactory.registerBeanDefinition("userWithAnnotated",beanDefinitionWithAnnotated);
        System.out.println(beanFactory.getBeansOfType( User.class));
    }

//output
{user=User(name=lazylittle, age=11), userWithAnnotated=User(name=lazylittle, age=11)}

使用BeanDefinitionBuilder进行构造

				//1. 使用BeanDefinitionBuilder进行构造
				AbstractBeanDefinition z3BeanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class)
                .addPropertyValue("name", "z3")
                .addPropertyValue("age", 22)
                .getBeanDefinition();

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
				//2. 使用工具类进行注册，底层就是调用BeanDefinitionRegistry#registerBeanDefinition()
        BeanDefinitionReaderUtils.registerBeanDefinition(new BeanDefinitionHolder(z3BeanDefinition, "userZ3"), beanFactory);
        System.out.println(beanFactory.getBeansOfType( User.class));

注册BeanDefinition的方式

命名式

BeanDefinitionRegistry/BeanDefinitionReaderUtils.registerBeanDefinition("user-1", BeanDefinitionBuilder.genericBeanDefinition(User.class).addPropertyValue("name", "z3").getBeanDefinition());

非命名式

BeanDefinitionReaderUtils.registerWithGeneratedName(
			AbstractBeanDefinition definition, BeanDefinitionRegistry registry);

Spring容器加载BeanDefinition源码解析

Spring 容器是通过 xxxBeanDefinitionReader类来进行相关元信息的加载

Xml文件

核心方法入口 ： XmlBeanDefinitionReader#loadBeanDefinitions()

相关类图如下

xml相关类图

  • EntityResolver ： 用来加载schemas文件 ， 可以在本地配置META-INF/spring.schemas，配置相关schame文件和类路径的路径映射
https\://www.zzhujing.com/users/schema/users.xsd=spring/in/action/configuration/xml/user.xsd
  • XmlBeanDefinitionReader ： 就是一个上下文对象，包含了解析，注册等，其中具体操作都委派给对象的类进行处理，比如委派给BeanDefinitionDocumentReader进行xml文件加载，委派给XmlReaderContext和BeanDefinitionparserDelegate进行xml文件内容解析并构造成BeanDefinition
protected void doRegisterBeanDefinitions(Element root) {
		//1. 创建Delegate
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				// We cannot use Profiles.of(...) since profile expressions are not supported
				// in XML config. See SPR-12458 for details.
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isDebugEnabled()) {
						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}
	
		preProcessXml(root);
  	//2. 委派给BeanDefinitionParserDelegate进行解析
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}
  • NamespaceHandler和BeanDefinitionParser : 前者是名称空间处理，spring会将自定义扩展的Schema名称空间命名和解析器注册到一个Map中，在解析的时候根据不同的命名空间选择不同的BeanDefinitionParser进行解析。后者则将xml的元素解析生成BeanDefinition，随后使用BeanDefinitionRegistry注册到IOC容器中
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
    //根据名称空间的uri获取NamespaceHandler , spring.handlers中 k-v配置
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
    //获取BeanDefinitionParser进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

其实上面的流程就是Spring的Extensible XML Authoring 扩展机制，我们常用的<aop:xxx>,<context:xx>都是这样加载的。

加载流程

  1. 加载Xml文件
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
			//1. xml解析为Document对象
			Document doc = doLoadDocument(inputSource, resource);
			//2. 解析Docuemnt -> BeanDefinition
			int count = registerBeanDefinitions(doc, resource);
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + count + " bean definitions from " + resource);
			}
			return count;
		}
  1. 判断是解析默认命名空间还是自定义
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    	//通过schema文件的名称空间url来判断是否是默认的名称空间,默认名称空间为 <bean>相关
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						parseDefaultElement(ele, delegate);
					}
					else {
            //2. 解析自定义标签
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
	}
  1. 默认则解析对应标签并设置到BeanDefinition中
//1. 解析不同的默认标签
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { //<import>
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { //<alias>
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { //<bean>
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { //<beans>
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}
	//2. <bean>标签解析流程
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    //2.1 依次读取<bean>里面的属性构造成BeanDefinitionHolder
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				//2.2 注册到IOC容器中
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
		}
	}
  1. 自定义标签则要通过NamespaceHandlerResolver获取到NamespaceHandler，然后获取对应前缀的BeanDefinitionParser解析出BeanDefinition
//1. 解析自定义标签	
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
  	//1.1 获取当前元素的命名空间uri
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
  	//1.2 通过NamespaceHandlerResolver获取对应的spring.handlers中配置好的handler实现
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
  	//委派给BeanDefinitionParser进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

//2. 最后都使用BeanDefinitionRegistry注册到IOC中

注解方式

AnnotationBeanDefinitionReader#register()

相关类图如下：

reader注册

核心类作用
  1. AnnotationBeanDefinitionReader ： 注解BeanDefinition解析注册上下文对象
  2. ConditionEvaluator : 条件注解计算器，用来处理@Conditional相关注解
  3. ScopeMetadata ： Bean的Scope元信息，包含当前Bean的Scope和生成代理对象的模式
  4. BeanNameGenerator : Bean名称生成器
  5. AnnotatedGenericBeanDefinition : 通用注解Bean定义信息
处理过程
//定位到 AnnotatedBeanDefinitionReader#doRegisterBean()
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {
		//1. 创建BeanDefinition
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
  	//2. 进行Conditional相关计算过滤
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
		//3. 设置实例工厂有的话,supplier在Bean的实例化的时候会优先于构造方法实例化
		abd.setInstanceSupplier(supplier);
  	//4. 解析Scope元信息
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
  	//5. 生成BeanName
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//6. 处理通用注解@Lazy ,@Primary ,@DepensOn...
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		//..省略部分自定义扩展
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  	//7. 如果需要代理则会生成代理对象的BeanDefinition
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  	//8. 注册到IOC容器中
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

ConfigurationClassPostProcessor，注解驱动核心处理类

该类是一个BeanDefinitionRegistryPostProcessor，在容器启动的时候会回调其后置处理器相关的方法，对Spring提供的一些列注解进行处理 ， 比如模式注解@Component，以及其派生注解 , @Import,@PropertySource,@ComponentScan等等。

下面我们来进行详细的源码解析，过程比较复杂。还望能耐心的研读！入口为ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		//1. 唯一性检测
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
    //2. 开始解析
		processConfigBeanDefinitions(registry);
	}

正式解析processConfigBeanDefinitions

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		String[] candidateNames = registry.getBeanDefinitionNames();
		//1. 从IOC中获取所有获选的beanNames
		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			//1.1 判断是否已经已经处理过了
			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			//1.2 判断是否是候选的Configuration Class (Component | ComponentScan | Import | ImportSource | Bean) , 若是Configuration且ProxyBeanMethod属性为true,设置属性ConfigurationClassPostProcessor.configurationClass 为full,表示后序该Configuration Class需要被CGLIB增强,其他如Component，Import等为lite.不会被增强
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
        //1.3 添加到候选配置中
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// 若候选的配置类为空则直接返回
		if (configCandidates.isEmpty()) {
			return;
		}
		//2. 根据sort排序好所有的候选Bean
		configCandidates.sort((bd1, bd2) -> {
			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
			return Integer.compare(i1, i2);
		});

		//3. 探测BeanNameGenerator
		SingletonBeanRegistry sbr = null;
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
			if (!this.localBeanNameGeneratorSet) {
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
						AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
				if (generator != null) {
					this.componentScanBeanNameGenerator = generator;
					this.importBeanNameGenerator = generator;
				}
			}
		}
		//初始化Environment对象
		if (this.environment == null) {
			this.environment = new StandardEnvironment();
		}

		//4. 解析所有的ConfigurationClass
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");

			//4.1 解析候选的BeanDefinition 为 Configuration Class
			parser.parse(candidates);
			parser.validate();
			//4.2 读取所有探测到的Configuration Class
			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			//4.3 加载Configuration Class
			this.reader.loadBeanDefinitions(configClasses);
			//4.4 放入已经解析的set集合中
			alreadyParsed.addAll(configClasses);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			candidates.clear();
			//4.5 判断IOC容器中是否新增了Bean数量(即parse方法过程有没有新增Bean)
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set<String> alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				//4.6 将新增的候选beanName添加到候选集合中继续递归处理
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());
		//5. 将ImportRegistry注册为spring bean ，为了支持ImportAware接口回调将ImportClass的注解元信息传入
		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
		}
		//6. 清空ASM中字节码缓存
		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
	}

核心步骤

  • 获取当前IOC容器中所有的BeanDefinition
  • 遍历所有的BeanDefinition , 并使用ConfigurationClassParser进行相关Bean的注解(@Component,@ComponentScan,@Import,@PropertySource...)扫描并构造成Configuration Class
  • 使用ConfigurationClassBeanDefinitionReader#loadBeanDefinition，将构造好的ConfigurationClass注册到IOC中

其中最为核心的是ConfigurationClassParser#parse()将候选的BeanDefinition解析为ConfigurationClass , so go on!

	//ConfigurationClassParser#parse()	
public void parse(Set<BeanDefinitionHolder> configCandidates) {
		//1. 迭代所有候选的Configuration Class
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}
		//2. 最后处理 DeferredImportSelector
		this.deferredImportSelectorHandler.process();
	}

上面的各种不同入参的parse()方法，最后都会走到processConfigurationClass(ConfigurationClass,Predicate<String>)

	protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
		//1. 条件注解(@Condtional)判断
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
		//2. 缓存处理
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			//2.1 若当前Configuration Class已经被处理过了，这里直接合并Import
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				return;
			}
			else {
				//2.2 移除之前处理过的Configuration Class
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}
		//3. (核心)递归解析Configuration Class
		// Recursively process the configuration class and its superclass hierarchy.
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);
		//4. 将当前ConfigurationClass设置到全局变量configurationClasses
		this.configurationClasses.put(configClass, configClass);
	}

doProcessConfigurationClass()终于来到了核心注解的处理方法


protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {
		//1. 处理@Component
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			//1.1 将处理@Component的嵌套类。
			processMemberClasses(configClass, sourceClass, filter);
		}

		//2. 处理@PropertySource，会创建一个PropertySource并添加到Environment中
		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");
			}
		}

		//3. 处理ComponentScan以及其嵌套注解
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		//3.1 如果有ComponentScan元信息，且 注册bean阶段的条件注解通过
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				//解析ComponentScan注解并直接进行scan扫描相关Bean然后注册到容器中
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
         //3.2 若扫描的BeanDefinition中有嵌套的Configuration Class则递归处理
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		//4. 处理@Import注解
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

		//5. 处理@ImportResource
		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);
			}
		}

		//6. 处理@Bean
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
		//7. 处理接口中的@Bean方法 （java8中的 default方法）
		processInterfaces(configClass, sourceClass);

		//8. 递归处理父类
		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;
	}

其中解析到这里大概流程就结束了。相关细节都大同小异。下面我们分布来看各个注解都是如何解析的

  • @Component : 其实很简单，就是使用ASM获取内置类信息，然后递归处理内置相关类
		//1. 处理@Component
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}

	private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
			Predicate<String> filter) throws IOException {
		//1. 获取所有的内置类
		Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
		if (!memberClasses.isEmpty()) {
			List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
			for (SourceClass memberClass : memberClasses) {
				if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
						!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
					candidates.add(memberClass);
				}
			}
			OrderComparator.sort(candidates);
			for (SourceClass candidate : candidates) {
				//3. 若当前Import栈中有了这个Configuration Class则出现循环导入！记录异常
				if (this.importStack.contains(configClass)) {
					this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
				}
				else {
					this.importStack.push(configClass);
					try {
						//2. 递归处理内置类
						processConfigurationClass(candidate.asConfigClass(configClass), filter);
					}
					finally {
						this.importStack.pop();
					}
				}
			}
		}
	}
  • @PropertySource : 会读取@PropertySource注解 元信息，然后读取相关资源构造成一个外部化配置数据源并添加到Environment中
		//2. 处理@PropertySource，会创建一个PropertySource并添加到Environment中
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
		}

	private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
    //1. 解析PropertySource相关属性元信息，从AnnotatioAttributes中获取
		String name = propertySource.getString("name");
		if (!StringUtils.hasLength(name)) {
			name = null;
		}
		String encoding = propertySource.getString("encoding");
		if (!StringUtils.hasLength(encoding)) {
			encoding = null;
		}
		String[] locations = propertySource.getStringArray("value");
		Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
		boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");

		Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
		PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
				DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
		//2. 迭代location并获取资源构造成PropertySource属性源
		for (String location : locations) {
			try {
				String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
				Resource resource = this.resourceLoader.getResource(resolvedLocation);
				addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
			}
			catch (IllegalArgumentException | FileNotFoundException | UnknownHostException | SocketException ex) {
				// Placeholders not resolvable or resource not found when trying to open it
				if (ignoreResourceNotFound) {
					if (logger.isInfoEnabled()) {
						logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
					}
				}
				else {
					throw ex;
				}
			}
		}
	}
  • @ComponentScan ： 也是解析相关注解属性信息，然后直接使用ClassPathBeanDefinitionScanner#doScan()扫描所有Component派生以及ManagedBean,Named等。然后注册到IOC中，并将扫描到的Bean递归进行配置解析
		//3. 处理ComponentScan以及其嵌套注解
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		//3.1 如果有ComponentScan元信息，且 注册bean阶段的条件注解通过
		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());
				//3.2 若扫描的BeanDefinition中有嵌套的Configuration Class则递归处理
				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());
					}
				}
			}
		}


//ComponentScanParser#parse()
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
  		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
		//省略大量读取ComponentScan属性元信息的代码..
  	//1. 使用ClassPathBeanDefinitionScanner进行扫描候选的组件
		return scanner.doScan(StringUtils.toStringArray(basePackages));
}

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		//1. 迭代扫描包
		for (String basePackage : basePackages) {
			//2. 查找包下的组件，直接通过ResourceLoader + ASM来读取字节码文件
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

			//3. 迭代查找到的组件BeanDefinition
			for (BeanDefinition candidate : candidates) {

				//省略相关注解格外属性的处理..
        // 将扫描到的组件注册到IOC中
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
  • @Import,importSelector等相关处理
		//4. 处理@Import注解
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);


	private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {
			this.importStack.push(configClass);
			try {
				for (SourceClass candidate : importCandidates) {
					//1.1 处理ImportSelector
					if (candidate.isAssignable(ImportSelector.class)) {
						//反射实例化ImportSelector并传入 Environment,ResourceLoader,BeanDefinitionReigstry
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
						Predicate<String> selectorFilter = selector.getExclusionFilter();
						if (selectorFilter != null) {
							exclusionFilter = exclusionFilter.or(selectorFilter);
						}
						if (selector instanceof DeferredImportSelector) {
							//暂存DeferredImportSelector,在最后面进行处理
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
							//递归处理ImportSelector导入的配置类
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
						}
					}
					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
						Class<?> candidateClass = candidate.loadClass();
						ImportBeanDefinitionRegistrar registrar =
								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
										this.environment, this.resourceLoader, this.registry);
						//处理ImportBeanDefinitionRegistrar
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					}
					else {
						//处理其他类型的Configuration Class , 并将其添加到imports列表中
						this.importStack.registerImport(
								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
						processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
					}
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to process import candidates for configuration class [" +
						configClass.getMetadata().getClassName() + "]", ex);
			}
			finally {
				this.importStack.pop();
			}
		}
	}

其中Import相关注解到后面都会被添加到ConfigurationClass相关的属性中缓存

final class ConfigurationClass {

	private final AnnotationMetadata metadata;

	private final Resource resource;

	@Nullable
	private String beanName;
	//记录所有@Import导入的Configuration Class
	private final Set<ConfigurationClass> importedBy = new LinkedHashSet<>(1);
	//记录所有解析@Bean生成的BeanMethod
	private final Set<BeanMethod> beanMethods = new LinkedHashSet<>();
	//记录所有@ImportResource （k->resource v->BeanDefinitionReader）
	private final Map<String, Class<? extends BeanDefinitionReader>> importedResources =
			new LinkedHashMap<>();
	//记录所有的ImportBeanDefinitionRegistrar (k -> ImportBeanDefinitionRegistrar ,v -> 声明类的注解元信息)
	private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars =
			new LinkedHashMap<>();
  • 后面还有@ImportResource,@bean，接口等相关处理就不一一列举了。详细的可以看spring的具体实现，其中值得一提的是DeferredImportSelector相关实现会在最后进行Configuration Class的处理，SpringBoot的自动配置类的相关加载就是通过DeferredImportSelector来实现了，确保了在加载自动配置类之前，已经加载了其依赖配置，详细可以参考AutoConfigurationImportSelector

最后使用ConfigurationClassBeanDefinitionReader#loadBeanDefinitionForConfiguratinoClass()完成Configuration Class的加载

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
		//1. 条件注解过滤，若满足则移除该BeanDefinition
		if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}
		//注册Configuration Class
		if (configClass.isImported()) {
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
		//注册BeanMethod
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//处理ImportResource,使用对应BeanDefinitionReader加载BeanDefinition
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
		//处理ImportBeanDefinitionRegistrar
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}

写在最后

由于ConfigurationClassPostProcessor相关解析代码比较复杂，但是其核心还是在相关元信息(AnnotationMetadata)的解析和BeanDefinition的解析(ClassPathBeanDefinitionScanner，BeanDefinitionReader等)和注册方法(BeanDefinitionRegistry#reigsterBeanDefinition)使用，尤其是注解元信息，以及注解属性元信息(AnnotationAttributes)的相关api使用尤为的重要。建议好好看看上面AnnotatedBeanDefinition和更底层的MergedAnnotation相关api。

avatar
文章
阅读
粉丝