Spring框架的设计理念与设计模式分析.docx

Spring框架的设计理念与设计模式分析.docx

《Spring框架的设计理念与设计模式分析.docx》由会员分享，可在线阅读，更多相关《Spring框架的设计理念与设计模式分析.docx（30页珍藏版）》请在冰豆网上搜索。

Spring框架的设计理念与设计模式分析

Spring框架的设计理念与设计模式分析

摘要：

Spring作为现在最优秀的框架之一，被广泛的使用并有很多对其分析的文章。

本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念，有那几个核心组件？

为什么需要这些组件？

它们又是如何结合在一起构成Spring的骨骼架构？

Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？

Spring中又使用了那些设计模式来完成它的这种设计的？

它的这种设计理念对对我们以后的软件设计有何启示？

本文将详细解答这些问题。

一、Spring的骨骼架构

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

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

从上图中可以看出Spring框架中的核心组件只有三个：

Core、Context和Beans。

它们构建起了整个Spring的骨骼架构。

没有它们就不可能有AOP、Web等上层的特性功能。

下面也将主要从这三个组件入手分析Spring。

1.Spring的设计理念

前面介绍了Spring的三个核心组件，如果再在它们三个中选出核心的话，那就非Beans组件莫属了，为何这样说，其实Spring就是面向Bean的编程（BOP,BeanOrientedProgramming），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复杂太多太多，但是都是构建一个数据结构，然后根据这个数据结构设计他的生存环境，并让它在这个环境中按照一定的规律在不停的运动，在它们的不停运动中设计一系列与环境或者与其他个体完成信息交换。

这样想来回过头想想我们用到的其他框架都是大慨类似的设计理念。

2.核心组件如何协同工作

前面说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.三个组件关系

3.核心组件详解

这里将详细介绍每个组件内部类的层次关系，以及它们在运行时的时序顺序。

我们在使用Spring是应该注意的地方。

3.1Bean组件

前面已经说明了Bean组件对Spring的重要性，下面看看Bean这个组件式怎么设计的。

Bean组件在Spring的org.springframework.beans包下。

这个包下的所有类主要解决了三件事：

Bean的定义、Bean的创建以及对Bean的解析。

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

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

图4.Bean工厂的继承关系

BeanFactory有三个子类：

ListableBeanFactory、HierarchicalBeanFactory和AutowireCapableBeanFactory。

但是从上图中我们可以发现最终的默认实现类是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的解析这里并没有列出。

3.2Context组件

Context在Spring的org.springframework.context包下，前面已经讲解了Context组件在Spring中的作用，他实际上就是给Spring提供一个运行时的环境，用以保存各个对象的状态。

下面看一下这个环境是如何构建的。

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

下面是Context的类结构图：

图7.Context相关的类结构图

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

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

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

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

再往下分就是按照构建Context的文件类型，接着就是访问Context的方式。

这样一级一级构成了完整的Context等级层次。

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

●标识一个应用环境

●利用BeanFactory创建Bean对象

●保存对象关系表

●能够捕获各种事件

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

3.3Core组件

Core组件作为Spring的核心组件，他其中包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。

这种把所有资源都抽象成一个接口的方式很值得在以后的设计中拿来学习。

下面就重要看一下这个部分在Spring的作用。

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

图8.Resource相关的类结构图

从上图可以看出Resource接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。

对资源的提供者来说，如何把资源包装起来交给其他人用这也是一个问题，我们看到Resource接口继承了InputStreamSource接口，这个接口中有个getInputStream方法，返回的是InputStream类。

这样所有的资源都被可以通过InputStream这个类来获取，所以也屏蔽了资源的提供者。

另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，从上图中可以看出这个任务是由ResourceLoader接口完成，他屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源，他的默认实现是DefaultResourceLoader。

下面看一下Context和Resource是如何建立关系的？

首先看一下他们的类关系图：

图9.Context和Resource的类关系图

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

Core组件中还有很多类似的方式。

3.4Ioc容器如何工作

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

3.4.1如何创建BeanFactory工厂

正如图2描述的那样，Ioc容器实际上就是Context组件结合其他两个组件共同构建了一个Bean关系网，如何构建这个关系网？

构建的入口就在AbstractApplicationContext类的refresh方法中。

这个方法的代码如下：

清单1.AbstractApplicationContext.refresh

publicvoidrefresh（）throwsBeansException,IllegalStateException{

synchronized（this.startupShutdownMonitor）{

//Preparethiscontextforrefreshing.

prepareRefresh（）;

//Tellthesubclasstorefresh（更新）theinternal（内部）beanfactory.

ConfigurableListableBeanFactorybeanFactory=obtainFreshBeanFactory（）;

//Preparethebeanfactoryforuseinthiscontext.

prepareBeanFactory（beanFactory）;

try{

//Allowspost-processing（后处理）ofthebeanfactoryincontextsubclasses.

postProcessBeanFactory（beanFactory）;

//Invokefactoryprocessors（处理器）registeredasbeansinthecontext.

invokeBeanFactoryPostProcessors（beanFactory）;

//Registerbeanprocessorsthatinterceptbeancreation.（拦截bean创建）

registerBeanPostProcessors（beanFactory）;

//Initializemessagesourceforthiscontext.

initMessageSource（）;

//Initializeeventmulticaster（事件多路广播）forthiscontext.

initApplicationEventMulticaster（）;

//Initializeotherspecialbeansinspecificcontextsubclasses（特定上下文子类）.

onRefresh（）;

//Checkforlistenerbeansandregisterthem.

registerListeners（）;

//Instantiateallremaining（non-lazy-init）singletons（实例化所有剩下的单例）.

finishBeanFactoryInitialization（beanFactory）;

//Laststep:

publishcorrespondingevent（发布相应事件）.

finishRefresh（）;

}

catch（BeansExceptionex）{

//Destroyalreadycreatedsingletonstoavoiddangling（悬挂的）resources.

destroyBeans（）;

//Reset'active'flag.

cancelRefresh（ex）;

//Propagateexceptiontocaller.

throwex;

}

}

}

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

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

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

●注册可能感兴趣的事件

●创建Bean实例对象

●触发被监听的事件

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

第二三句就是在创建和配置BeanFactory。

这里是refresh也就是刷新配置，前面介绍了Context有可更新的子类，这里正是实现这个功能，当BeanFactory已存在是就更新，如果没有就新创建。

下面是更新BeanFactory的方法代码：

清单2.AbstractRefreshableApplicationContext.refreshBeanFactory

protectedfinalvoidrefreshBeanFactory（）throwsBeansException{

if（hasBeanFactory（））{

destroyBeans（）;

closeBeanFactory（）;

}

try{

DefaultListableBeanFactorybeanFactory=createBeanFactory（）;

beanFactory.setSerializationId（getId（））;

customizeBeanFactory（beanFactory）;

loadBeanDefinitions（beanFactory）;

synchronized（this.beanFactoryMonitor）{

this.beanFactory=beanFactory;

}

}

catch（IOExceptionex）{

thrownewApplicationContextException（"I/Oerrorparsingbeandefinitionsourcefor"+getDisplayName（）,ex）;

}

}

这个方法实现了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

voidpostProcessBeanFactory（ConfigurableListableBeanFactorybeanFactory）throwsBeansException;

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

registerBeanPostProcessors方法也是可以获取用户定义的实现了BeanPostProcessor接口的子类，并执行把它们注册到BeanFactory对象中的beanPostProcessors变量中。

BeanPostProcessor中声明了两个方法：

postProcessBeforeInitialization、postProcessAfterInitialization分别用于在Bean对象初始化时执行。

可以执行用户自定义的操作。

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

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

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

清单4.AbstractApplicationContext.finishBeanFactoryInitialization

protectedvoidfinishBeanFactoryInitialization（ConfigurableListableBeanFactorybeanFactory）{

//StopusingthetemporaryClassLoaderfortypematching.

beanFactory.setTempClassLoader（null）;

//Allowforcachingallbeandefinitionmetadata,notexpectingfurtherchanges.

beanFactory.freezeConfiguration（）;

//Instantiateallremaining（non-lazy-init）singletons.

beanFactory.preInstantiateSingletons（）;

}

从上面代码中可以发现Bean的实例化是在BeanFactory中发生的。

preInstantiateSingletons方法的代码如下：

清单5.DefaultListableBeanFactory.preInstantiateSingletons

publicvoidpreInstantiateSingletons（）throwsBeansException{

if（this.logger.isInfoEnabled（））{

this.logger.info（"Pre-instantiatingsingletonsin"+this）;

}

synchronized（this.beanDefinitionMap）{

for（StringbeanName:

this.beanDefinitionNames）{

RootBeanDefinitionbd=getMergedLocalBeanDefinition（beanName）;

if（!

bd.isAbstract（）&&bd.isSingleton（）&&!

bd.isLazyInit（））{

if（isFactoryBean（beanName））{

finalFactoryBeanfactory=（FactoryBean）getBean（FACTORY_BEAN_PREFIX+beanName）;

booleanisEagerInit;

if（System.getSecuri