Spring源码解析(16)之refresh(4)-prepareBeanFactory源码分析

一、前言

        在这一篇博客中我们主要是介绍prepareBeanFactory方法，bean工厂的初始化准备工作，设置bean工厂的一些属性值，需要忽略哪一些接口，需要注册哪一些bean，需要设置哪一些bean的后置处理器等。接下来我们看具体的源码分析，并且这里我们还看看Spring属性编辑器，以及我们如果去拓展一个属性编辑器。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());

		// 设置SPEL表达式解析器，用来支持Spring的SPEL表达式
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

		// 添加属性编辑注册器。例如一个字符串类型的地址需要转换为一个Address对象，可以使用该功能.
		// 可参考示例：spring-source-study模块下的com.wb.spring.propertyeditor包下的示例程序
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 添加bean的后置处理器。此处添加的是Spring自己的后置处理器，用来回调bean所实现的aware接口中的方法.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

		// 下面的ignoreDependencyInterface是用来设置bean工厂中需要忽略的接口
		// 可以通过实现EnvironmentAware接口来获取到当前的环境信息Environment。
		/**
		 * 如果将EnvironmentAware接口添加到ignoreDependencyInterface中，则在使用的地方通过@Autowired将会无法正常注入
		 *   而是需要通过setEnvironment方法进行注入，下面的其他接口都类似.
		 */
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		// 可以通过实现EmbeddedValueResolverAware接口来获取String类型值的解析器
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		// 资源加载器，例如使用：@Autowired ResourceLoaderAware aware; 将不会被注入
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		// 事件发布器
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		// 消息资源
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		// 应用的上下文信息
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// 注册一些可以自动装配的接口。 当类型为dependencyType时， 注入autowiredValue。为了解决一个类型有多个子类实现时，优先注入那个子类实现的问题。
		// 例如下面第一个，当注入类型为BeanFactory时，注入的值为beanFactory，默认为DefaultListableBeanFactory
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		// 当注入类型为ResourceLoader时，注入的值为ApplicationContext
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		// 当注入类型为ApplicationEventPublisher时，注入的值为ApplicationContext
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		// 当注入的类型为ApplicationContext时，注入的值为ApplicationContext.
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 增加一个bean的后置处理器，ApplicationListenerDetector
		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		// 如果bean工厂中存在着名称为loadTimeWeaver的bean定义，则给bean工厂中加入LoaderTimeWeaverAwareProcessor后置处理器
		// 补充：1、增加对AspectJ的支持，在Java中织入分为3种：(1) 编译期织入; (2) 类加载期织入; (3) 运行期织入。编译期织入指的是在java编译期，
		//         采用特殊的编译器，将切面织入到java类中；类加载期织入则指的是通过特殊的类加载器，在字节码加载到JVM时，织入切面；运行期织入则是
		//         通过采用cglib或者jdk进行切面的织入。
		//      2、aspectJ中提供了两种方式：
		//         (1) 通过特殊编译器，在编译期，将aspectJ语言编写的切面类织入到java类中；
		//         (2) 类加载期织入，就是通过下面的LoadTimeWeaving
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 给容器中注册一些与运行环境相关的单实例Bean
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			// beanName: environment，直接将new出来的Spring内部对象放入到Spring的单实例缓存池中.
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}

		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			// beanName: systemProperties   方法：System.getProperties();
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}

		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			// beanName: systemEnvironment,   方法：System.getEnv();
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

• 设置bean的加载器
• 设置SPEL表达式解析器，用来支持Spring的SPEL表达式
• 添加属性编辑注册器。例如一个字符串类型的地址需要转换为一个Address对象，可以使用该功能，一会我们来实现一个自定义的属性编辑器，我们一会看看他的属性编辑器是如何实现的。
• 添加bean的后置处理器。此处添加的是Spring自己的后置处理器，用来回调bean所实现的aware接口中的方法.
• ignoreDependencyInterface是用来设置bean工厂中需要忽略的接口。
• 注册一些可以自动装配的接口。 当类型为dependencyType时， 注入autowiredValue。为了解决一个类型有多个子类实现时，优先注入那个子类实现的问题。
• 增加一个bean的后置处理器，ApplicationListenerDetector。

二、ResourceEditorRegistrar属性编辑器

        我们可以看得到他是实现PropertyEditorRegistrar接口，里面只有一个方法registerCustomEditors就是用来注册我们的属性编辑器。这里注册的是一些Spring默认的属性编辑器。

public class ResourceEditorRegistrar implements PropertyEditorRegistrar {

	private final PropertyResolver propertyResolver;

	private final ResourceLoader resourceLoader;


	/**
	 * Create a new ResourceEditorRegistrar for the given {@link ResourceLoader}
	 * and {@link PropertyResolver}.
	 * @param resourceLoader the ResourceLoader (or ResourcePatternResolver)
	 * to create editors for (usually an ApplicationContext)
	 * @param propertyResolver the PropertyResolver (usually an Environment)
	 * @see org.springframework.core.env.Environment
	 * @see org.springframework.core.io.support.ResourcePatternResolver
	 * @see org.springframework.context.ApplicationContext
	 */
	public ResourceEditorRegistrar(ResourceLoader resourceLoader, PropertyResolver propertyResolver) {
		this.resourceLoader = resourceLoader;
		this.propertyResolver = propertyResolver;
	}


	/**
	 * Populate the given {@code registry} with the following resource editors:
	 * ResourceEditor, InputStreamEditor, InputSourceEditor, FileEditor, URLEditor,
	 * URIEditor, ClassEditor, ClassArrayEditor.
	 * 
If this registrar has been configured with a {@link ResourcePatternResolver},
	 * a ResourceArrayPropertyEditor will be registered as well.
	 * @see org.springframework.core.io.ResourceEditor
	 * @see org.springframework.beans.propertyeditors.InputStreamEditor
	 * @see org.springframework.beans.propertyeditors.InputSourceEditor
	 * @see org.springframework.beans.propertyeditors.FileEditor
	 * @see org.springframework.beans.propertyeditors.URLEditor
	 * @see org.springframework.beans.propertyeditors.URIEditor
	 * @see org.springframework.beans.propertyeditors.ClassEditor
	 * @see org.springframework.beans.propertyeditors.ClassArrayEditor
	 * @see org.springframework.core.io.support.ResourceArrayPropertyEditor
	 */
	@Override
	public void registerCustomEditors(PropertyEditorRegistry registry) {
		ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);
		doRegisterEditor(registry, Resource.class, baseEditor);
		doRegisterEditor(registry, ContextResource.class, baseEditor);
		doRegisterEditor(registry, InputStream.class, new InputStreamEditor(baseEditor));
		doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));
		doRegisterEditor(registry, File.class, new FileEditor(baseEditor));
		doRegisterEditor(registry, Path.class, new PathEditor(baseEditor));
		doRegisterEditor(registry, Reader.class, new ReaderEditor(baseEditor));
		doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));

		ClassLoader classLoader = this.resourceLoader.getClassLoader();
		doRegisterEditor(registry, URI.class, new URIEditor(classLoader));
		doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));
		doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));

		if (this.resourceLoader instanceof ResourcePatternResolver) {
			doRegisterEditor(registry, Resource[].class,
					new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));
		}
	}

	/**
	 * Override default editor, if possible (since that's what we really mean to do here);
	 * otherwise register as a custom editor.
	 */
	private void doRegisterEditor(PropertyEditorRegistry registry, Class requiredType, PropertyEditor editor) {
		if (registry instanceof PropertyEditorRegistrySupport) {
			((PropertyEditorRegistrySupport) registry).overrideDefaultEditor(requiredType, editor);
		}
		else {
			registry.registerCustomEditor(requiredType, editor);
		}
	}

}

        现在我们如果需要实现自定义的一个属性编辑器，我们改如何去做呢？就好比我们现在要将字符串解析成我们对应的地址，在实际的项目需求中，比如说是string转成成我们的localDate等需求。

        到这里我们首先要看明确一个东西，这些属性编辑器的时候是在什么时候进行调用，我们看下createBeanInstance方法的源码。

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 解析Bean的Class类型
		Class beanClass = resolveBeanClass(mbd, beanName);

		// 如果Bean不是public，而且是不允许共有权限访问，直接抛出异常.
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		/**
		 * 通过指定的回调方法去创建bean实例，Spring5.0版本之后新增的方法。
		 *  可以通过实现BeanFactoryPostProcessor接口来进行扩展，设置自定义的Supplier，通过自定义supplier实例化对象
		 */
		// 可参考：【示例代码：com.wb.spring.supplier.SupplierBeanFactoryPostProcessor】
		Supplier instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		/**
		 * 如果当前bean指定了对应的工厂方法，则通过工厂方法去创建bean实例
		 *   底层会获取工厂方法【静态工厂方法|实例化方法】--> 然后解析方法入参 --> 然后执行反射调用创建实例 --> 封装为包装对象返回.
		 *
		 *   fixme: 该方法的实现特别长 230行左右的代码
		 */
		if (mbd.getFactoryMethodName() != null) {
			// 通过工厂方法创建实例，可参考：【示例代码：com.wb.spring.factorymethod.InstanceFactoryMethod，com.wb.spring.factorymethod.StaticFactoryMethod】
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		// 原型(prototype)，多次获取的时候会走该分支
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				// 因为一个类可能由多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数。
				// 因为判断过程会比较，所以spring会将解析、确定好的构造函数缓存到BeanDefinition中的resolvedConstructorOrFactoryMethod字段中。
				// 在下次创建相同时直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值获取，避免再次解析
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					// 表示构造函数的参数是否已经解析妥当
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			// 如果构造函数的参数已经解析妥当
			if (autowireNecessary) {
				// 则通过构造函数完成实例的创建
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 使用默认的bean对象创建策略进行bean对象的创建  ***【此处使用了策略设计模式】***
				return instantiateBean(beanName, mbd);
			}
		}

		/** 推断构造方法，获取候选的用来创建bean对象的构造函数 */
		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		// 获取到了构造函数 || 注入模式为使用构造函数 || bean定义中指定了带参数的构造函数 || 创建bean对象时的入参args[参数列表对应的值列表]不为null
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			// 使用构造函数及入参进行bean对象的创建
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		/** 获取指定的用来创建bean对象的默认构造函数 */
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		/**
		 * 如果上述情况都没有：没有创建bean的回调方法 && 没有工厂方法 && 构造函数的参数未解析完毕 && 没有预先指定的默认构造函数
		 *   则使用默认策略来创建bean对象
		 */
		return instantiateBean(beanName, mbd);
	}

        然后到instantiateBean。

	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged((PrivilegedAction