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

目录

Spring的架构

核心组件

核心组件如何协调工作

核心组件详解

Bean组件

Context组件

Core组件

Ioc容器如何工作

如何创建BeanFactory工厂

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

Ioc容器的扩展点

Ioc容器如何为我所用

Spring中AOP特性详解

动态代理的实现原理

Spring AOP如何实现

Spring中设计模式分析

代理模式

原理

Spring中如何实现代理模式

策略模式

策略模式原理

Spring中策略模式的实现

结束语

---

Spring的架构

核心组件

spring真正核心的组件只有三个：Core Context 和 Beans。其中Beans最核心，Spring就是面向Bean的编程（Bean Oriented Programming）。Bean在Spring中的作用就像Object对OOP的意义一样，没有对象的概念就没有面向对象编程，Spring中没有Bean也就没有Spring存在的意义。为什么Bean这种角色在Spring中如此重要？这是由Spring框架的设计目标决定的。

Spring为何如此流行？因为Spring解决了一个非常关键的问题，它可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。这个注入关系在一个Ioc容器中管理，Ioc容器就是被Bean包裹的对象。Spring正是通过把对象包装在Bean中而达到对这些对象的管理以及一系列额外操作的目的。

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

核心组件如何协调工作

前面说Bean是Spring中关键因素，那Context和Core又有何作用？前面把Bean比作一场演出中的演员的话，那Context就是这场演出的舞台背景，而Core就是演出的道具。只有他们在一起才能具备演出一场好戏的基本条件。

我们知道Bean包装的是Object，而Object必然有数据，如何给这些数据提供生存环境就是Context要解决的问题。对Context来说它就是要发现每个Bean之间的关系，为它们建立这种关系并且维护好这种关系。所以Context就是一个Bean关系的集合，这个关系集合又叫Ioc容器，一旦建立起这个Ioc容器Spring就可以为你工作了。

那Core组件又有什么用武之地呢？Core就是发现、建立和维护每个Bean之间关系所需要的一系列工具，从这个角度来看，Core这个组件叫Util更能让你理解。

核心组件详解

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

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的配置文件中你定义的<bean/>节点中所有的信息，包括子节点。当Spring成功解析你定义的一个<bean/>节点后，在Spring的内部就被转化成BeanDefinition对象，以后所有的操作都是对这个对象完成的。

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

Context组件

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

ApplicationContext是Context的顶级父类，他除了能标识一个应用环境的基本信息外，他还继承了五个接口，这五个接口主要是扩展了Context的功能。下面是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的大部分功能，或者说是大部分功能的基础。

Core组件

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

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

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

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

Ioc容器如何工作

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

如何创建BeanFactory工厂

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

ublic 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的方法代码：
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容器中的特定数据结构。

这个过程可以用下面的时序图解释，创建BeanFactory时序图
Bean的解析和注册流程时序图如下：
创建好BeanFactory后，接下去添加一些Spring本身需要的工具类，这个操作在AbstractApplicationContext的prepareBeanFactory方法中完成。

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

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

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
    throws BeansException;

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

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

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

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

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

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方法的代码如下：
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<Boolean>() { 
                            public Boolean run() { 
                                return ((SmartFactoryBean) factory).isEagerInit(); 
                            } 
                        }, getAccessControlContext()); 
                    } 
                    else { 
                        isEagerInit = factory instanceof SmartFactoryBean 
                            && ((SmartFactoryBean) factory).isEagerInit(); 
                    } 
                    if (isEagerInit) { 
                        getBean(beanName); 
                    } 
                } 
                else { 
                    getBean(beanName); 
                } 
            } 
        } 
    } 
}

这里出现了一个非常重要的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框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：

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，它可是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的球了，这样在这个箱子里你可以发现所有你想要的球。

Ioc容器如何为我所用

前面介绍了Spring容器的构建过程，那Spring能为我们做什么？Spring的Ioc容器又能做什么呢？我们使用Spring必须要首先构建Ioc容器，没有它Spring无法工作，ApplicationContext就是Ioc容器的默认配置文件，Spring的所有特性功能都是基于这个Ioc容器工作的，比如后面要介绍的AOP。

Ioc它实际上就是为你构建了一个魔方，Spring为你搭建了骨骼架构，这个魔方到底能变出什么好东西出来，这必须要有你的参与。那我们如何参与？这就是前面说的要了解Spring中有哪些扩展点，我们通过实现那些扩展点来改变Spring的通用行为。至于如何实现扩展点来得到我们想要的个性结果，Spring中有很多例子，其中AOP的实现就是Spring本身实现了其扩展点来达到它想要的特性功能，可以拿来参考。

Spring中AOP特性详解

动态代理的实现原理

要了解Spring的AOP就必须先了解动态代理的原理，因为AOP就是基于动态代理实现的。动态代理还要从JDK本身说起。

在JDK的java.lang.reflect包下有个Proxy类，它正是构造代理类的入口。这个类的结构如下：
Proxy类结构

从上图发现最后面四个方法是公有方法。而最后一个方法newProxyInstance就是创建代理对象的方法。这个方法的源码如下：
Proxy.newInstance

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包下。
假设有下面这样一个接口

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参数。整个代理就是这样实现的。

Spring AOP如何实现

从前面代理的原理我们知道，代理的目的是调用目标方法时我们可以转而执行InvocationHandler类的invoke方法，所以如何在InvocationHandler上做文章就是Spring实现AOP的关键所在。

Spring的Aop实现是遵守Aop联盟的约定。同时Spring又扩展了它，增加了如Pointcut、Advisor等一些接口使得更加灵活。

下面是Jdk动态代理的类图：

上面清楚地显示了Spring引用了Aop Alliance定义的接口。姑且不讨论Spring如何扩展Aop Alliance，先看看Spring如何实现代理类，要实现代理类在Spring的配置文件中通常是这样定义一个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创建的代理对象的时序图：

Spring创建了代理对象后，当你调用目标对象上的方法时，将都会被代理到InvocationHandler类的invoke方法中执行，这在前面已经解释。在这里JdkDynamicAopProxy类实现了InvocationHandler接口。
下面再看看Spring是如何调用拦截器的，下面是这个过程的时序图：

以上所说的都是Jdk动态代理，Spring还支持一种CGLIB类代理，感兴趣自己看。

Spring中设计模式分析

Spring中使用的设计模式很多，比如工厂模式、单例模式、模板模式等，在《Webx框架的系统架构与设计模式》、《Tomcat系统架构与设计模式分析》已经有介绍，这里不再赘述。这里主要介绍代理模式和策略模式。

代理模式

代理模式原理

代理模式就是给某一个对象创建一个代理对象，而由这个代理对象控制对原对象的引用，而创建这个代理对象就是可以在调用原对象时增加一个额外的操作。下面是代理模式的结构：

• Subject：抽象主题，它是代理对象的真实对象要实现的接口，当然这可以由多个接口组成。
• ProxySubject：代理类除了实现抽象主题定义的接口外，还必须持有所代理对象的引用
• RealSubject：被代理的类，是目标对象

Spring中如何实现代理模式

Spring Aop中Jdk动态代理是利用代理模式技术实现的。在Spring中除了实现被代理对象的接口外，还会有org.springframework.aop.SpringProxy和org.springframework.aop.framework.Advised两个接口。Spring中使用代理模式的结构图如下：

$Proxy就是创建的代理对象，而Subject是抽象主题，代理对象是通过InvocationHandler来持有对目标对象的引用的。

Spring中一个真实的代理对象结构如下：

public class $Proxy4 extends java.lang.reflect.Proxy implements 
    org.springframework.aop.framework.PrototypeTargetTests$TestBean 
    org.springframework.aop.SpringProxy 
    org.springframework.aop.framework.Advised
{
    java.lang.reflect.Method m16;
    java.lang.reflect.Method m9;
    java.lang.reflect.Method m25;
    java.lang.reflect.Method m5;
    java.lang.reflect.Method m2;
    java.lang.reflect.Method m23;
    java.lang.reflect.Method m18;
    java.lang.reflect.Method m26;
    java.lang.reflect.Method m6;
    java.lang.reflect.Method m28;
    java.lang.reflect.Method m14;
    java.lang.reflect.Method m12;
    java.lang.reflect.Method m27;
    java.lang.reflect.Method m11;
    java.lang.reflect.Method m22;
    java.lang.reflect.Method m3;
    java.lang.reflect.Method m8;
    java.lang.reflect.Method m4;
    java.lang.reflect.Method m19;
    java.lang.reflect.Method m7;
    java.lang.reflect.Method m15;
    java.lang.reflect.Method m20;
    java.lang.reflect.Method m10;
    java.lang.reflect.Method m1;
    java.lang.reflect.Method m17;
    java.lang.reflect.Method m21;
    java.lang.reflect.Method m0;
    java.lang.reflect.Method m13;
    java.lang.reflect.Method m24;
 
    int hashCode();
    int indexOf(org.springframework.aop.Advisor);
    int indexOf(org.aopalliance.aop.Advice);
    boolean equals(java.lang.Object);
    java.lang.String toString();
    void sayhello();
    void doSomething();
    void doSomething2();
    java.lang.Class getProxiedInterfaces();
    java.lang.Class getTargetClass();
    boolean isProxyTargetClass();
    org.springframework.aop.Advisor; getAdvisors();
    void addAdvisor(int, org.springframework.aop.Advisor) 
        throws org.springframework.aop.framework.AopConfigException;
    void addAdvisor(org.springframework.aop.Advisor)
        throws org.springframework.aop.framework.AopConfigException;
    void setTargetSource(org.springframework.aop.TargetSource);
    org.springframework.aop.TargetSource getTargetSource();
    void setPreFiltered(boolean);
    boolean isPreFiltered();
    boolean isInterfaceProxied(java.lang.Class);
    boolean removeAdvisor(org.springframework.aop.Advisor);
    void removeAdvisor(int)throws org.springframework.aop.framework.AopConfigException;
    boolean replaceAdvisor(org.springframework.aop.Advisor, 
        org.springframework.aop.Advisor)
        throws org.springframework.aop.framework.AopConfigException;
    void addAdvice(org.aopalliance.aop.Advice) 
        throws org.springframework.aop.framework.AopConfigException;
    void addAdvice(int, org.aopalliance.aop.Advice) 
        throws org.springframework.aop.framework.AopConfigException;
    boolean removeAdvice(org.aopalliance.aop.Advice);
    java.lang.String toProxyConfigString();
    boolean isFrozen();
    void setExposeProxy(boolean);
    boolean isExposeProxy();
}

策略模式

策略模式原理

策略模式顾名思义就是做某事的策略，这在编程上通常是指完成某个操作可能有多种方法，这些方法各有千秋，可能有不同的适用场合。每一个操作方法都当做一个实现策略，使用者可能根据需要选择合适的策略。
下面是策略模式的结构

• Context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要完成的操作。
  它持有一个策略实例的引用。创建具体策略对象的方法也可以由它完成。
• Strategy：抽象策略，定义每个策略都要实现的策略方法。
• ConcreteStrategy：具体策略实现类，实现抽象策略中定义的策略方法

Spring中策略模式的实现

Spring中策略模式使用有多个地方，如Bean定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。
前面已经了解Spring的代理方式由两个，Jdk动态代理和CGLIB代理。这两个代理方式的使用正是使用了策略模式，它的结构图如下所示：

在上面结构图中与标准的策略模式结构稍微有点不同，这里抽象策略是AopProxy接口，Cglib2AopProxy和JdkDynamicAopProxy分别代表两种策略的实现方式，ProxyFactoryBean就是代表Context角色，它根据条件选择使用Jdk代理方式还是CGLIB方式，而另外三个类主要是来负责创建具体策略对象，ProxyFactoryBean是通过依赖的方法来关联具体策略对象的，它是通过调用策略对象的getProxy(ClassLoader classLoader)方法来完成操作。

结束语

本文通过从Spring的几个核心组件入手，试图找出构建Spring框架的骨骼架构，进而分析Spring在设计时的一些设计理念，是否从中找出一些好的设计思想，对我们以后程序设计能提供一些思路。接着在详细分析了Spring是如何实现这些理念的，以及在设计模式上是如何使用的。

通过分析Spring给我一个很大的启示就是这套设计理念其实对我们有很强的借鉴意义，它通过抽象复杂多变的对象，进一步做规范，然后根据它定义的这套规范设计出一个容器，容器中构建它们的复杂关系，其实现在有很多情况都可以用这种类似的处理方法。