spring加载流程之AnnotatedBeanDefinitionReader

于 2019-03-01 23:57:14 发布
阅读量1.1w 收藏 65
点赞数 25
分类专栏： spring源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yu_kang/article/details/88068619
版权

spring加载流程之AnnotatedBeanDefinitionReader


缘起：自上次编译spring源码成功之后（ 记一次spring源码编译的血泪史），刚好已经过去一个月了，在这期间我边读源码编写注释。其实本来不准备写spring源码博客的。但是发现读一遍两遍还是会记不住一些加载流程的场景，于是再重温一遍的时候，想着一边死磕源码一边写博客分享，看看能坚持多久吧…

读源码的技巧是先跟着debug大致跟一下加载流程，然后将一些重点或者不懂的地方分块慢慢消化，于是我准备采用分块的形式来记录spring源码,当然会附上详细的注释。

为了方便（也是为了趋势），spring源码的分析将全部采用java注解的形式来解读。

spring程序入口

AnnotationConfigApplicationContext context =
				new AnnotationConfigApplicationContext(Test.class);

这行代码（好吧，两行代码），相信各位大佬应该都知道吧。放在main函数里面，执行run就可以启动程序了。

到底加不加@Configuration

Test.class一般是配置类，这里有的童鞋可能要说了，我知道我知道，就是需要加上@Configuration的类。咳咳…其实也没错，但是其实也可以不用加@Configuration，不信你可以去试试，程序照样成功运行。至于配置类加了@Configuration与不加有什么区别，后面可能会专门出一篇文章详解，因为这一块我也还没有深磕，可以提示下加了@Configuration后的配置类会由cglib动态代理。
放图解释：
加了@Configuration
在这里插入图片描述
不加@Configuration
在这里插入图片描述

AnnotationConfigApplicationContext的构造函数

AnnotationConfigApplicationContext就是当前上下文的容器，有多个构造函数，我们就
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses)来分析。

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		/**
		 * 这里由于他有父类，所以会先调用父类的构造方法:
		 * 	看源码得知初始化了DefaultListableBeanFactory
		 *
		 * 然后才调用自己的构造方法:
		 * 1.创建一个读取注解的Bean定义读取器
		 * 	将bean读取完后，会调用DefaultListableBeanFactory注册这个bean
		 * 2.
		 */

		this();
		register(annotatedClasses);
		refresh();
	}

这个构造函数有3行代码，每一行都够研究一阵子了，先看this();执行自己的无参构造函数，于是先执行父类GenericApplicationContext的默认构造函数

先加载父类的构造函数

继承关系图：
在这里插入图片描述

public GenericApplicationContext() {
		// 初始化一个beanFactory
		this.beanFactory = new DefaultListableBeanFactory();
	}

记住这个DefaultListableBeanFactory，非常重要，spring加载的bean都会放到这里面去，上面截图的test就是在DefaultListableBeanFactory里面。
当然GenericApplicationContext的父类AbstractApplicationContext，包括AbstractApplicationContext的父类DefaultResourceLoader都有默认构造函数

public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}

public DefaultResourceLoader() {
		this.classLoader = ClassUtils.getDefaultClassLoader();
	}

这些提前初始化的属性到后面都会用到。

AnnotatedBeanDefinitionReader

这时候再回去看AnnotationConfigApplicationContext(Class<?>... annotatedClasses)构造函数中的this();

public AnnotationConfigApplicationContext() {
		/**
		 * 创建一个读取注解的Bean定义读取器
		 * 什么是bean定义？BeanDefinition
		 *
		 * 完成了spring内部BeanDefinition的注册（主要是后置处理器）
		 */
		this.reader = new AnnotatedBeanDefinitionReader(this);

		/**
		 * 创建BeanDefinition扫描器
		 * 可以用来扫描包或者类，继而转换为bd
		 *
		 * spring默认的扫描器其实不是这个scanner对象
		 * 而是在后面自己又重新new了一个ClassPathBeanDefinitionScanner
		 * spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner
		 *
		 * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法
		 *
		 */
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

AnnotationConfigApplicationContext默认的构造函数只有两行代码，它们之间是互不影响。所以这两行代码准备分两章节来解读，提前贴出代码的注释。
本章节讲解AnnotatedBeanDefinitionReader，所以跟进第一行代码。

AnnotatedBeanDefinitionReader的构造函数

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}
	
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		Assert.notNull(environment, "Environment must not be null");
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		/**
		 * registerAnnotationConfigProcessors
		 * 根据名字顾名思义就是->注册注解配置的的处理器
		 * 也就是这个方法里面会注册一些用于处理注解的处理器
		 */
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

1.首先第一个构造函数里面的参数registry其实就是当前上下文AnnotationConfigApplicationContext，因为传的是this就是自己，从这里也可以看出AnnotationConfigApplicationContext实现了BeanDefinitionRegistry接口，放图：
在这里插入图片描述
2.第二个构造函数只看最后一行，看注释就知道是干嘛用的，代码跟进

AnnotationConfigUtils

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}
	
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		// 获取beanFactory也就是DefaultListableBeanFactory
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				/**
				 * AnnotationAwareOrderComparator主要能解析@Order和@Priority
				 */
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				/**
				 * ContextAnnotationAutowireCandidateResolver提供处理延迟加载的功能
				 */
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		/**
		 * spring默认的BeanDefinition的注册，很重要，需要理解每个bean的类型
		 */
		// 注册ConfigurationAnnotationProcessor
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

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

		// 注册RequiredAnnotationBeanPostProcessor
		if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			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.
		// 注册CommonAnnotationBeanPostProcessor
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			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.
		// 注册PersistenceAnnotationProcessor
		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));
		}

		// 注册EventListenerMethodProcessor
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		// 注册DefaultEventListenerFactory
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

1.unwrapDefaultListableBeanFactory(registry);方法里面的代码非常简单易看懂，简单到我不想贴代码。
接下来就是一个大if判断里面的两个小if判断，很奇怪两个判断都会进去，beanFactory的这两个属性后面用到的时候在具体说明。
2.然后就是下面7个默认的spring内部bean的注册

注册ConfigurationClassPostProcessor

public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

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

ConfigurationClassPostProcessor是一个工厂后置处理器，这个后置处理器非常重要，基本上类上面的注解都在这里面判断并解析，spring的包扫描也在里面完成，在后面会具体分析spring加载流程之ConfigurationClassPostProcessor

注册AutowiredAnnotationBeanPostProcessor

public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

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

顾名思义就是处理@Autowired的，它是一个bean的后置处理器，在bean的属性注入的时候会用到

注册RequiredAnnotationBeanPostProcessor

public static final String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalRequiredAnnotationProcessor";

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

顾名思义就是处理@Required的，它是一个bean的后置处理器，在bean的属性注入的时候会用到

注册CommonAnnotationBeanPostProcessor

public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalCommonAnnotationProcessor";

if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

顾名思义就是处理一些公共注解的，它是一个bean的后置处理器，可以处理@PostConstruct和@PreDestroy还有@Resource等
提示： 这里有一个jsr250Present校验

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

就是判断@Resource的路径存不存在，讲道理不会不存在，这是jdk里面的

注册PersistenceAnnotationBeanPostProcessor

public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalPersistenceAnnotationProcessor";

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));
		}

这里先看jpaPresent

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

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

就是判断是否存在PersistenceAnnotationBeanPostProcessor这个类，很明显这是对jpa的处理，所以需要引入spring-orm的包，没有引入的话则spring不会注册这个类

注册EventListenerMethodProcessor

public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

这是对@EventListener注解的处理，spring实现事件监听的方式有很多种，其中一种就是在方法上添加@EventListener注解@EventListener注解式实现

注册DefaultEventListenerFactory

EventListenerMethodProcessor中会调用DefaultEventListenerFactory的方法，注册的具体实现是由DefaultEventListenerFactory处理

public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerFactory";

if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

这个也是跟事件监听有关，具体还不是很了解，后面可能会补充

注册以上bean的方法registerPostProcessor()

上面用到了registerPostProcessor方法来注册beanDefinition

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

		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

		/**
		 * registry就是AnnotationApplicationContext
		 * 这里是调用父类GenericApplicationContext中的registerBeanDefinition方法
		 * 调用beanFactory将spring默认的BeanDefinition注册进去
		 */
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}
	
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		// 一开始就初始化了DefaultListableBeanFactory
		this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}

再往beanFactory.registerBeanDefinition(beanName, beanDefinition);里面跟进，其实就是

this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

不多说，来看一下DefaultListableBeanFactory的属性

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

处理注解的方法processCommonDefinitionAnnotations()

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}
	
    /**
	 * 检查通用的注解
	 * 并添加到数据结构中去
	 * @param abd
	 * @param metadata
	 */
	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}

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

		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
			AnnotationAttributes role = attributesFor(metadata, Role.class);
			if (role != null) {
				absBd.setRole(role.getNumber("value").intValue());
			}
			AnnotationAttributes description = attributesFor(metadata, Description.class);
			if (description != null) {
				absBd.setDescription(description.getString("value"));
			}
		}
	}

这个方法processCommonDefinitionAnnotations()在后面会用到，注册beanDefinition的时候会先处理类当中的通用注解，分析源码可以知道他主要处理Lazy、DependOn、 Primary 、Role等注解，然后将注解的信息添加到数据结构BeanDefinition中去，BeanDefinition就是描述bean注册的信息。
上面注册的7个内部bean是没有任何注解的，所以没用到这个方法。

AnnotatedBeanDefinitionReader很重要的方法register()

public void register (Class<?>... annotatedClasses) {
		for (Class<?> annotatedClass : annotatedClasses) {
			registerBean(annotatedClass);
		}
	}

这个方法在AnnotationConfigApplicationContext的默认构造函数执行完后在来具体分析，因为spring加载流程还没到这里，可以先看下第2行的代码

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		this();
		register(annotatedClasses);
		refresh();
	}
	
	/**
	 * 注册一个或多个bean给容器
	 * 比如有新加的类可以调用这个方法
	 * 但是注册之后需要手动调用refresh方法
	 */
public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}

this.reader.register(annotatedClasses);的reader就是默认构造函数初始化的AnnotatedBeanDefinitionReader

new ClassPathBeanDefinitionScanner之前

到此为止，this.reader = new AnnotatedBeanDefinitionReader(this);就执行完了
可以看一下beanDefinitionMap中大小
在这里插入图片描述
除了jpa的那个bean(beanName为org.springframework.context.annotation.internalPersistenceAnnotationProcessor)没有之外，其余的6个内部bean都注册进DefaultListableBeanFactory中去了

浴缸灬
关注
  • 25
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值