Spring深入理解（三）

Spring 中 AOP 特性详解

动态代理的实现原理

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

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

图 16. 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 如何产生代理类的过程，他构造出来的代理类到底是什么样子？下面揭晓啦。

图 17. 创建代理对象时序图

其实从上图中可以发现正在构造代理类的是在 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 参数。整个代理就是这样实现的。

Spring AOP 如何实现

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

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

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

图 18. Jdk 动态代理的类图

上图清楚的显示了 Spring 引用了 Aop Alliance 定义的接口。姑且不讨论 Spring 如何扩展 Aop Alliance，先看看 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 的系统架构与模式设计分析》已经有介绍，这里就不赘述了。这里主要介绍代理模式和策略模式。

代理模式

代理模式原理

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

图 21. 代理模式的结构

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

Spring 中如何实现代理模式

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

图 22. Spring 中使用代理模式的结构图

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

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

清单 10 代理对象 $Proxy4

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();

}

策略模式

策略模式原理

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

下面是策略模式的结构：

图 23. 策略模式的结构

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

Spring 中策略模式的实现

Spring 中策略模式使用有多个地方，如 Bean 定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。

前面已经了解 Spring 的代理方式有两个 Jdk 动态代理和 CGLIB 代理。这两个代理方式的使用正是使用了策略模式。它的结构图如下所示：

图 24. Spring 中策略模式结构图

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

总结

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

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

虽然我很想把我对 Spring 的理解完全阐述清楚，但是所谓“书不尽言，言不尽意。”，有什么不对或者不清楚的地方大家还是看看其源码吧。

转载自：https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/