spring源码分析1-BeanFactory和ApplicationContext

最新推荐文章于 2023-12-31 12:06:40 发布

shushangyun

最新推荐文章于 2023-12-31 12:06:40 发布

阅读量219

点赞数 1

分类专栏： spring

本文链接：https://blog.csdn.net/shushangyun/article/details/118405099

版权

spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

spring源码分析1-BeanFactory和ApplicationContext

文章目录

spring源码分析1-BeanFactory和ApplicationContext
前言
一、BeanFactory
二、ApplicationContext
- 1.ApplicationContext源码
- 2.refresh
总结

前言

spring源码分析第一篇，BeanFactory和ApplicationContext对于了解spring的人来说应该一点都不陌生，今天就来聊聊它们。

一、BeanFactory

1.BeanFactory源码

BeanFactory是springioc的根接口，定义了bean工厂最基础的功能特性，BeanFactory是管理bean的容器，spring中的bean都是由这个接口的实现类来管理的

BeanFactory 只是对 IOC 容器最基本行为作了定义，而不关心 Bean 是怎样定义和加载的。定义了一些 getBean、containsBean、isSingleton、isPrototype 等基本容器方法。

public interface BeanFactory {

	/**
	 * 对于FactoryBean的转义定义，提供获取FactoryBean的方式
	 * 如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象
	 * 如果需要得到工厂本身，需要转义
	 * FactoryBean 本质也是一个bean，作用是生成bean，实现了这个接口，spring容器在初始化时会实现了这个接口的bean给取出来，
	 * 然后使用里面的getObject方法来生成bean
	 */
	String FACTORY_BEAN_PREFIX = "&";

    //根据bean的名字从容器中获取bean实例
	Object getBean(String name) throws BeansException;

	//根据bean的名字和class类型从容器中获取bean实例，
	// 增加类型校验进一步确保精准地获取到的实例
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	 //通过名字外加构造函数的形式来获取bean实例
	Object getBean(String name, Object... args) throws BeansException;

    //按照类型来获取bean实例
	<T> T getBean(Class<T> requiredType) throws BeansException;

    //通过类型和构造函数的形式来获取bean实例
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	//方法用于获取指定bean的提供者,返回的是一个ObjectProvider,此接口通常用于封装一个泛型工厂，
	// 在每次调用的时候返回一些目标对象新的实例。
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	 //看看是否在容器有这个名字的bean
	boolean containsBean(String name);

	 //根据bean名字得到bean实例，并判断这个bean是不是单例
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	 //根据bean名字得到bean实例，并判断这个bean是不是多例
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	 //判断Bean的类型是否是指定类型
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	
    //这里对得到bean实例的Class类型
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
	
    //这里得到bean的别名，如果根据别名检索，那么其原名也会被检索出来
	String[] getAliases(String name);

}

2.BeanFactory家族体系

在这里插入图片描述
通过上面类图可以看出BeanFactory 的直接继承接口（二级接口），有HierarchicalBeanFactory、AutowireCapableBeanFactory和ListableBeanFactory

2.2 HierarchicalBeanFactory

为了实现bean工厂的层级关系提供支持，从名字可以看出，分层BeanFactory，说明在spring中，容器是具有父子关系(层次)的。

package org.springframework.beans.factory;
import org.springframework.lang.Nullable;
//由 bean 工厂实现的子接口，可以是层次结构的一部分。
public interface HierarchicalBeanFactory extends BeanFactory {

	/**
	 * 返回父 bean 工厂，如果没有，则返回 null.
	 */
	@Nullable
	BeanFactory getParentBeanFactory();

	/**
	 * 返回本地 bean 工厂是否包含给定名称的 bean，
	 * 忽略祖先上下文中定义的 bean。 
	 *<p>这是 {@code containsBean} 的替代方法，忽略来自祖先 bean 工厂的给定名称的 bean
	 */
	boolean containsLocalBean(String name);

}

2.3 AutowireCapableBeanFactory

提供自动装配bean能力的功能支持

package org.springframework.beans.factory.config;

import java.util.Set;

import org.springframework.beans.BeansException;
import org.springframework.beans.TypeConverter;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
import org.springframework.lang.Nullable;

public interface AutowireCapableBeanFactory extends BeanFactory {

	int AUTOWIRE_NO = 0;
	int AUTOWIRE_BY_NAME = 1;
	int AUTOWIRE_BY_TYPE = 2;
	int AUTOWIRE_CONSTRUCTOR = 3;
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;

	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

	//-------------------------------------------------------------------------
	// Typical methods for creating and populating external bean instances
	//-------------------------------------------------------------------------

    //用个给定的class类型制造一个完整的bean
	<T> T createBean(Class<T> beanClass) throws BeansException;
    
    //bean初始化完成之后执行回调函数和后处理器
	void autowireBean(Object existingBean) throws BeansException;
    // 自动注入和设置bean的属性、执行factory回调函数比如setBeanName和setBeanFactory和执行bean的所有的后处理器
	Object configureBean(Object existingBean, String beanName) throws BeansException;

	//-------------------------------------------------------------------------
	// Specialized methods for fine-grained control over the bean lifecycle
	//-------------------------------------------------------------------------

	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;

	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
	
    //调用bean的init方法，这个方法是客户配置的，在bean实例化之后调用
	Object initializeBean(Object existingBean, String beanName) throws BeansException;
	
    //应用前处理器
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;
			
    //初始化完成之后应用后处理器
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

	void destroyBean(Object existingBean);

	//-------------------------------------------------------------------------
	// Delegate methods for resolving injection points
	//-------------------------------------------------------------------------
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

	Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}

2.4 ListableBeanFactory

可以枚举所有的bean实例，是为了使客户端访问工厂中的bean而设计的

package org.springframework.beans.factory;

import java.lang.annotation.Annotation;
import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface ListableBeanFactory extends BeanFactory {
    
    //是否含有给定的名称的bean
	boolean containsBeanDefinition(String beanName);

	int getBeanDefinitionCount();

    //得到工厂所有的bean的名称数组
	String[] getBeanDefinitionNames();

	String[] getBeanNamesForType(ResolvableType type);

    //根据给定的类型得到和相应的策略得到所有的bean名称数组
	String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);

	String[] getBeanNamesForType(@Nullable Class<?> type);

	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    //根据给定过的类型得到所有该类型的bean，返回的结果是一个Map<bean名称，bean对象>的形式
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
    //得到给定名称的bean上的给定注解类型的注解对象
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

}

以上二级接口在BeanFactory的基础上大大扩充了自身的能力。

2.5 ConfigurableBeanFactory

实现可配置的bean的环境功能，这个接口继承自HierarchicalBeanFactory所以支持层级关系的工厂，和SingletonBeanRegistry所以支持单例工厂行为

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

	String SCOPE_SINGLETON = "singleton";

	String SCOPE_PROTOTYPE = "prototype";

    void setTypeConverter(TypeConverter typeConverter);
    //支持自定义bean的作用范围，可以理解为单例和多例之外的
    void registerScope(String scopeName, Scope scope);
    //归并的将给定的name的bean的定义
    BeanDefinition getMergedBeanDefinition(String beanName);
    //添加处理器
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
    //下面是3个destory方法
    void destroyBean(String beanName, Object beanInstance);
    void destroyScopedBean(String beanName);
   //只能销毁所有单例的bean,因为多例的是不归Spring控制的，是由客户端控制的

}

2.6 ConfigurableListableBeanFactory

提供可配置的、可访问的功能,接口中的方法在在DefaultListableBeanFactory默认实现默认实现

public interface ConfigurableListableBeanFactory
        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
        void ignoreDependencyType(Class<?> type);
        void ignoreDependencyInterface(Class<?> ifc);
        void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
        Iterator<String> getBeanNamesIterator();
        void clearMetadataCache();
        boolean isConfigurationFrozen();
        //冻住之后bean定义就不能在被修改和进行任何的后处理器规定的操作
        void freezeConfiguration();
        //确保所有的单例bean都实例化
        void preInstantiateSingletons() throws BeansException;
        //
        BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
        //判断当前的bean是不是作为其它bean的依赖注入的
        boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor);
    }

二、ApplicationContext

1.ApplicationContext源码

ApplicationContext 是 spring 中较高级的容器。和 BeanFactory 类似，它可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。另外，它增加了企业所需要的功能。 public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver

1.支持不同的信息源。
继承了 MessageSource 接口，这个接口为 ApplicationContext 提供了很多信息源的扩展功能，比如：国际化的实现为多语言版本的应用提供服务。

2.访问资源。
这一特性主要体现在 ResourcePatternResolver 接口上，对 Resource 和 ResourceLoader 的支持，这样我们可以从不同地方得到 Bean 定义资源。这种抽象使用户程序可以灵活地定义 Bean 定义信息，尤其是从不同的 IO 途径得到 Bean 定义信息。这在接口上看不出来，不过一般来说，具体 ApplicationContext 都是继承了 DefaultResourceLoader 的子类。因为 DefaultResourceLoader 是 AbstractApplicationContext 的基类。

3.支持应用事件。
继承了接口 ApplicationEventPublisher，为应用环境引入了事件机制，这些事件和 Bean 的生命周期的结合为 Bean 的管理提供了便利。

4.附件服务。
EnvironmentCapable 里的服务让基本的 Ioc 功能更加丰富。

5.ListableBeanFactory 和 HierarchicalBeanFactory 是继承的主要容器。
最常被使用的 ApplicationContext 接口实现类：
1，FileSystemXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供给构造器 XML 文件的完整路径。
2，ClassPathXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可，因为，容器会从 CLASSPATH 中搜索 bean 配置文件。
3，WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

	@Nullable
	String getId();

	String getApplicationName();

	String getDisplayName();

	long getStartupDate();

	@Nullable
	ApplicationContext getParent();

	AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

2.refresh

代码如下（示例）：

在这里插入图片描述
以上的这些过程都发生在 new ClassPathXmlApplicationContext 中调用的 AbstractApplicationContext#refresh 方法中。
AbstractApplicationContext#refresh 逻辑：
1）初始化前的准备工作，比如对系统属性或者环境变量进行准备及验证
2）初始化 BeanFactory，并进行 XML 文件读取（component-scan->包括 class 文件）
3）对 BeanFactory 进行各种功能填充，比如@Qualifier 和@Autowired
4）子类覆盖方法做额外的处理
5）激活各种 BeanFactory 处理器
6）注册拦截 bean 创建的 bean 处理器，这里只是注册，真正的调用是在 getBean 的时候
7）为上下文初始化 Message 源，即为不同语言的消息体进行国际化处理
8）初始化应用消息广播器，并放入 applicationEventMulticaster bean 中
9）留给子类来初始化其他的 bean
10）在所有注册的 bean 中查找 listener bean，注册到消息广播器中
11）初始化剩下的代理实例（非 lazy-init）（bean 的加载）
12）完成刷新过程，通知生命周期处理器 lifecycleProcessor 刷新过程，同时发出 ContextRefreshEvent 通知别人。

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			// 给容器refresh加锁，避免容器处在refresh阶段时，容器进行了初始化或者销毁的操作
			// 准备 刷新的上下文环境
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			//告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从
			//子类的refreshBeanFactory()方法启动，里面有抽象方法
			//针对xml配置，最终创建内部容器，该容器负责 Bean 的创建与管理，此步会进行BeanDefinition的注册
			// 初始化 BeanFactory，并进行 XML 文件的读取
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			// 注册一些容器中需要的系统Bean.例如classloader，beanfactoryPostProcessor等
			// 对 BeanFactory 进行各种功能填充
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				//允许容器的子类去注册postProcessor  ，钩子方法
				// 子类覆盖方法做额外的处理
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				// 激活在容器中注册为bean的BeanFactoryPostProcessors
				//对于注解容器，org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
				//方法扫描应用中所有BeanDefinition并注册到容器之中
				// 激活各种 BeanFactory 处理器
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				// 注册拦截bean创建过程的BeanPostProcessor
				// 注册拦截 Bean 创建的 Bean 处理器，这里只是注册，真正的调用是在 getBean 的 时候
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				// 找到“messageSource”的Bean提供给ApplicationContext使用，
				// 使得ApplicationContext具有国际化能力。
				// 为上下文初始化 Message 源，即不同语言的消息体，国际化处理
				initMessageSource();

				// Initialize event multicaster for this context.
				// 初始化ApplicationEventMulticaster该类作为事件发布者，
				// 可以存储所有事件监听者信息，并根据不同的事件，通知不同的事件监听者。
				// 初始化应用消息广播器，并放入 applicationEventMulticaster bean 中
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				// 预留给 AbstractApplicationContext 的子类用于初始化其他特殊的 bean，
				// 该方法需要在所有单例 bean 初始化之前调用
				// 比如Web容器就会去初始化一些和主题展示相关的Bean（ThemeSource）
				// 留给子类来初始化其他 bean
				onRefresh();

				// Check for listener beans and register them.
				// 注册监听器（检查监听器的bean并注册它们）
				// 在所有注册的 bean 中查找 Listener bean，注册到消息广播器中
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				//设置自定义的类型转化器ConversionService，
				// 设置自定义AOP相关的类LoadTimeWeaverAware，
				// 清除临时的ClassLoader
				// ，实例化所有的类（懒加载的类除外）
				// 初始化剩下的单例实例（除了 lazy-init）
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				// 初始化容器的生命周期事件处理器，（默认使用DefaultLifecycleProcessor），调用扩展了SmartLifecycle接口的start方法
				// 当Spring容器加载所有bean并完成初始化之后，会接着回调实现该接口的类中对应的方法（start()方法）
				// 并发布容器刷新完毕事件ContextRefreshedEvent给对应的事件监听者
				// 完成刷新过程，通知生命周期处理器 lifecycleProcessor 刷新过程，同时发出 ContextRefreshEvent 通知别人
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

obtainFreshBeanFactory（创建 beanFactory，解析 XML）
在后面会调用到 loadBeanDefinitions(beanFactory) 方法，该方法会创建 XmlBeanDefinitionReader，后面会调用 reader#loadBeanDefinitions 方法。
该方法会：
1 ） Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); 将 applicationContext.xml 转为 Resource。
2）然后会调用 Resource#getInputStream，然后将该资源转为 XML 的 Document 对象。最终是使用 jaxp 的 dom 方式读取的 XML 配置文件。（JAXP 是一种标准，SUN API 对其提供了实现）
3）使用 BeanDefinitionDocumentReader#registerBeanDefinitions 将 XML 对应的 Document 对象转为 BeanDefinitions。最终会调用 parseBeanDefinitions（解析标签），它会分开解析默认标签和自定义标签。默认标签是 import、alias、bean 和 beans 四种。自定义标签会先找到其对应的 parser ，比如 component-scan 标签对应着 ComponentScanBeanDefinitionParser。该 Parser 会调用 PathMatchingResourcePatternResolver#getResources 从包名得到 Resource 封装了的 class 文件（底层是调用了 File API）。MetadataReader 会读入 class 文件，如果有@Component 注解，那么返回其对应的 BeanDefinition。
4）标签解析完毕后会将 beanName 和 beanDefinition 作为 key 和 value 放入 beanfactory 的 beanDefinitionMap 中。

Bean 的加载
在 Bean 的注册 refresh 中除了调用了 obtainFreshBeanFactory 完成了 XML2BeanDefinition，还调用了 finishBeanFactoryInitialization （初始化非 lazy-load 且 singleton 的 bean ）（BeanDefinition2BeanInstance），该方法会获取所有 beanName，逐个调用 getBean 方法。
在这里插入图片描述

总结

提示：这里对文章进行总结：

链接: https://blog.csdn.net/qq_34090008/article/details/78772189.

shushangyun

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
spring源码分析1-BeanFactory和ApplicationContext

spring源码分析1-BeanFactory和ApplicationContext文章目录spring源码分析1-BeanFactory和ApplicationContext前言一、BeanFactory1.BeanFactory源码二、ApplicationContext1.引入库2.读入数据总结前言spring源码分析第一篇，BeanFactory和ApplicationContext对于了解spring的人来说应该一点都不陌生，今天就来聊聊它们。一、BeanFactory1.Bean
复制链接

扫一扫