Spring 内部工具类 -- AnnotationConfigUtils

最新推荐文章于 2023-03-25 20:47:39 发布
最新推荐文章于 2023-03-25 20:47:39 发布
阅读量3.4k 收藏 2
点赞数
分类专栏： Spring 内部工具 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andy_zhang2007/article/details/78529232
版权

概述

AnnotationConfigUtils是一个Spring内部工具类，用于识别注解配置类中的bean定义。

该工具类主要提供了两个工具方法 :

  1. void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry,Object source)

    该方法主要是向容器注册了一组基础设施PostProcessor bean定义,这些bean定义生成的PostProcessor实例被框架自己用于识别注解配置类中的bean定义。它们里面还有一些作用于BeanDefinitionRegistry(容器级)的BeanDefinitionRegistryPostProcessor,和作用于BeanFactory(容器级)的BeanFactoryPostProcessor,其它才是一般bean级别的BeanPostProcessor。

    另外该方法还注册了一个通用的org.springframework.beans.factory.support.AutowireCandidateResolver ：
    ContextAnnotationAutowireCandidateResolver。

    该方法应用时机: 容器启动过程中

    
AnnotationConfigServletWebServerApplicationContext 构造函数
					====> AnnotatedBeanDefinitionReader 构造函数

  2. void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd)

    输入参数一般是某个基于注解的bean定义(类级别或者方法级别bean定义)，以AnnotatedBeanDefinition类型存在的一个对象实例，可能创建者已经设置了该对象的一些成员属性，但是更多的成员属性还存在于原始bean定义的元数据中，该方法从原始bean定义的元数据中获取那些通用的注解信息：@Lazy,@DependsOn,@Role,@Description,然后设置AnnotatedBeanDefinition实例相应的属性。

    该方法应用时机: 容器启动过程中
    容器启动过程中 :

    1. ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod
    2. AnnotatedBeanDefinitionReader#doRegisterBean

源代码解析

源代码版本 Spring Boot 1.5.8.RELEASE

package org.springframework.context.annotation;


public class AnnotationConfigUtils {

	/**
	 * The bean name of the internally managed Configuration annotation processor.
	 */
	public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

	/**
	 * The bean name of the internally managed BeanNameGenerator for use when processing
	 * Configuration classes. Set by AnnotationConfigApplicationContext
	 * and AnnotationConfigWebApplicationContext during bootstrap in order to make
	 * any custom name generation strategy available to the underlying
	 * ConfigurationClassPostProcessor.
	 * @since 3.1.1
	 */
	public static final String CONFIGURATION_BEAN_NAME_GENERATOR =
			"org.springframework.context.annotation.internalConfigurationBeanNameGenerator";

	/**
	 * The bean name of the internally managed Autowired annotation processor.
	 */
	public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

	/**
	 * The bean name of the internally managed Required annotation processor.
	 */
	public static final String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalRequiredAnnotationProcessor";

	/**
	 * The bean name of the internally managed JSR-250 annotation processor.
	 */
	public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalCommonAnnotationProcessor";

	/**
	 * The bean name of the internally managed JPA annotation processor.
	 */
	public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalPersistenceAnnotationProcessor";


	private static final String PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME =
			"org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor";

	/**
	 * The bean name of the internally managed @EventListener annotation processor.
	 */
	public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

	/**
	 * The bean name of the internally managed EventListenerFactory.
	 */
	public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =		
			"org.springframework.context.event.internalEventListenerFactory";

	private static final boolean jsr250Present =
			ClassUtils.isPresent("javax.annotation.Resource", 
				AnnotationConfigUtils.class.getClassLoader());

	private static final boolean jpaPresent =
			ClassUtils.isPresent("javax.persistence.EntityManagerFactory", 
				AnnotationConfigUtils.class.getClassLoader()) &&
			ClassUtils.isPresent(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, 
				AnnotationConfigUtils.class.getClassLoader());


	/**
	 * 把所有相关的注解bean factory/bean post processor注册到指定的bean registry
	 */
	public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

	/**
 	 * 把所有相关的注解bean factory/bean post processor注册到指定的bean registry
	 * Register all relevant annotation post processors in the given registry.
	 * @param registry the registry to operate on
	 * @param source the configuration source element (already extracted)
	 * that this registration was triggered from. May be null.
	 * @return a Set of BeanDefinitionHolders, containing all bean definitions
	 * that have actually been registered by this call
	 */
	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof 
				ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new 
					ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		    // ConfigurationClassPostProcessor 是一个 BeanDefinitionRegistryPostProcessor
			RootBeanDefinition def = new 
				RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		    // AutowiredAnnotationBeanPostProcessor 是一个 BeanPostProcessor
			RootBeanDefinition def = new 
				RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		    // RequiredAnnotationBeanPostProcessor 是一个 BeanPostProcessor
			RootBeanDefinition def = new 
				RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the 
		// CommonAnnotationBeanPostProcessor.
		if (jsr250Present && 
			!registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		    // CommonAnnotationBeanPostProcessor 是一个 BeanPostProcessor
			RootBeanDefinition def = new 
				RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && 
			!registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
		
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + 
							PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
		    // EventListenerMethodProcessor 是一个 SmartInitializingSingleton
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
		    // DefaultEventListenerFactory 是一个 EventListenerFactory
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, 
				EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}

	private static DefaultListableBeanFactory 
		unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
		if (registry instanceof DefaultListableBeanFactory) {
			return (DefaultListableBeanFactory) registry;
		}
		else if (registry instanceof GenericApplicationContext) {
			return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
		}
		else {
			return null;
		}
	}
	// 将注解元数据信息中Bean定义相关的通用属性应用到BeanDefinitaion上
	public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

	/**
  	 * 	将注解元数据信息中Bean定义相关的通用属性应用到BeanDefinitaion上
  	 *  参数 abd ： Bean定义
  	 *  参数 metadata : 类型上的注解元数据信息
 	 **/
	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, 
		AnnotatedTypeMetadata metadata) {
		if (metadata.isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata && 
			abd.getMetadata().isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
		}

		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		if (metadata.isAnnotated(DependsOn.class.getName())) {
			abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
		}

		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
			if (metadata.isAnnotated(Role.class.getName())) {
				absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
			}
			if (metadata.isAnnotated(Description.class.getName())) {
				absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
			}
		}
	}

	static BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, 
			BeanDefinitionRegistry registry) {

		ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
		if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
			return definition;
		}
		boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
	}

	static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, 
		Class<?> annotationClass) {
		return attributesFor(metadata, annotationClass.getName());
	}

	static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, 
		String annotationClassName) {
		return AnnotationAttributes.fromMap(
			metadata.getAnnotationAttributes(annotationClassName, false));
	}

	static Set<AnnotationAttributes> attributesForRepeatable(AnnotationMetadata metadata,
			Class<?> containerClass, Class<?> annotationClass) {

		return attributesForRepeatable(metadata, containerClass.getName(), 
			annotationClass.getName());
	}

	@SuppressWarnings("unchecked")
	static Set<AnnotationAttributes> attributesForRepeatable(AnnotationMetadata metadata,
			String containerClassName, String annotationClassName) {

		Set<AnnotationAttributes> result = new LinkedHashSet<AnnotationAttributes>();
		addAttributesIfNotNull(result, 
			metadata.getAnnotationAttributes(annotationClassName, false));

		Map<String, Object> container = metadata.getAnnotationAttributes(
				containerClassName, false);
		if (container != null && container.containsKey("value")) {
			for (Map<String, Object> containedAttributes : 
				(Map<String, Object>[]) container.get("value")) {
				addAttributesIfNotNull(result, containedAttributes);
			}
		}
		return Collections.unmodifiableSet(result);
	}

	private static void addAttributesIfNotNull(Set<AnnotationAttributes> result, 
		Map<String, Object> attributes) {
		if (attributes != null) {
			result.add(AnnotationAttributes.fromMap(attributes));
		}
	}

}
安迪源文
关注
专栏目录
ConfigUtil 工具
一名屌丝程序员的秘密花园
04-11 1837
package com.founder.ics.utils;import android.content.Context;import android.content.SharedPreferences;/** * 配置文件操作工具类 * @author GaoJR * */public class ConfigUtil { private static final String CONFIG_F...
Spring5源码13-AOP源码分析(上)
java_lujj的博客
08-30 142
Spring 借助AspectJ的切点表达式语言来定义 Spring 切面AspectJ指示器描述arg()限制连接点匹配参数为指定类型的执行方法@args()限制连接点匹配参数由指定注解标注的执行方法用于匹配是连接点的执行方法this()限制连接点匹配 AOP代理的bean引用为指定类型的类target限制连接点匹配的目标对象为指定类型的类@target()限制连接点匹配特定的执行对象，这些对象对应的类要具有指定类型的注解within()限制连接点匹配指定的类型。...
【小家Spring】Spring贡献的多个注解相关的工具类：AnnotationUtils、AnnotatedElementUtils、AnnotationConfigUtils...
架构师：通透，才能写出好代码！
03-24 4684
AliasFor解释的使用场景 前言 本文主要聊聊Spring提供的多个关于注解相关的工具类：AnnotationUtils和AnnotatedElementUtils等等 因为很多逻辑都封装在了工具类里面，因此要理解Spring的深层意思，有时候不了解工具类也是比较麻烦的 虽然说都是Spring内部去使用，但是有些工具类是public的(下面会有介绍)，所以我们平时若有需要，也是可以使用的 本...
spring中的AnnotationConfigUtils
多看多听多总结
03-14 723
1、概要 AnnotationConfigUtils作为抽象类作为静态方法来使用，其主要是注册一些公共的BeanPostProcessor及BeanFactoryPostProcessor及处理一些公共的注解。像AnnotataionConfigApplicationContext基于注解的上下文初始化时会调用到。 2、注册处理器 主要包括ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotat
Spring-context-AnnotationConfigUtils类
文天大人
10-15 1082
本文只讲述该工具类中的静态方法：registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) 为什么不讲述其他方法呢？因为其他方法我不知道是做什么的 作用：当用注解的方式启动项目时，将处理这些注解的基础设施类放到DefaultListableBeanFactory当中，因为无论如何，终归要有一些写死的基础类，来处理我们自己的...
AnnotationConfigUtils 处理注解Bean 定义类中的通用注解
Leon_Jinhai_Sun的博客
11-15 372
AnnotationConfigUtils 类的processCommonDefinitionAnnotations()在向容器注册Bean 之前，首先对注解Bean 定义类中的通用Spring 注解进行处理，源码如下： //处理Bean定义中通用注解 static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) { AnnotationAttrib
ConfigUtil（配置文件加载操作）
kucaozhuzhu的专栏
01-27 1219
纯代码 第一步：配置好配置文件：   配置文件置于 框架的 src 下，命名为 application.properties 内容类似于： #oracle version database settings #jdbc.driver=oracle.jdbc.driver.OracleDriver #jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:s
Spring零基础入门到精通 --- IOC基础容器
最新发布
shuai_h的博客
03-25 1544
Spring零基础入门到精通
spring分析-启动大致流程
luolei1994的博客
07-16 858
spring 实现分析 AnnotationConfigApplicationContext refresh 之前 refresh 方法 prepareRefresh obtainFreshBeanFactory prepareBeanFactory postProcessBeanFactory invokeBeanFactoryPostProcessors initMessageSource...
[Spring Boot] 1. Spring Boot启动过程源码分析
热门推荐
不忘初心，好好沉淀
08-05 2万+
关于Spring Boot，已经有很多介绍其如何使用的文章了，本文从源代码(基于Spring-boot 1.5.6)的角度来看看Spring Boot的启动过程到底是怎么样的，为何以往纷繁复杂的配置到如今可以这么简便。1. 入口类package com.example.demo;import org.springframework.boot.SpringApplication; import org
这个是用来测试ConfigUtils的
08-27
The all-volunteer ASF develops, stewards, and incubates more than 350 Open Source projects and initiatives that cover a wide range of technologies. From Abdera to Zookeeper, if you are looking for a rewarding experience in Open Source and industry leading software, chances are you are going to find it here. Are you powered by Apache?
spring-aop源码（一）创建AnnotationAwareAspectJAutoProxyCreator过程
qq_33230747的博客
11-16 285
系列文章目录 【spring-aop源码（一）创建AnnotationAwareAspectJAutoProxyCreator过程】 【spring-aop源码（二）创建代理对象过程】 【spring-aop源码（三）调用aop代理方法过程】 SpringBoot源码地址：https://github.com/spring-projects SpringBoot版本：2.4.0-SNAPSHOT SpringBoot分支：master 文章目录 前言 一、@EnableAspectJ.
spring5.2.x源码阅读笔记-AnnotationConfigApplicationContext构建（二）register(componentClasses)
weixin_43836063的博客
04-08 1288
接上一篇，使用同样的测试用例 代码块1：register(Class<?>... componentClasses) public void register(Class<?>... componentClasses) { Assert.notEmpty(componentClasses, "At least one component class must be specified"); this.reader.register(componentClasses);
工具类3：ConfigUtil
ahua186186的专栏
02-21 204
public class ConfigUtil { private static PropertiesConfiguration config=null; static{ try{ //config = new PropertiesConfiguration("app.properties"); //config.setEncoding("UTF-8"); ...
小程序工具utils的config封装
weixin_42593599的博客
08-23 1735
//这里是承接上篇文章,为其暴露接口 class Config{ constructor(){ } } Config.tributeUrl = '';//这里写你要调用的后端接口url Config.xmdUrl = '';//同上 Config.onPay=true; //是否启用支付 export {Config};  ...
utils/config.sh
jason的笔记
12-13 645
#!/bin/bash # 通过echo 打印log echo "Begin configure build enviroment." #如果在根目录下不存在rpmmacros的话，则通过wget下载。这里的-O ~/ 表示将下载的文件保存到~/ 这个目录下 #可以这里用-O其实有一点优化，如果不用-O的话，则需要cp/mv 将下载到当前目录的rpmmacros copy到对应的目录下面 if [
读取文件参数配置工具类ConfigUtil
Leopard锋的博客
10-23 800
静态注入文件方法： import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.util.Properties; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** ...
Spring源码分析——AnnotationConfigApplicationContext组件注册流程
byx的博客
06-29 386
工程搭建 Maven依赖： <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.5</version> </dependency> </depen
项目中使用的ConfigUtil 类的封装，支持多元
司刚军的个人专栏
04-22 2184
import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.ResourceBundle; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.log4j.Logger;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值