Spring框架的设计理念与设计模式分析
Spring框架的设计理念与设计模式分析
摘要：本文试图剖析出Spring框架的作者设计Spring框架的骨骼结构的设计理念，有哪几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成Spring的骨骼架构？Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？Spring中又使用了哪些设计模式来完成它的这种设计？它的这种设计理念对我们以后的软件设计有何启示？本文将解答这些问题
一、 Spring的骨骼架构
Spring总共有十几个组件，但真正核心的组件只有几个，下面是Spring框架的总体架构图
图1 .Spring框架的总体架构图
从图中可以看出，Spring框架中的核心组件只有三个：Context，Core和Beans，它们构建起了整个Spring的骨骼架构。没有它们就不可能有AOP，Web等上层的特性功能。下面也将主要从这三个组件入手分析Spring
1. Spring的设计理念
前面介绍了Spring的三个核心组件，如果再在它们三个之中选出一个核心的话，那就非Beans组件莫属了。为何这样说，其实Spring就是面向Bean的编程（BOP，Bean Oriented Programming），Bean在Spring中才是真正的主角。
Bean在Spring中的作用就像Object对OOP的意义一样，没有对象的概念就没有面向对象编程，Spring中没有Bean也就没有了Spring存在的意义。就像演出舞台都准备好了但是却没有演员一样。为什么Bean如此重要，这是由Spring的设计目标决定的。Spring为何如此流行，我们使用Spring的原因是什么，想想你会发现原来Spring解决了一个非常关键的问题：它可以让你把对象间的依赖关系转而用配置文件来管理，也就是它的依赖注入机制。而这个注入关系在一个叫IOC的容器中管理，IOC容器存的就是被Bean包裹的对象。Spring正是通过把对象包装在Bean中来达到对这些对象管理以及额外操作的目的。
它的这种设计策略完全类似于Java实现OOP的设计理念，当然了Java本身的设计要比Spring复杂太多太多，但是都是构建一个数据结构，然后根据这个数据结构设计它的生存环境，并让它在这个生存环境中按照一定的规律在不停的运动。在它们的不停运动中设计一系列与环境或者其他个体完成信息交换。回头想想其他框架都是类似的设计理念。
2. 核心组件如何协同工作
前面说Bean是Spring中的关键因素，那么Core和Context又有何作用呢？前面把Bean比作一场演出中的演员，那么Context就是舞台背景，Core就是演出的道具。只有它们在一起才能具备演出一场好戏的基本条件。当然有最基本的条件还不能使这场戏脱颖而出，还要它表演的界面足够精彩，这些节目就是Spring能提供的特色功能了。
我们知道Bean包装的是Object，而Object必然有数据，如何给这些数据提供生存环境就是Context要解决的问题，对Context来说它就是要发现每个Bean之间的关系，为它们建立这种关系并维护好这种关系。所以Context就是一个Bean关系的集合，这个关系集合又叫IOC容器。一旦建立起这个IOC容器之后，Spring就可以为你工作了。那么Core组件又有何用武之地呢？其实Core就是发现，建立和维护Bean之间的关系所需要的一系列工具，从这个角度看Core这个组件叫Util能更让你理解。
它们之间的关系如下图所示：
图2.三个组件关系
3. 核心组件详解
这里将详细介绍每个组件内部类的层次关系，以及它们在运行时的时序顺序，我们在使用Spring时应该注意的地方。
3.1 Bean组件
前面已经说明了Bean组件对Spring的重要性，下面看看Bean这个组件是怎么设计的。Bean组件在Spring的org.springframework.beans包下。这个包下的所有类主要解决了三件事：Bean的定义，Bean的创建以及对Bean的解析。对Spring的使用者来说唯一需要关心的就是Bean的创建，其他两个由Spring在内部帮你完成了，对你来说是透明的。
Spring Bean的创建是典型的工厂模式，它的*接口是BeanFactory，下图是这个工厂的继承层次关系：
图4. Bean工厂的继承关系
BeanFactory有三个子类：ListableBeanFactory，HierarchicalBeanFactory和AutowireCapatableBeanFactory。但是从上图我们可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口。那么为何要定义这么多层次的接口呢？查阅这些层次的源码和说明发现，每个接口都有它使用的场合，它主要是为了区分Spring内部操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如ListableBeanFactory接口表示这些Bean是可列表的；而HierarchicalBeanFactory接口表示这些Bean是有继承关系的，也就是说每个Bean都可能有父Bean；AutowireCapatableBeanFactory接口定义Bean的自动装配规则。这四个接口共同定义了Bean的集合，Bean之间的关系，以及Bean的行为。
Bean的定义主要有BeanDefination描述，下图说明了这些类的层次关系：
图5. Bean定义的类层次关系图
Bean的定义就是完整的描述了在Spring的配置文件中你定义的<bean/>节点中的所有信息，包括各种子节点。当Spring成功解析你定义的一个<bean/>节点后，在Spring的内部它就被转化成了BeanDefination对象，以后所有的操作都是对这个对象完成的。
Bean的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。Bean的解析主要是对Spring配置文件的解析。这个解析过程主要是通过下图中的类完成：
图6. Bean的解析类
当然还有具体对tag的解析 在这里并未列出
3.2 Context组件
Context组件在Spring的org.springframework.context包下，前面已经讲解了Context组件在Spring中的作用，它实际上就是给Spring提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个环境是如何构建的。
ApplicationContext是Context的*父类，它除了能标识一个应用环境的基本信息外，它还继承了5个接口，这5个接口主要是扩展了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必须要完成以下几件事：
l 标识一个应用环境
l 利用BeanFactory创建Bean对象
l 保存对象关系表
l 能够捕获各种事件
Context作为Spring的IOC容器，基本上整合了Spring的大部分功能，或者说是大部分功能的基础
3.3 Core核心组件
Core组件作为Spring的核心组件，包含了很多的关键类，其中一个重要的组成部分就是定义了资源的访问方式。这种把所有资源都抽象成一个接口的方式很值得以后在设计中学习。下面就看一下这部分在Spring中的作用。
下面是Resource相关的类结构图：
图8. Resource相关的类结构图
从上图可以看出Resource接口封装了各种可能的资源类型，就是说对使用者来说屏蔽了文件类型的不同。对资源的提供者来说，如何把资源包装起来交给其他人用这也是一个问题，我们看到Resource接口继承了InputStreamSource接口，这个接口中有一个getInputStream方法，返回的是InputStream类。这样所有的资源都可以通过InputStream类来获取，所以也屏蔽了资源的提供者。另外还有一个就是加载资源的问题，也就是资源的加载者要统一，从上图中可以看出这个任务是由ResourceLoader接口来完成，它屏蔽了所有资源加载者的差异，只需要实现这个接口就可以加载所有的资源，它的默认实现是DefaultResourceLoader。
下面看一下Context和Resource是如何建立关系的，首先看一下它们的类关系图：
图9. Context和Resource的类关系图
从上图可以看出，Context是把资源的加载，解析和描述工作委托给了ResourcePatternResolver类来完成，它相当于一个接头人，它把资源的加载，解析和资源的定义整合在一起便于其他组件使用。Core组件中还有很多类似的方式。
3.4 IOC容器如何工作
前面介绍了Core组件，Beans组件和Context组件和他们之间的相互关系，下面从使用者的角度看下他们是如何运行的，以及我们如何让Spring完成各种功能，Spring到底有哪些功能，这些功能是如何得来的？
3.4.1如何创建BeanFactory工厂
正如图2描述的那样，IOC容器实际上就是Context组件结合其他两个组件共同构建了一个Bean的关系网。如何构建这个关系网？构建的入口就在AbstractApplicationContext类的refresh方法中。代码如下：
清单1. AbstractApplicationContext.refresh
|
public void refresh() throws BeansException, IllegalStateException { synchronized(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 subclass 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: public corresponding event finishRefresh(); }catch(BeansException ex) { destroyBeans(); cancelRefresh(ex); throw ex; } } } |
这个方法就是构建整个IOC容器的完整代码，了解里面的每一行代码基本上就了解了Spring的大部分的原理和功能了。这段代码主要包含以下几个步骤：
l 构建BeanFactory，以便产生所需的“演员”
l 注册可能感兴趣的事件
l 创建Bean实例对象
l 触发被监听的时间
下面就结合代码分析这几个过程。
第二三句就是在创建和配置BeanFactory，这里refresh也就是刷新配置，前面介绍了Context有可更新的子类，这里正是实现这个功能，当BeanFactory已经存在就更新，如果没有就新建，下面是更新BeanFactory的代码：
protected final void refreshBeanFactory() throws BeansException {
if(hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized(beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
} catch(IOException ex) {
throw new ApplicationContextException((new StringBuilder("I/O error parsing bean definition source for ")).append(getDisplayName()).toString(), ex);
}
}
这个方法实现了AbstractApplicationContext的抽象方法refreshBeanFactory，这段代码清楚的说明了BeanFactory的创建过程。注意BeanFactory类型的变化，前面介绍了它有很多子类，在什么情况下使用不同的子类这非常关键。BeanFactory的原始对象是DefaultListableBeanFactory。这非常关键，因为它涉及到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：
图10. DefaultListableBeanFactory类继承关系图
从这个可以发现除了BeanFactory相关的类外，还有与Bean的register相关的类。这在refreshBeanFactory方法中有一行loadBeanDefinations（beanFactory）将找到答案，这个方法将开始加载，解析Bean的定义，也就是把用户定义的数据结构转化成IOC中特定的数据结构。
这个过程可以用下面的时序图来解释：
图11.创建BeanFactory时序图
Bean的解析和登记流程时序图如下：
图12.解析和登记Bean对象时序图
创建好BeanFactory后，接下来添加一些Spring本身需要的工具类，这个操作在AbstractApplicationContext的prepareBeanFactory方法完成。
AbstractApplicationContext中接下来三行代码对Spring的功能扩展起了至关重要的作用。前两行主要是让你现在可以对已经创建的BeanFactory的配置做修改，后一行就是让你可以对以后再创建Bean的实例对象时添加一些自定义的操作。所以他们都是扩展了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 temporary ClassLoader for type matching
beanFactory.setTempClassLoader(null);
//Allow for caching all bean definition metadata,not expecting futher changes
beanFactory.freezeConfiguration();
//Instantiate all remaining(not-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 (Iterator it = this.beanDefinitionNames.iterator(); it.hasNext();) {
String beanName = (String) it.next();
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
if (factory instanceof SmartFactoryBean && ((SmartFactoryBean) factory).isEagerInit()) {
getBean(beanName);
}
}else {
getBean(beanName);
}
}
}
}
}
这里出现了一个非常重要的bean-Factory Bean，可以说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架构的核心竞争力。何时，如何创建它们之间的关系请看下面的时序图：
图15.Bean对象关系建立
3.4.3 IOC容器的扩展点
现在还有一个问题就是如何让这些Bean对象有一定的扩展性，就是可以加入用户的一些操作。那么有哪些扩展点呢？Spring又是如何调用这些扩展点呢？
对Spring的IOC来说，主要有这么几个：BeanFactoryPostProcessor，BeanPostProcessor。它们分别是在构建BeanFactory和构建Bean对象时创建。还有就是InitializingBean和DisposableBean它们分别是在Bean实例创建和销毁时被调用。用户可以实现这些接口中定义的方法，Spring就会在适当的时候调用它们。还有一个是FactoryBean是一个特殊的Bean，可以被用户更多的控制。
这些扩展点通常也是我们使用Spring来完成我们特定任务的地方，如何精通Spring就看你有没有掌握好Spring有哪些扩展点，并且如何使用它们，要知道如何使用它们就要了解Spring内在的机制。可以用下面的比喻来解释：
我们把IOC比作一个箱子，这个箱子里有若干个球的模子，可以用这些模子来造很多种不同的球，还有一个造这些球模的机器，这个机器可以产生球模。BeanFactory就是那个造球模的机器，Bean就是球模，而球模造出来的球就是Bean的实例。那么前面说的几个扩展点又在什么地方呢？BeanFactoryPostProcessor对应到 当球模被造出来时，你将有机会对其作出适当的修改，也就是它可以帮你修改球模。而InitializingBean和DisposableBean是在球模造球的开始和结束阶段，你可以完成一些预备和扫尾工作。BeanPostProcessor就可以让你对球模造出来的球进行适当的修正。最后还有一个FactoryBean，它是一个神奇的球模。这个球模不是预先就定型了，而是由你来确定它们的形状，既然你可以确定这个球模的形状，它造出来的球当然是你想要的球了。
3.4.4 IOC容器如何为我所用
前面介绍了Spring容器的创建过程，那Spring能为我们做什么，Spring的IOC容器又能做什么？我们使用Spring必须要首先创建IOC容器，没有它Spring无法工作，ApplicationContext.xml就是IOC容器的默认配置文件，Spring的所有特性功能都是基于这个IOC容器工作的。
IOC它实际上就是为你构建了一个魔方，Spring为你搭好了骨骼框架，这个魔方到底能变出什么好东西出来，这必须要有你的参与。那我们怎么参与？这就是前面说的有哪些扩展点，我们通过实现那些扩展点来改变Spring的通用行为。至于如何实现扩展点来得到我们想要的个性结果，Spring中有很多例子，其中AOP的实现就是Spring本事实现了其扩展点来达到它想要的特性功能，可以拿来参考。
二、 Spring中AOP特性
1. 动态代理的实现
要了解Spring的AOP就必须先了解动态代理的原理，因为AOP就是基于动态代理实现的，动态代理还要从JDK本身说起。
在JDK的java.lang.reflect包下有个Proxy类，它正是构建代理类的入口。这个类的结构如下：
图16. 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产生代理类的过程，它构造出来的代理类到底是个什么样子呢，马上揭晓：
图17.创建代理对象时序图
从上图中可以发现正在构造代理类的是ProxyGenerator的generateProxyClass方法。ProxyGenerator类是在sun.misc包下，感兴趣的可以去看它的源码。
假如有这样一个接口，如下：
清单7. SimpleProxy类
public interface SimpleProxy {
public void simpleMethod1();
public void simpleMethod2();
}
生成的代理类结构如下：
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，Advistor等一些接口，使得AOP更加灵活。
下面是JDK动态代理的类图：
图18. Jdk动态代理的类图
上图清楚的显示了Spring引用了AOP联盟定义的接口，姑且不讨论Spring如何扩展AOP联盟，先看看Spring如何实现代理类的，要实现代理类在Spring的配置文件中通常是这样定义一个Bean的，如下：
清单9.配置代理类Bean
<bean id="testBeanSingleton" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces"> <value>org.springframework.aop.framework.PrototypeTargetTests$TestBean</value>
</property>
<property name="target"><ref local="testBeanTarget"></ref> </property>
<property name="singleton"><value>true</value></property>
<property name="interceptorNames">
<list>
<value>testInterceptor</value>
<value>testInterceptor2</value>
</list>
</property>
</bean>
从配置文件看到需要设置被代理的接口，和接口的实现类也就是目标类，以及拦截器也就在执行目标方法之前被调用，这里Spring中定义了各种各样的拦截器，可选择使用。
下面看看Spring是如何完成代理以及如何调用拦截器的：
前面提到Spring AOP也是实现自身的扩展点来完成这个特性的，从这个代理类就可看出它正是继承了FactoryBean的ProxyFactoryBean，FactoryBean之所以特别就在于它可以让你自定义对象的创建方法，当然代理对象要通过Proxy类来动态生成。
下面是Spring创建代理对象的时序图：
图19.Spring代理对象的产生
Spring创建了代理对象后，当你调用目标对象上的方法时，将会被代理到InvocationHandler类的invoke方法中执行，这在前面已经解释过。其中JdkDynamicAopProxy类实现了InvocationHandler接口。
下面再看看Spring是如何调用拦截器的，下面是这个过程的时序图：
图20.Spring调用拦截器
以上所说的都是JDK动态代理，Spring还支持一种CGLIB类代理，感兴趣的可以看看。
三、 Spring中设计模式分析
Spring中使用的设计模式有很多，比如工厂模式，单例模式，模板方法模式，在《Webx框架的系统架构与设计模式》、《Tomcat的系统架构与模式设计分析》已经有介绍，这里就不赘述了。这里主要介绍代理模式和策略模式。
1. 代理模式
1.1 代理模式原理
代理模式就是给某一个对象创建一个代理对象，而由这个代理对象控制对原对象的引用，而创建这个代理对象就是为了当调用原对象是可以增加一些额外的操作，下面是代理模式的结构：
图21.代理模式的结构
l Subject：抽象主题，它是代理对象的真实对象要实现的接口，当然这可以是多个接口组成
l ProxySubject：代理类除了实现Subject定义的接口外，还必须持有所代理对象的引用
l RealSubject：被代理的类，是目标对象
1.2 Spring中如何实现代理模式
SpringAop中JDK动态代理就是利用代理模式实现的。在Spring中除了实现被代理对象的接口外，还会有org.springframework.aop.SpringProxy和org.springframework.aop.framework.Advisted两个接口，Spring中使用代理模式的结构图如下：
图22. Spring中使用代理模式的结构图
$Proxy就是创建的代理对象，而Subject是抽象主题，代理对象是通过InvocationHandler来持有对目标对象的引用的。
2. 策略模式
2.1 策略模式原理
策略模式顾名思义就是做某事的策略，这在编程上是指完成某个操作通常有多种方法，这些方法各有千秋，可能有不能的使用场合，然而这些操作方法都有可能用到。每一个操作方法都当做一个实现策略，使用者可以根据需要选择合适的策略。
下面是策略模式的结构：
图23.策略模式的结构
l Context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要的操作，它持有一个Strategy实例的引用。创建具体策略的方法也可以由他完成
l Strategy：抽象策略，定义每个策略都要实现的方法
l ConcreteStrategy：具体策略实现类，实现抽象策略中定义的策略方法
2.2 Spring中策略模式的实现
Spring中有很多地方使用策略模式，如Bean定义对象的创建以及代理对象的创建等，这里主要看下代理对象的创建的策略模式的实现。
前面已经了解了Spring的代理方式有两种：JDK动态代理和CGLIB代理。这两个代理方式的使用正是使用了策略模式，它的结构如下图所示：
图24. Spring中策略模式结构图
上图与标准的策略模式稍有不同，这里抽象策略是AopProxy接口，Cglib2AopProxy和JdkDynamicAopProxy分别代表两种策略的实现方式，ProxyFactoryBean就是代表Context角色，它根据条件选择使用JDK代理还是CGLIB代理。而另外三个类主要是负责创建具体策略对象，ProxyFactoryBean是通过依赖方法来关联具体策略对象的，它是通过调用策略对象的getProxy（ClassLoader classLoader）来完成具体操作的。
四、 Webx2.0与Spring3.0框架的比较
Webx主要作为表现层框架与Spring主要用于业务逻辑层，本身可比性不强。Webx也有一个容器叫Service容器，可以说Webx也是基于这个容器工作的。Webx的Service容器和Spring的IOC容器有很多相似之处，一个Service组件相当于Spring中的Bean，Service的管理是通过ServiceManager，而Spring是BeanFactory，Spring中的ApplicationContext相当于Webx中的WebxController。虽然结构有点类似，但实际差别很大。
首先Webx没有把容器的构建者和容器的使用者角色分开，在Webx中Service是兼顾两个角色的，它既是容器的执行者又是容器的被执行者。但Spring不同，我们使用Spring主要是用来管理我们自己定义的对象间的关系。虽然Spring本身的执行也是基于同样的原理，但Spring并没有把容器执行者角色需要的类交给用户去配置，Spring把它作为默认配置向用户屏蔽。虽然Webx中也有默认的Service配置，但是用户仍然可以修改容器本身的结构行为。
其次，Webx的耦合性太强，我在《Webx框架的系统架构与设计模式》中曾经把Webx中的Service划分为三层，其中一层就是说到Service之间是批次依赖的，框架之间有依赖关系不可避免。但这种依赖是不是要扩展到框架之外，让用户也绑定到框架上就值得考虑了。Webx中就有这样的，本来Webx把对Service的配置开放给用户，是想提高其扩展性。但是有一个缺点就是，你要配置的这些Service他们有彼此之间依赖，而这种依赖是紧耦合的。也就是Service之间的调用时写在Service中某个方法中的，虽然Service对象的创建是通过ServiceManager来完成的，但是调用其他Service这种关系还是写死的，也就是，Service之间的关联关系并不是由使用者通过配置文件就能完全管理的。这种通过把框架本身的执行逻辑交给框架使用者来控制而达到其框架本身的扩展性，是非常不可取的。而Spring做的非常好。框架本身的执行与使用者的代码没有太强的耦合性，也就是你不能控制框架本身的执行逻辑，你能控制改变的只能是你自己定义的行为，当然你可以借助Spring让他更强大。
再次，Webx扩展性不好，我至今仍然想不通Webx为何要构建四个容器，Webx中有个Spring，Spring中有个Webx。唯一的解释就是Webx不能与Spring有很好的互通性。也就是Webx要访问Spring怎么办呢？就在Webx中起一个Spring容器，那Spring要访问Webx又怎么办呢？Spring中起一个Webx容器。前面的Webx又要访问后面的Spring咋办。只能让前面的Spring指向后面的Spring，这关系真复杂。为何有这么复杂的关系，唯一的解释只能是没有良好的扩展点。到底是Spring没有还是Webx没有？