多图详解Spring框架的设计理念与设计模式

Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念。

Rod Johson在2002年编著的《Expert one to one J2EE design and development》一书中，对Java EE正统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破Java EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-to-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB 的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson

成为一个改变Java世界的大师级人物。

传统J2EE应用的开发效率低，应用服务器厂商对各种技术的支持并没有真正统一，导致J2EE的应用没有真正实现Write Once及Run Anywhere的承诺。Spring作为开源的中间件，独立于各种应用服务器，甚至无须应用服务器的支持，也能提供应用服务器的功能，如声明式事务等。

Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而与它们无缝地整合。

Spring简介

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring 使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且 Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将

应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

为什么需要Spring

你可能正在想“Spring不过是另外一个的framework”。当已经有许多开放源代码(和专有) J2EE framework时，我们为什么还需要Spring Framework？

Spring是独特的,因为若干个原因:

◆它定位的领域是许多其他流行的framework没有的。Spring关注提供一种方法管理你的业务对象。

◆ Spring是全面的和模块化的。Spring有分层的体系结构,这意味着你能选择使用它孤立的任何部分,它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如,你可能选择仅仅使用Spring 来简单化JDBC的使用,或用来管理所有的业务对象。

◆它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。

Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

Spring带给我们什么

◆方便解耦，简化开发,通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

◆AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP 轻松应付。

◆声明式事务的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

◆方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。

◆方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hession、Quartz）等的直接支持。

◆降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring 的简易封装，这些Java EE API的使用难度大为降低。

◆Java 源码是经典学习范例

Spring的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java 技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

Spring框架的好处

在我们进入细节以前，让我们看一下Spring可以给一个工程带来的一些好处:

◆Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。

◆Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。

◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。

◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。

◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。

◆使用Spring构建的应用程序易于单元测试。

◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs 来实现业务接口，却不会影响调用代码。

◆Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。

◆Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。

Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。

总结起来，Spring有如下优点：

◆低侵入式设计，代码污染极低

◆独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺

◆Spring的DI机制降低了业务对象替换的复杂性

◆Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

Spring能做什么？

Spring提供许多功能,在此我将快速地依次展示其各个主要方面。首先,让我们明确Spring范围。尽管Spring覆盖了许多方面，但我们已经有清楚的概念，它什么应该涉及和什么不应该涉及。Spring的主要目的是使J2EE易用和促进好编程习惯。

Spring不重新开发已有的东西。因此，在Spring中你将发现没有日志记录的包,没有连接池,没有分布事务调度。这些均有开源项目提供 (例如Commons Logging 用来做所有的日志输出，或Commons DBCP

用来作数据连接池),或由你的应用程序服务器提供。因为同样的的原因，我们没有提供O/R mapping层，对此，已有有好的解决办法如Hibernate和JDO。

Spring的目标是使已存在的技术更加易用。例如,尽管我们没有底层事务协调处理，但我们提供了一个抽象层覆盖了JTA或任何其他的事务策略。

Spring没有直接和其他的开源项目竞争，除非我们感到我们能提供新的一些东西。例如，象许多开发人员，我们从来没有为Struts高兴过，并且感到在MVC web framework中还有改进的余地。在某些领域，例如轻量级的IoC容器和AOP框架，Spring有直接的竞争，但是在这些领域还没有已经较为流行的解决方案。(Spring在这些区域是开路先锋。)

Spring也得益于内在的一致性。所有的开发者都在唱同样的的赞歌,基础想法依然是Expert

One-on-One J2EE设计与开发的那些。并且我们已经能够使用一些主要的概念,例如倒置控制，来处理多个领域。Spring在应用服务器之间是可移植的。当然保证可移植性总是一次挑战，但是我们避免任何特定平台或非标准化,并且支持在WebLogic，Tomcat，Resin，JBoss，WebSphere和其他的应用服务器上的用户。

Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成Spring的骨骼架构？Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？Spring中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。

Spring的骨骼架构

Spring总共有十几个组件，但是真正核心的组件只有几个，下面是Spring框架的总体架构图：

图1.Spring框架的总体架构图

从上图中可以看出Spring框架中的核心组件只有三个：Core、Context和Beans。它们构建起了整个Spring的骨骼架构。没有它们就不可能有AOP、Web等上层的特性功能。下面也将主要从这三个组件入手分析Spring。

Spring的设计理念

前面介绍了Spring的三个核心组件，如果再在它们三个中选出核心的话，那就非Beans组件莫属了，为何这样说，其实Spring就是面向Bean的编程（BOP,Bean Oriented Programming），Bean在Spring 中才是真正的主角。

Bean在Spring中作用就像Object对OOP的意义一样，没有对象的概念就像没有面向对象编程，Spring 中没有Bean也就没有Spring存在的意义。就像一次演出舞台都准备好了但是却没有演员一样。为什么要Bean这种角色Bean或者为何在Spring如此重要，这由Spring框架的设计目标决定，Spring为何如此流

行，我们用Spring的原因是什么，想想你会发现原来Spring解决了一个非常关键的问题他可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。而这个注入关系在一个叫Ioc容器中管理，那Ioc容器中有又是什么就是被Bean包裹的对象。Spring正是通过把对象包装在 Bean中而达到对这些对象管理以及一些列额外操作的目的。

它这种设计策略完全类似于Java实现OOP的设计理念，当然了Java本身的设计要比Spring复杂太多太多，但是都是构建一个数据结构，然后根据这个数据结构设计他的生存环境，并让它在这个环境中按照一定的规律在不停的运动，在它们的不停运动中设计一系列与环境或者与其他个体完成信息交换。这样想来回过头想想我们用到的其他框架都是大慨类似的设计理念。

核心组件如何协同工作

前面说Bean是Spring中关键因素，那Context和Core又有何作用呢？前面吧Bean比作一场演出中的演员的话，那Context就是这场演出的舞台背景，而Core应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是Spring能提供的特色功能了。

我们知道Bean包装的是Object，而Object必然有数据，如何给这些数据提供生存环境就是Context 要解决的问题，对Context来说他就是要发现每个Bean之间的关系，为它们建立这种关系并且要维护好这种关系。所以Context就是一个Bean关系的集合，这个关系集合又叫Ioc容器，一旦建立起这个Ioc容器后Spring就可以为你工作了。那Core组件又有什么用武之地呢？其实Core就是发现、建立和维护每个Bean之间的关系所需要的一些列的工具，从这个角度看来，Core这个组件叫Util更能让你理解。

它们之间可以用下图来表示：

图2.三个组件关系

核心组件详解

这里将详细介绍每个组件内部类的层次关系，以及它们在运行时的时序顺序。我们在使用Spring是应该注意的地方。

Bean组件

前面已经说明了Bean组件对Spring的重要性，下面看看Bean这个组件式怎么设计的。Bean组件在Spring的org.springframework.beans包下。这个包下的所有类主要解决了三件事：Bean的定义、Bean 的

创建以及对Bean的解析。对Spring的使用者来说唯一需要关心的就是Bean的创建，其他两个由Spring 在内部帮你完成了，对你来说是透明的。

SpringBean的创建时典型的工厂模式，他的顶级接口是BeanFactory，下图是这个工厂的继承层次关系：

图4.Bean工厂的继承关系

BeanFactory有三个子类：ListableBeanFactory、HierarchicalBeanFactory和Autowire Capable Bean Factory。但是从上图中我们可以发现最终的默认实现类是DefaultListableBeanFactory，他实现了所有的接口。那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在Spring内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如ListableBeanFactory接口表示这些Bean是可列表的，而HierarchicalBeanFactory表示的是这些Bean是有继承关系的，也就是每个Bean有可能有父Bean。 AutowireCapableBeanFactory接口定义Bean的自动装配规则。这四个接口共同定义了Bean的集合、Bean之间的关系、以及Bean行为。

Bean的定义主要有BeanDefinition描述，如下图说明了这些类的层次关系：

图5.Bean定义的类层次关系图

Bean的定义就是完整的描述了在Spring的配置文件中你定义的节点中所有的信息，包括各种子节点。当Spring成功解析你定义的一个节点后，在Spring的内部他就被转化成BeanDefinition对象。以后所有的操作都是对这个对象完成的。

Bean的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。Bean的解析主要就是对Spring配置文件的解析。这个解析过程主要通过下图中的类完成：

图6.Bean的解析类

当然还有具体对tag的解析这里并没有列出。

Context组件

Context在Spring的org.springframework.context包下，前面已经讲解了Context组件在Spring

中的作用，他实际上就是给Spring提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个环境是如何构建的。

ApplicationContext是Context的顶级父类，他除了能标识一个应用环境的基本信息外，他还继承了五个接口，这五个接口主要是扩展了Context的功能。下面是Context的类结构图：

图7.Context相关的类结构图

从上图中可以看出ApplicationContext继承了BeanFactory，这也说明了Spring容器中运行的主体对象是Bean，另外ApplicationContext继承了ResourceLoader接口，使得ApplicationContext可以访问到任何外部资源，这将在Core中详细说明。

ApplicationContext的子类主要包含两个方面：

ConfigurableApplicationContext表示该Context是可修改的，也就是在构建Context中用户可以动态添加或修改已有的配置信息，它下面又有多个子类，其中最经常使用的是可更新的Context，即AbstractRefreshableApplicationContext类。

WebApplicationContext顾名思义，就是为web准备的Context他可以直接访问到ServletContext，通常情况下，这个接口使用的少。

再往下分就是按照构建Context的文件类型，接着就是访问Context的方式。这样一级一级构成了完整的Context等级层次。

总体来说ApplicationContext必须要完成以下几件事：

◆标识一个应用环境

◆利用BeanFactory创建Bean对象

◆保存对象关系表

◆能够捕获各种事件

Context作为Spring的Ioc容器，基本上整合了Spring的大部分功能，或者说是大部分功能的基础。

Core组件

Core组件作为Spring的核心组件，他其中包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。这种把所有资源都抽象成一个接口的方式很值得在以后的设计中拿来学习。下面就重要看一下这个部分在Spring的作用。

下图是Resource相关的类结构图：

图8.Resource相关的类结构图

从上图可以看出Resource接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。对资源的提供者来说，如何把资源包装起来交给其他人用这也是一个问题，我们看到Resource 接口继承了InputStreamSource接口，这个接口中有个getInputStream方法，返回的是InputStream类。这样所有的资源都被可以通过InputStream这个类来获取，所以也屏蔽了资源的提供者。另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，从上图中可以看出这个任务是由ResourceLoader接口完成，他屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源，他的默认实现是DefaultResourceLoader。

下面看一下Context和Resource是如何建立关系的？首先看一下他们的类关系图：

图9.Context和Resource的类关系图

从上图可以看出，Context是把资源的加载、解析和描述工作委托给了ResourcePatternResolver类来完成，他相当于一个接头人，他把资源的加载、解析和资源的定义整合在一起便于其他组件使用。 Core 组件中还有很多类似的方式。

Ioc容器如何工作

前面介绍了Core组件、Bean组件和Context组件的结构与相互关系，下面这里从使用者角度看一下他们是如何运行的，以及我们如何让Spring完成各种功能，Spring到底能有那些功能，这些功能是如何得来的，下面介绍。

如何创建BeanFactory工厂

正如图2描述的那样，Ioc容器实际上就是Context组件结合其他两个组件共同构建了一个Bean关系网，如何构建这个关系网？构建的入口就在AbstractApplicationContext类的refresh方法中。这个方法的代码如下：

清单1.AbstractApplicationContext.refresh

1.public void refresh() throws BeansException, IllegalStateException {

2.

3. synchronized (this.startupShutdownMonitor) {

4.

5. // Prepare this context for refreshing.

6.

7. prepareRefresh();

8.

9. // Tell the subclass to refresh the internal bean factory.

10.

11. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

12.

13. // Prepare the bean factory for use in this context.

14.

15. prepareBeanFactory(beanFactory);

16.

17. try {

18.

19. // Allows post-

processing of the bean factory in context subclasses.

20.

21. postProcessBeanFactory(beanFactory);

22.

23. // Invoke factory processors registered as beans in&

nbsp;the context.

24.

25. invokeBeanFactoryPostProcessors(beanFactory);

26.

27. // Register bean processors that intercept bean crea tion.

28.

29. registerBeanPostProcessors (beanFactory);

30.

31. // Initialize message source for this context.

32.

33. initMessageSource();

34.

35. // Initialize event multicaster for this context.

36.

37. initApplicationEventMulticaster();

38.

39. // Initialize other special beans in specific contex t subclasses.

40.

41. onRefresh();

42.

43. // Check for listener beans and register them.

44.

45. registerListeners();

46.

47. // Instantiate all remaining (non-lazy-init) singletons.

48.

49. finishBeanFactoryInitialization (beanFactory);

50.

51. // Last step: publish corresponding event.

52.

53. finishRefresh();

54.

55. }

56.

57. catch (BeansException ex) {

58.

59. // Destroy already created singletons to avoid dangl ing resources.

60.

61. destroyBeans();

62.

63. // Reset 'active' flag.

64.

65. cancelRefresh(ex);

66.

67. // Propagate exception to caller.

68.

69. throw ex;

70.

71. }

72.

73. }

74.

75.}

76.

这个方法就是构建整个Ioc容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分Spring的原理和功能了。

这段代码主要包含这样几个步骤：

◆构建BeanFactory，以便于产生所需的“演员”

◆注册可能感兴趣的事件

◆创建Bean实例对象

◆触发被监听的事件

下面就结合代码分析这几个过程。

第二三句就是在创建和配置BeanFactory。这里是refresh也就是刷新配置，前面介绍了Context有可更新的子类，这里正是实现这个功能，当BeanFactory已存在是就更新，如果没有就新创建。下面是更新BeanFactory的方法代码：

清单2. AbstractRefreshableApplicationContext. refreshBeanFactory

1.protected final void refreshBeanFactory() throws BeansException {

2.

3. if (hasBeanFactory()) {

4.

5. destroyBeans();

6.

7. closeBeanFactory();

8.

9. }

10.

11. try {

12.

13. DefaultListableBeanFactory beanFactory = createBeanFactory();

14.

15. beanFactory.setSerializationId(getId());

16.

17. customizeBeanFactory(beanFactory);

18.

19. loadBeanDefinitions(beanFactory);

20.

21. synchronized (this.beanFactoryMonitor) {

22.

23.this.beanFactory = beanFactory;

24.

25. }

26.

27. }

28.

29. catch (IOException ex) {

30.

31. throw new ApplicationContextException(

32.

33. "I/O error& nbsp;parsing bean definition source for "

34.

35. + getDisplayName (), ex);

36.

37. }

38.

39.}

40.

这个方法实现了AbstractApplicationContext的抽象方法refreshBeanFactory，这段代码清楚的说明了BeanFactory的创建过程。注意BeanFactory对象的类型的变化，前面介绍了他有很多子类，在什么情况下使用不同的子类这非常关键。BeanFactory的原始对象是DefaultListableBeanFactory，这个非常关键，因为他设计到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：

图10.DefaultListableBeanFactory类继承关系图

从这个图中发现除了BeanFactory相关的类外，还发现了与Bean的register相关。这在refreshBeanFactory方法中有一行loadBeanDefinitions(beanFactory)将找到答案，这个方法将开始加载、解析 Bean的定义，也就是把用户定义的数据结构转化为Ioc容器中的特定数据结构。

这个过程可以用下面时序图解释：

图11.创建BeanFactory时序图

Bean的解析和登记流程时序图如下：

图12.解析和登记Bean对象时序图

创建好BeanFactory后，接下去添加一些Spring本身需要的一些工具类，这个操作在AbstractApplicationContext的prepareBeanFactory方法完成。

AbstractApplicationContext中接下来的三行代码对Spring的功能扩展性起了至关重要的作用。前两行主要是让你现在可以对已经构建的BeanFactory的配置做修改，后面一行就是让你可以对以后再创建Bean的实例对象时添加一些自定义的操作。所以他们都是扩展了Spring的功能，所以我们要学习使用Spring必须对这一部分搞清楚。

其中在invokeBeanFactoryPostProcessors方法中主要是获取实现BeanFactoryPostProcessor接口的子类。并执行它的postProcessBeanFactory方法，这个方法的声明如下：

清单3.BeanFactoryPostProcessor.postProcessBeanFactory

1.void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

2.

3. throws BeansException;

它的参数是beanFactory，说明可以对beanFactory做修改，这里注意这个beanFactory是ConfigurableListableBeanFactory类型的，这也印证了前面介绍的不同BeanFactory所使用的场合不同，这里只能是可配置的BeanFactory，防止一些数据被用户随意修改。

registerBeanPostProcessors方法也是可以获取用户定义的实现了BeanPostProcessor接口的子类，并执行把它们注册到BeanFactory对象中的beanPostProcessors变量中。BeanPostProcessor中声明了两个方法：postProcessBeforeInitialization、postProcessAfterInitialization分别用于在Bean对象初始化时执行。可以执行用户自定义的操作。

后面的几行代码是初始化监听事件和对系统的其他监听者的注册，监听者必须是ApplicationListener 的子类。

如何创建Bean实例并构建Bean的关系网

下面就是Bean的实例化代码，是从finishBeanFactoryInitialization方法开始的。

清单4.AbstractApplicationContext.finishBeanFactoryInitialization

1.protected void finishBeanFactoryInitialization(

2.

3. ConfigurableListableBeanFactory beanFactory) {

4.

5.

6.

7. // Stop using the temporary ClassLoader for type matching.

8.

9. beanFactory.setTempClassLoader(null);

10.

11.

12.

13. // Allow for caching all bean definition metadata, not expecting further chang

es .

14.

15. beanFactory.freezeConfiguration();

16.

17.

18.

19. // Instantiate all remaining (non-lazy-init) singletons.

20.

21. beanFactory.preInstantiateSingletons();

22.

23.}

24.

从上面代码中可以发现Bean的实例化是在BeanFactory中发生的。preInstantiateSingletons方法的代码如下：

清单5.DefaultListableBeanFactory.preInstantiateSingletons

25.public void preInstantiateSingletons() throws BeansException {

26.

27. if (this.logger.isInfoEnabled()) {

28.

29. https://www.wendangku.net/doc/1c263957.html,("Pre- instantiating singletons in " + this);

30.

31. }

32.

33. synchronized (this.beanDefinitionMap) {

34.

35. for (String beanName : this.beanDefinitionNames) {

36.

37. RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

38.

39. if (!bd.isAbstract() && bd.isSingleton()

40.

41. && !bd.isLazyInit()) {

42.

43. if (isFactoryBean(beanName)) {

44.

45. final FactoryBean factory =

46.

47. (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName);

48.

49. boolean isEagerInit;

50.

51. if (System.getSecurityManager() != null

52.

53. && ;factory instanceof SmartFactoryBean) {

54.

55.isEagerInit = AccessController.doPrivileged(

56.

57. &nb sp; new PrivilegedAction() {

58.

59. &nb sp; public Boolean run() {

60.

61. return ((SmartFactoryBean) factory).isEagerInit();

62.

63. &nb sp; }

64.

65. }, getAcce ssControlContext());

66.

67. }

68.

69. else {

70.

71.isEagerInit = factory instanceof SmartFactoryBean

72.

73. &nb

sp; && ((SmartFactoryBean) factory).isEagerInit();

74.

75. }

76.

77. if (isEagerInit) {

78.

79. getBean (beanName);

80.

81. }

82.

83. }

84.

85. else {

86.

87. getBean(beanName);

88.

89. }

90.

91. }

92.

93. }

94.

95. }

96.

97.}

98.

?这里出现了一个非常重要的Bean——FactoryBean，可以说Spring一大半的扩展的功能都与这个Bean有关，这是个特殊的Bean他是个工厂Bean，可以产生Bean的Bean，这里的产生Bean是指Bean的实例，如果一个类继承FactoryBean用户可以自己定义产生实例对象的方法只要实现他的getObject方法。然而在Spring内部这个Bean的实例对象是FactoryBean，通过调用这个对象的getObject方法就能获取用户自定义产生的对象，从而为Spring提供了很好的扩展性。Spring 获取FactoryBean本身的对象是在前面加上&来完成的。

?如何创建Bean的实例对象以及如何构建Bean实例对象之间的关联关系式Spring中的一个核心关键，下面是这个过程的流程图。

图13.Bean实例创建流程图

如果是普通的Bean就直接创建他的实例，是通过调用getBean方法。下面是创建Bean实例的时序图：

图14.Bean实例创建时序图

还有一个非常重要的部分就是建立Bean对象实例之间的关系，这也是Spring框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：