Ioc容器如何工作
完整的IOC容器实际上就是 Context 组件结合Bean组件和Core组件，组成的Bean 关系网，如何构建这个关系网？构建的入口就在 AbstractApplicationContext 类的 refresh 方法中。这个方法的代码如下：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备刷新容器
prepareRefresh();
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//对BeanFactory做各种预处理设置
prepareBeanFactory(beanFactory);
try {
// 允许BeanFactory在Context子类中做后期处理
postProcessBeanFactory(beanFactory);
// 调用容器中BeanFactory后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册BeanFactory后置处理器，这种处理器用于拦截bean的创建过程
registerBeanPostProcessors(beanFactory);
// 为Context初始化消息源组件，用于消息绑定、消息解析等功能
initMessageSource();
// Context初始化事件广播器
initApplicationEventMulticaster();
//在特定Context子类中初始化特殊Bean
//没有任何操作，留给子类继承的，我们可以自定义子Context，在重写方法中做一些我们想要的操作
onRefresh();
// 注册事件监听器
registerListeners();
// 完成剩下的单例bean的初始化
finishBeanFactoryInitialization(beanFactory);
// 完成Context刷新，发布相应事件。
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();
}
}
}
这个方法就是构建整个 Ioc 容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分 Spring 的原理和功能了。
这段代码主要包含这样几个步骤：
- 构建 BeanFactory，以便于产生Bean
- 注册可能感兴趣的事件
- 创建 Bean 实例对象
- 触发被监听的事件
BeanFactory的创建
第二三句就是在创建和配置 BeanFactory。
// 准备刷新容器
prepareRefresh();
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//对BeanFactory做各种预处理设置
prepareBeanFactory(beanFactory);
我们可以通过查看obtainFreshBeanFactory()发现它调用了`refreshBeanFactory()``方法，Context 有可更新的子类，这里正是实现这个功能，当 BeanFactory 已存在是就更新，如果没有就新创建。
/**
* 告诉子类刷新BeanFactory
* @return the fresh BeanFactory instance
* @see #refreshBeanFactory()
* @see #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
return getBeanFactory();
}
下面是refreshBeanFactory()方法的代码：
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
这段代码清楚的说明了 BeanFactory 的创建过程，当 BeanFactory 已存在是就更新，如果没有就新创建。注意 BeanFactory 对象的类型的变化，前面介绍了他有很多子类，在什么情况下使用不同的子类这非常关键。
这个过程可以用下面时序图解释：
Bean的解析和注册
BeanFactory 的原始对象是 DefaultListableBeanFactory，这个非常关键，因为他设计到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：
从这个图中发现除了 BeanFactory 相关的类外，还发现了与 Bean 的 register 相关。这在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 将找到答案，这个方法将开始加载、解析 Bean 的定义，也就是把用户定义的数据结构转化为 IOC容器中的特定数据结构。
//通过XmlBeanDefinitionReader加载bean定义。
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 为特定的BeanFactory创建一个新的XmlBeanDefinitionReader。
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//使用此容器配置的资源环境，配置BeanDefinitionReader
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
///允许子类自定义初始化BeanDefinitionReader，然后继续实际加载Bean定
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader);
}
Bean 的解析和注册流程图如下：
Bean的解析和注册代码太多了，没法都贴出来，先出个流程图。
创建好 BeanFactory 后，接下去添加一些 Spring 本身需要的一些工具类，这个操作在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。
// 配置工厂的标准Context属性，例如Context的类加载器和后置处理器。
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 让内部bean工厂使用Context类加载器等。
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 使用上下文回调配置Bean工厂。
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory接口未在普通工厂中注册为可解析类型。
// MessageSource注册为Bean（并用于发现自动装配）。
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 注册早期的后处理器用于为内部bean检测ApplicationListeners。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 如果发现LoadTimeWeaver，请准备代码织入。
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)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
BeanFactoryPostProcessor 和BeanPostProcessor
AbstractApplicationContext 中接下来的三行代码对 Spring 的功能扩展性起了至关重要的作用。
// 允许BeanFactory在Context子类中做后期处理
postProcessBeanFactory(beanFactory);
// 调用容器中BeanFactory后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 注册BeanFactory后置处理器，这种处理器用于拦截bean的创建过程
registerBeanPostProcessors(beanFactory);
前两行主要是让你现在可以对已经构建的 BeanFactory 的配置做修改，
postProcessBeanFactory(beanFactory);
- BeanFactory标准初始化后，修改ApplicationContext的内部bean工厂。 所有bean定义都将被加载，但尚未实例化任何bean。 这允许在某些ApplicationContext实现中注册特殊的BeanPostProcessor等。
invokeBeanFactoryPostProcessors(beanFactory);
- 实例化并调用所有注册的BeanFactoryPostProcessor Bean，并遵循显式顺序（如果指定的话）。
后面一行就是让你可以对以后再创建 Bean 的实例对象时添加一些自定义的操作。
registerBeanPostProcessors(beanFactory);
- 实例化并注册所有BeanPostProcessor Bean，并遵循显式顺序（如果指定的话）。
所以他们都是扩展了 Spring 的功能，所以我们要学习使用 Spring 必须对这一部分搞清楚。
其中invokeBeanFactoryPostProcessors(beanFactory);和registerBeanPostProcessors(beanFactory);分别获取实现 BeanFactoryPostProcessor 接口的子类和获取用户定义的实现了 BeanPostProcessor 接口的子类。
BeanFactoryPostProcessor和BeanPostProcessor，这两个接口，都是Spring初始化bean时对外暴露的扩展点。
-
BeanPostProcessor：Bean级别的处理，针对某个具体的Bean进行处理,能在spring容器实例化bean之后，在执行bean的初始化方法前后。
-
BeanFactoryPostProcessor：BeanFactory级别的处理，是针对整个Bean的工厂进行处理，在Bean实例化之前进行。
后面的几行代码是初始化监听事件和对系统的其他监听者的注册，监听者必须是 ApplicationListener 的子类。
如何创建Bean实例和构建Bean关系网
Bean 的实例化代码，是从 finishBeanFactoryInitialization 方法开始的。
AbstractApplicationContext.finishBeanFactoryInitialization
//完成该Context的BeanFactory初始化，初始化所有剩余的单例bean。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 为Context初始化类型转换器
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//如果之前没有注册过任何Bean后期处理器，请注册一个默认的嵌入式值解析器：
//主要用于解析注释的属性值。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 尽早初始化LoadTimeWeaverAware Bean，以便尽早注册它们的转换器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 禁止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
// 允许缓存所有的bean的定义数据
beanFactory.freezeConfiguration();
// 准备实例化bean
beanFactory.preInstantiateSingletons();
}
从上面代码中可以发现 Bean 的实例化是在 BeanFactory 中发生的，通过调用BeanFactory的方法准备实例化bean, 这个BeanFactory就是Spring默认是bean工厂, DefaultListableBeanFactory。
DefaultListableBeanFactory.preInstantiateSingletons
//确保所有非延迟初始单例都实例化
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//遍历一个副本以允许init方法，而init方法反过来注册新的bean定义。
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有非延迟加载单例beans的初始化，主要步骤为调用getBean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
getBean(beanName);
}
}
}
}
FactoryBean
这里出现了一个非常重要的 Bean —— FactoryBean，可以说 Spring 一大半的扩展的功能都与这个 Bean 有关，这是个特殊的 Bean 是一个工厂 Bean，可以产生 Bean 的 Bean，这里的产生 Bean 是指 Bean 的实例，如果一个类继承 FactoryBean 用户只要实现他的 getObject 方法，就可以自己定义产生实例对象的方法。从而为 Spring 提供了很好的扩展性。Spring 获取 FactoryBean 本身的对象是在前面加上 & 来完成的。
如何创建 Bean 的实例对象以及如何构建 Bean 实例对象之间的关联关系式 Spring 中的一个核心关键，下面是这个Bean对象创建过程的流程图。
如果是普通的 Bean 就直接创建他的实例，是通过调用 getBean 方法。下面是创建 Bean 实例的时序图：
还有一个非常重要的部分就是建立 Bean 对象实例之间的关系，这也是 Spring 框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：
Ioc 容器的扩展点
对 Spring 的 Ioc 容器来说，主要有这么几个。BeanFactoryPostProcessor， BeanPostProcessor。他们分别是在构建 BeanFactory 和构建 Bean 对象时调用。还有就是 InitializingBean 和 DisposableBean， 他们分别是在 Bean 实例创建和销毁时被调用。用户可以实现这些接口中定义的方法，Spring 就会在适当的时候调用他们。还有一个是 FactoryBean 他是个特殊的 Bean，这个 Bean 可以被用户更多的控制。
这些扩展点通常也是我们使用 Spring 来完成我们特定任务的地方，如何精通 Spring 就看你有没有掌握好 Spring 有哪些扩展点，并且如何使用他们，要知道如何使用他们就必须了解他们内在的机理。可以用下面一个比喻来解释。
我们把 Ioc 容器比作一个箱子，这个箱子里有若干个球的模子，可以用这些模子来造很多种不同的球，还有一个造这些球模的机器，这个机器可以产生球模。那么他们的对应关系就是：BeanFactory 是那个造球模的机器，球模就是 Bean，而球模造出来的球就是 Bean 的实例。那前面所说的几个扩展点又在什么地方呢？ BeanFactoryPostProcessor 对应到当造球模被造出来时，你将有机会可以对其做出适当的修正，也就是他可以帮你修改球模。而 InitializingBean 和 DisposableBean 是在球模造球的开始和结束阶段，你可以完成一些预备和扫尾工作。BeanPostProcessor 就可以让你对球模造出来的球做出适当的修正。最后还有一个 FactoryBean，它可是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的球了，这样在这个箱子里你可以发现所有你想要的球。
562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
