javascript
spring框架的设计理念与设计模式分析 -ag凯发k8国际
spring设计原理
spring框架的设计理念与设计模式分析2016-1-27 by damon
摘要：spring作为现在最优秀的框架之一，被广泛的使用并有很多对其分析的文章。本文将从另外一个视角试图剖析出spring框架的作者设计spring框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成spring的骨骼架构？spring的aop特性又是如何利用这些基础的骨骼架构来工作的？spring中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。
一、spring的骨骼架构
spring总共有十几个组件，但是真正核心的组件只有几个，下面是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更能让你理解。
它们之间可以用下图来表示：
核心组件详解
这里将详细介绍每个组件内部类的层次关系，以及它们在运行时的时序顺序。我们在使用spring是应该注意的地方。
3.1 bean组件
前面已经说明了bean组件对spring的重要性，下面看看bean这个组件式怎么设计的。bean组件在spring的org.springframework.beans包下。这个包下的所有类主要解决了三件事：bean的定义、bean的创建以及对bean的解析。对spring的使用者来说唯一需要关心的就是bean的创建，其他两个由spring在内部帮你完成了，对你来说是透明的。
spring bean的创建时典型的工厂模式，他的顶级接口是beanfactory，下图是这个工厂的继承层次关系：
beanfactory有三个子类：listablebeanfactory、hierarchicalbeanfactory和autowirecapablebeanfactory。但是从上图中我们可以发现最终的默认实现类是defaultlistablebeanfactory，他实现了所有的接口。那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在spring内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如listablebeanfactory接口表示这些bean是可列表的，而hierarchicalbeanfactory表示的是这些bean是有继承关系的，也就是每个bean有可能有父bean。autowirecapablebeanfactory接口定义bean的自动装配规则。这四个接口共同定义了bean的集合、bean之间的关系、以及bean行为。
bean的定义主要有beandefinition描述，如下图说明了这些类的层次关系：
bean的定义就是完整的描述了在spring的配置文件中你定义的节点中所有的信息，包括各种子节点。当spring成功解析你定义的一个节点后，在spring的内部他就被转化成beandefinition对象。以后所有的操作都是对这个对象完成的。
bean的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。bean的解析主要就是对spring配置文件的解析。这个解析过程主要通过下图中的类完成：
当然还有具体对tag的解析这里并没有列出。
3.2 context组件
context在spring的org.springframework.context包下，前面已经讲解了context组件在spring中的作用，他实际上就是给spring提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个环境是如何构建的。
applicationcontext是context的顶级父类，他除了能标识一个应用环境的基本信息外，他还继承了五个接口，这五个接口主要是扩展了context的功能。下面是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的大部分功能，或者说是大部分功能的基础。
3.3 core组件
core组件作为spring的核心组件，他其中包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。这种把所有资源都抽象成一个接口的方式很值得在以后的设计中拿来学习。下面就重要看一下这个部分在spring的作用。
下图是resource相关的类结构图：
从上图可以看出resource接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。对资源的提供者来说，如何把资源包装起来交给其他人用这也是一个问题，我们看到resource接口继承了inputstreamsource接口，这个接口中有个getinputstream方法，返回的是inputstream类。这样所有的资源都被可以通过inputstream这个类来获取，所以也屏蔽了资源的提供者。另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，从上图中可以看出这个任务是由resourceloader接口完成，他屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源，他的默认实现是defaultresourceloader。
下面看一下context和resource是如何建立关系的？首先看一下他们的类关系图：
从上图可以看出，context是把资源的加载、解析和描述工作委托给了resourcepatternresolver类来完成，他相当于一个接头人，他把资源的加载、解析和资源的定义整合在一起便于其他组件使用。core组件中还有很多类似的方式。
3.4 ioc容器如何工作
前面介绍了core组件、bean组件和context组件的结构与相互关系，下面这里从使用者角度看一下他们是如何运行的，以及我们如何让spring完成各种功能，spring到底能有那些功能，这些功能是如何得来的，下面介绍。
3.4.1 如何创建beanfactory工厂
正如图2描述的那样，ioc容器实际上就是context组件结合其他两个组件共同构建了一个bean关系网，如何构建这个关系网？构建的入口就在abstractapplicationcontext类的refresh方法中。这个方法的代码如下：
清单1. abstractapplicationcontext.refresh
public void refresh() throws beansexception, illegalstateexception {synchronized (this.startupshutdownmonitor) {// prepare this context for refreshing.preparerefresh();// tell the subclass to refresh the internal bean factory.configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();// prepare the bean factory for use in this context.preparebeanfactory(beanfactory);try {// allows post-processing of the bean factory in context subclasses.postprocessbeanfactory(beanfactory);// invoke factory processors registered as beans in the context.invokebeanfactorypostprocessors(beanfactory);// register bean processors that intercept bean creation.registerbeanpostprocessors(beanfactory);// initialize message source for this context.initmessagesource();// initialize event multicaster for this context.initapplicationeventmulticaster();// initialize other special beans in specific context subclasses.onrefresh();// check for listener beans and register them.registerlisteners();// instantiate all remaining (non-lazy-init) singletons.finishbeanfactoryinitialization(beanfactory);// last step: publish corresponding event.finishrefresh();} catch (beansexception ex) {// destroy already created singletons to avoid dangling resources.destroybeans();// reset 'active' flag.cancelrefresh(ex);// propagate exception to caller.throw ex;}} }这个方法就是构建整个ioc容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分spring的原理和功能了。
这段代码主要包含这样几个步骤：
构建beanfactory，以便于产生所需的“演员”
注册可能感兴趣的事件
创建bean实例对象
触发被监听的事件
下面就结合代码分析这几个过程。
第二三句就是在创建和配置beanfactory。这里是refresh也就是刷新配置，前面介绍了context有可更新的子类，这里正是实现这个功能，当beanfactory已存在是就更新，如果没有就新创建。下面是更新beanfactory的方法代码：
清单2. abstractrefreshableapplicationcontext. refreshbeanfactory
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);} }这个方法实现了abstractapplicationcontext的抽象方法refreshbeanfactory，这段代码清楚的说明了beanfactory的创建过程。注意beanfactory对象的类型的变化，前面介绍了他有很多子类，在什么情况下使用不同的子类这非常关键。beanfactory的原始对象是defaultlistablebeanfactory，这个非常关键，因为他设计到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：
从这个图中发现除了beanfactory相关的类外，还发现了与bean的register相关。这在refreshbeanfactory方法中有一行loadbeandefinitions(beanfactory)将找到答案，这个方法将开始加载、解析bean的定义，也就是把用户定义的数据结构转化为ioc容器中的特定数据结构。
这个过程可以用下面时序图解释：
bean的解析和登记流程时序图如下：
创建好beanfactory后，接下去添加一些spring本身需要的一些工具类，这个操作在abstractapplicationcontext的preparebeanfactory方法完成。
abstractapplicationcontext中接下来的三行代码对spring的功能扩展性起了至关重要的作用。前两行主要是让你现在可以对已经构建的beanfactory的配置做修改，后面一行就是让你可以对以后再创建bean的实例对象时添加一些自定义的操作。所以他们都是扩展了spring的功能，所以我们要学习使用spring必须对这一部分搞清楚。
其中在invokebeanfactorypostprocessors方法中主要是获取实现beanfactorypostprocessor接口的子类。并执行它的postprocessbeanfactory方法，这个方法的声明如下：
清单3. beanfactorypostprocessor.postprocessbeanfactory
void postprocessbeanfactory(configurablelistablebeanfactory beanfactory) throws beansexception;它的参数是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
protected void finishbeanfactoryinitialization(configurablelistablebeanfactory beanfactory) {// stop using the temporary classloader for type matching.beanfactory.settempclassloader(null);// allow for caching all bean definition metadata, not expecting further changes.beanfactory.freezeconfiguration();// instantiate all remaining (non-lazy-init) singletons.beanfactory.preinstantiatesingletons(); }从上面代码中可以发现bean的实例化是在beanfactory中发生的。preinstantiatesingletons方法的代码如下：
清单5. defaultlistablebeanfactory.preinstantiatesingletons
public void preinstantiatesingletons() throws beansexception {if (this.logger.isinfoenabled()) {this.logger.info("pre-instantiating singletons in " this);}synchronized (this.beandefinitionmap) {for (string beanname : this.beandefinitionnames) {rootbeandefinition bd = getmergedlocalbeandefinition(beanname);if (!bd.isabstract() && bd.issingleton() && !bd.islazyinit()) {if (isfactorybean(beanname)) {final factorybean factory = (factorybean) getbean(factory_bean_prefix beanname);boolean iseagerinit;if (system.getsecuritymanager() != null && factory instanceof smartfactorybean) {iseagerinit = accesscontroller.doprivileged(new privilegedaction这里出现了一个非常重要的bean——factorybean，可以说spring一大半的扩展的功能都与这个bean有关，这是个特殊的bean他是个工厂bean，可以产生bean的bean，这里的产生bean是指bean的实例，如果一个类继承factorybean用户可以自己定义产生实例对象的方法只要实现他的getobject方法。然而在spring内部这个bean的实例对象是factorybean，通过调用这个对象的getobject方法就能获取用户自定义产生的对象，从而为spring提供了很好的扩展性。spring获取factorybean本身的对象是在前面加上&来完成的。
如何创建bean的实例对象以及如何构建bean实例对象之间的关联关系式spring中的一个核心关键，下面是这个过程的流程图。
如果是普通的bean就直接创建他的实例，是通过调用getbean方法。下面是创建bean实例的时序图：
还有一个非常重要的部分就是建立bean对象实例之间的关系，这也是spring框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：
3.4.3 ioc容器的扩展点
现在还有一个问题就是如何让这些bean对象有一定的扩展性，就是可以加入用户的一些操作。那么有哪些扩展点呢？spring又是如何调用到这些扩展点的？
对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，它可是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的球了，这样在这个箱子里尼可以发现所有你想要的球。
3.4.4 ioc容器如何为我所用
前面的介绍了spring容器的构建过程，那spring能为我们做什么，spring的ioc容器又能做什么呢？我们使用spring必须要首先构建ioc容器，没有它spring无法工作，applicatoncontext.xml就是ioc容器的默认配置文件，spring的所有特×××都是基于这个ioc容器工作的，比如后面要介绍的aop。
ioc它实际上就是为你构建了一个魔方，spring为你搭好了骨骼架构，这个魔方到底能变出什么好的东西出来，这必须要有你的参与。那我们怎么参与？这就是前面说的要了解spring中那有些扩展点，我们通过实现那些扩展点来改变spring的通用行为。至于如何实现扩展点来得到我们想要的个性结果，spring中有很多例子，其中aop的实现就是spring本身实现了其扩展点来达到了它想要的特×××，可以拿来参考。
二、spring中aop特性详解
1.动态代理的实现原理
要了解spring的aop就必须先了解的动态代理的原理，因为aop就是基于动态代理实现的。动态代理还要从jdk本身说起。
在jdk的java.lang.reflect包下有个proxy类，它正是构造代理类的入口。这个类的结构入下：
从上图发现最后面四个是公有方法。而最后一个方法newproxyinstance就是创建代理对象的方法。这个方法的源码如下：
清单6.proxy. newproxyinstance
public static object newproxyinstance(classloader loader,class[] interfaces,invocationhandler h)throws illegalargumentexception{if (h == null) {throw new nullpointerexception();}class cl = getproxyclass(loader, interfaces);try {constructor cons = cl.getconstructor(constructorparams);return (object) cons.newinstance(new object[] { h });} catch (nosuchmethodexception e) {throw new internalerror(e.tostring());} catch (illegalaccessexception e) {throw new internalerror(e.tostring());} catch (instantiationexception e) {throw new internalerror(e.tostring());} catch (invocationtargetexception e) {throw new internalerror(e.tostring());} }这个方法需要三个参数：classloader，用于加载代理类的loader类，通常这个loader和被代理的类是同一个loader类。interfaces，是要被代理的那些那些接口。invocationhandler，就是用于执行除了被代理接口中方法之外的用户自定义的操作，他也是用户需要代理的最终目的。用户调用目标方法都被代理到invocationhandler类中定义的唯一方法invoke中。这在后面再详解。
下面还是看看proxy如何产生代理类的过程，他构造出来的代理类到底是什么样子？下面揭晓啦。
其实从上图中可以发现正在构造代理类的是在proxygenerator的generateproxyclass的方法中。proxygenerator类在sun.misc包下，感兴趣的话可以看看他的源码。
假如有这样一个接口，如下：
清单7.simpleproxy类
public interface simpleproxy {public void simplemethod1();public void simplemethod2();}代理来生成的类结构如下：
清单8. $proxy2类
public class $proxy2 extends java.lang.reflect.proxy implements simpleproxy{java.lang.reflect.method m0;java.lang.reflect.method m1;java.lang.reflect.method m2;java.lang.reflect.method m3;java.lang.reflect.method m4;int hashcode();boolean equals(java.lang.object);java.lang.string tostring();void simplemethod1();void simplemethod2(); }这个类中的方法里面将会是调用invocationhandler的invoke方法，而每个方法也将对应一个属性变量，这个属性变量m也将传给invoke方法中的method参数。整个代理就是这样实现的。
2.spring aop如何实现
从前面代理的原理我们知道，代理的目的是调用目标方法时我们可以转而执行invocationhandler类的invoke方法，所以如何在invocationhandler上做文章就是spring实现aop的关键所在。
spring的aop实现是遵守aop联盟的约定。同时spring又扩展了它，增加了如pointcut、advisor等一些接口使得更加灵活。
下面是jdk动态代理的类图：
上图清楚的显示了spring引用了aop alliance定义的接口。姑且不讨论spring如何扩展aop alliance，先看看spring如何实现代理类的，要实现代理类在spring的配置文件中通常是这样定一个bean的，如下：
清单9.配置代理类bean
配置上看到要设置被代理的接口，和接口的实现类也就是目标类，以及拦截器也就在执行目标方法之前被调用，这里spring中定义的各种各样的拦截器，可以选择使用。
下面看看spring如何完成了代理以及是如何调用拦截器的。
前面提到spring aop也是实现其自身的扩展点来完成这个特性的，从这个代理类可以看出它正是继承了factorybean的proxyfactorybean，factorybean之所以特别就在它可以让你自定义对象的创建方法。当然代理对象要通过proxy类来动态生成。
下面是spring创建的代理对象的时序图：
spring创建了代理对象后，当你调用目标对象上的方法时，将都会被代理到invocationhandler类的invoke方法中执行，这在前面已经解释。在这里jdkdynamicaopproxy类实现了invocationhandler接口。
下面再看看spring是如何调用拦截器的，下面是这个过程的时序图：
以上所说的都是jdk动态代理，spring还支持一种cglib类代理，感兴趣自己看吧。
转载于:https://blog.51cto.com/damon188/1739324
总结
以上是ag凯发k8国际为你收集整理的spring框架的设计理念与设计模式分析的全部内容，希望文章能够帮你解决所遇到的问题。
- 上一篇：
- 下一篇：