Spring容器之Bean的“前世今生”

前言

Spring框架是当前Java企业级应用开发的首选框架，其可以通过整合SSH（新项目较少）、SSM或者使用SpringBoot等作为项目搭建的底层框架。无论是选择与Spring框架的整合又或者直接使用SpringBoot，基础都是Spring，通过Spring容器来接管对象，并提供各种扩展点来简化开发。本文主要介绍Spring容器的核心点，讲述其是如何Bean是如何一步一步创建的。

---

一、“Bean的前世”：BeanDefinition

1、BeanDefinition是什么？

Spring容器的创建，离不开BeanDefinition即Bean定义信息（以下简称BD），其在源码中是一个接口，我们可以将BD理解为对象信息的载体，用来操作创建Bean对象的“原材料”，比如Bean的id、name、class、scope等等，有了这些信息，Spring才可以根据BD内容为我们创建相应的Bean。

2、如何获取并解析BD？

有了BD这个Bean对象信息的载体，我们如何进行定义，Spring又如何获取并构建BD载体呢？
首先，如何进行定义，相信我们在工作和日常开发中是经常接触的。一开始会用的xml文件的方式对BD进行定义，有了注解之后，我们会使用各种注解进行BD的定义。
定义了BD载体，之后便是如何对其进行解析和构建了。Spring提供了不同方式的BD解析器，例如解析xml文件的XmlBeanDefinitionReader、解析注解的AnnotatedBeanDefinitionReader、扫描classpath路径的ClassPathBeanDefinitionScanner等。

（1）XmlBeanDefinitionReader

当我们创建一个ClassPathXmlApplicationContext的时候，其会对我们传入的xml文件路径进行解析，其中就会用到XmlBeanDefinitionReader解析器，将我们的xml文件中的BD信息进行获取并构建。

ClassPathXmlApplicationContext的实例化会去调用refresh方法。

在refresh方法中通过obtainFreshBeanFactory方法来获取最新的BeanFactory，根据上面方法的调用，可以知道其中会调用loadBeanDefinition这个方法，而这个方法的实现中就会有XmlBeanDefinitionReader解析器来对xml中定义的BD进行解析以及构建BD对象，并存放到beanDefinitionMap这个ConcurrentHashMap中，方便后面Bean对象的实例化，具体实现有兴趣的可以debug一下源码。

（2）AnnotatedBeanDefinitionReader以及ClassPathBeanDefinitionScanner

当创建一个AnnotationConfigApplicationContext的时候，其会实例化AnnotatedBeanDefinitionReader以及ClassPathBeanDefinitionScanner对BD进行解析和获取。


我们以register方法为例，看一下注解方式如何对BD进行获取和解析：进入源码我们来到AnnotatedBeanDefinitionReader的doRegisterBean方法中。

	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {

		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(supplier);
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//通过BeanDefinitionReaderUtils的registerBeanDefinition方法进行BD的解析并添加到BeanDefinitionMap中
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

3、完成BD解析并注册在beanDefinitionMap

当解析完成xml或者注解，最终获取BD信息，并创建出BD对象，随后会将每个BD对象都注册在BeanDefinitionMap中，从而完成Spring容器需要管理对象的一系列BD信息，有了BD信息Spring就能够根据这些信息来帮我们创建相对应的Bean对象，并进行后续的对象管理。

4、自定义扩展

当然，我们也可以自定义自己的BD读取方式，例如通过yml、properties、json等等格式来获取BD信息，最后添加进beanDefinitionMap中即可交给Spring容器去创建对应的Bean对象。
回到refresh方法，在以下两个方法，我们可以定义各种BD获取方式，并添加进beanDefinitionMap，即可交给Spring创建相应的Bean对象。

第一个postProcessBeanFactory，需要在我们去实现子类的postProcessBeanFactory方法，在这个方法中进行BD的获取和添加；
第二个是invokeBeanFactoryPostProcessors，需要去实现BeanFactoryPostProcessor这个接口，是Spring框架中重要的扩展点之一，是对BeanFactory的增强扩展，也是Bean对象添加在Spring容器之前的扩展方法。

---

二、“Bean的今生”：Bean的实例化和扩展

有了上述的BD对象，接下来Spring就可以创相对应的Bean对象，并进行管理了，接下来讲解一下Bean的创建，看看Spring容器是如何一步一步创建并管理对象的。

1、BeanPostProccessor的注册

我们回到refresh方法，在调用BeanFactoryPostProcessor方法之后，将实现BeanPostProcessor接口的注册进beanPostProcessors中，为后面Bean的生命周期提供可扩展点。

2、Bean的生成及扩展

我们来跟下finishBeanFactoryInitialization这个方法调用过程。

	/********************finishBeanFactoryInitialization方法****************************/
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		//...省略

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

	/********************preInstantiateSingletons方法****************************/
	@Override
	public void preInstantiateSingletons() throws BeansException {
		//...省略
		
		//这里获取所有的beanDefinitionNames
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
				   //获取bean实例的方法getBean
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					//...省略
					
				else {
					getBean(beanName);
				}
			}
		}
		
		//...省略
		
	/********************getBean方法****************************/
	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
	
	/********************doGetBean方法****************************/
	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
				//...省略

				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//创建Bean方法
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				//...省略

		return adaptBeanInstance(name, beanInstance, requiredType);
	}


   /********************createBean方法****************************/
	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		//...省略
		
		try {
		    //doCreateBean
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

接下来，重点就在doCreateBean方法，其会在实例化Bean对象之后会去设置属性以及初始化bean。

设置属性populateBean方法会获取我们@Autowired需要注入的属性，并添加；初始化bean，执行initializeBean方法就会进行Bean的增强/扩展。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				//调用aware方法，判断bean是否实现Aware接口，根据不同的Aware实现设置不同的值，setBeanName，setBeanClassLoader，setBeanFactory
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//使用BeanPostProcessor增强，判断bean是否实现BeanPostProcessor，是的话会调用其postProcessBeforeInitialization方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			//调用初始化方法，判断bean是否实现InitializingBean，是的话会调用其afterPropertiesSet方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			//..省略
		}
		if (mbd == null || !mbd.isSynthetic()) {
			//使用BeanPostProcessor增强，判断bean是否实现BeanPostProcessor，是的话会调用其postProcessAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

最后，其会将获取得到的bean进行返回，并添加在singletonObjects这个ConcurrentHashMap中，此时bean就完成了其创建过程，接下来，我们就可以直接在Spring容器中获取想要的Bean对象了。

总结

本文主要讲解Spring容器的Bean对象的来源以及主要创建过程，从配置注解到BeanDefinition，从BeanDefinition到Bean的创建以及扩展，其实际上还包括aop代理的实现，循环依赖解决的三级缓存等等。有兴趣的可以持续关注我的博客以及我的同名微信公众号“猿梦学码”，我将不定期更新Spring、SpringBoot等框架源码的内容，一起学习，一起秃头。