学习AOP之认识一下Spring AOP

心碎之事

要说知道AOP这个词倒是很久很久以前了，但是直到今天我也不敢说非常的理解它，其中的各种概念即抽象又太拗口。
在几次面试中都被问及AOP，但是真的没有答上来，或者都在面上，这给面试官的感觉就是java基础不行。可见这还是挺重要的一个概念。

在看工作中也遇到了相关的问题，在RPC的一种实现机制里应用了AOP，结果各种类一直绕来绕去看着头都大了，这也就是没有对动态代理和aop有了解导致的。

所以要好好的去掌握它，否则吃亏的还是自己。

先从概念开始

面向侧面的程序设计（aspect-oriented programming，AOP，又译作面向方面的程序设计、观点导向编程、剖面导向程序设计）是计算机科学中的一个术语，指一种程序设计范型。该范型以一种称为侧面（aspect，又译作方面）的语言构造为基础，侧面是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。——维基百科

不知道看完这段话你能理解AOP是个啥吗？并不能，最多知道AOP是一种规范。所以说要理解AOP最重要还是要从具体的实现入手，才能真正明白AOP到底是干啥子的。

那么AOP的核心是什么？

其实就是一种代码增强方式，可以实现动态的代理，在运行期完成；也有一些是静态的为对象增强，在编绎期间完成。说的白话一点就是在对象进行代码上的扩展增强，就是说原先可能只能跑10行代码，增强后就可以多跑些代码，而且这种增强是通过织入的方式完成，而不是直接修改目标对象的代码。

为此还是要先理解代理这个概念，可以更好的理解AOP，那么就从学习代理开始吧。

写个静态代理例子

//创建一个接口public interface ISay {    void say();}//接口的实现类（可以理解为业务类）public class SayImpl implements ISay{    @Override    public void say() {        System.out.print("我是5207.");    }}//只说一个名字太单调了，需要多多拉票，创建一个代理类来增强一下class StaticSayImplProxy implements ISay {    private ISay target;    public StaticSayImplProxy(ISay target) {        this.target = target;    }    @Override    public void say() {        SayHello();        this.target.say();        ThumbUp();    }    void SayHello() {        System.out.print("大家好:");    }    void ThumbUp() {        System.out.print("希望大家多多点赞.");    }}//调用代码public class StaticProxy {    public static void main(String[] args) {        ISay aop = new SayImpl();        ISay aopProxy = new StaticSayImplProxy(aop);        aopProxy.say();    }}

代码很简单，静态代理代码中通过增加一个StaticSayImplProxy类来对原先的实现类进行增强。注意这里的增强很重要。也就是原本只会说一句“我是5207.”，通过代理的类后就完整了许多。

但是静态代理的缺点是，代理时必须知道其类型是，比如上面代码中就必须知道ISay这个接口，最终才能在代理类里才能调用：this.target.say()这样的代码。那么也就是说如果还有另外的IOtherSay接口也需要用这个代理类就没法使用了。

所以如果能把代理集中一个类中，只要将要代理的对象给这个类就能代理是不是比较方便，代码少写好多。

整成动态代理

办法当然是有的，JDK提供了一种动态代理的技术，可以动态的为接口创建代理对象，从而实现代理模式。那么接着上面的例子我们需要做成动态代理代码如下：

class DynamicProxyImpl implements InvocationHandler {    private Object target;    public DynamicProxyImpl(Object target) {        this.target = target;    }    @SuppressWarnings("unchecked")    public <T> T getObject() {        return (T) Proxy.newProxyInstance(                target.getClass().getClassLoader(),                target.getClass().getInterfaces(),                this            );    }    @Override    public Object invoke(Object proxy, Method method, Object[] args)            throws Throwable {        SayHello();        Object result = method.invoke(target, args);        ThumbUp();        return result;    }    void SayHello() {        System.out.print("大家好:");    }    void ThumbUp() {        System.out.println("希望大家多多点赞.");    }}

这里可以发现DynamicProxyImpl类并没有指定具体代理的接口类型，而使用Object类型。这样就不用关心传入给这个代理类的具体对象了。所以说这个代理类的范围一下子就大了许多，只要是类似的增强功能都可以用这个代理类来完成。举个例子：

public interface IOtherSay {    void applause();}public class OtherSayImpl implements IOtherSay {    @Override    public void applause() {        System.out.print("大家鼓掌.");    }}public static void main(String[] args) {    IOtherSay oSay = new OtherSayImpl();    DynamicProxyImpl oSayProxy = new DynamicProxyImpl(oSay);    IOtherSay oSay2 = oSayProxy.getObject();    oSay2.applause();}

可以看到使用同一个代理类也可以代理IOtherSay接口派生的对象啦。

InvocationHandler接口
另外一点就是DynamicProxyImpl实现了InvocationHandler接口，这个接口是关键，其实应当是JDK代理对象时的一个调用处理程序，这应当是暴露给开发者的代码增强接口啦。InvocationHandler接口只有一个invoke方法，我们需要做的就是在这个方法中增加需要的增强代码。

Proxy工具类
对于getObject方法才是真正的代理对象生成的过程，可以看到最终是Proxy.newProxyInstance这个方法来完成代理对象生成并返回的。那么这里可以看看Proxy的设计与原理。

因为暂时只用到了newProxyInstance方法，就从它开始吧：

@CallerSensitivepublic static Object newProxyInstance(ClassLoader loader,                                      Class<?>[] interfaces,                                      InvocationHandler h)    throws IllegalArgumentException{    Objects.requireNonNull(h);    final Class<?>[] intfs = interfaces.clone();    final SecurityManager sm = System.getSecurityManager();    if (sm != null) {        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);    }    /*     * Look up or generate the designated proxy class.     */    Class<?> cl = getProxyClass0(loader, intfs);    /*     * Invoke its constructor with the designated invocation handler.     */    try {        if (sm != null) {            checkNewProxyPermission(Reflection.getCallerClass(), cl);        }        final Constructor<?> cons = cl.getConstructor(constructorParams);        final InvocationHandler ih = h;        if (!Modifier.isPublic(cl.getModifiers())) {            AccessController.doPrivileged(new PrivilegedAction<Void>() {                public Void run() {                    cons.setAccessible(true);                    return null;                }            });        }        return cons.newInstance(new Object[]{h});    } catch (IllegalAccessException|InstantiationException e) {        throw new InternalError(e.toString(), e);    } catch (InvocationTargetException e) {        Throwable t = e.getCause();        if (t instanceof RuntimeException) {            throw (RuntimeException) t;        } else {            throw new InternalError(t.toString(), t);        }    } catch (NoSuchMethodException e) {        throw new InternalError(e.toString(), e);    }}

方法的三个参数中要注意interfaces和h
- interfaces
是指的传入需要代理的接口列表，==这里有一点比较重要JDK的动态代理只能代理接口哦==。

• h
  另外一个h则是指调用处理程序，发现在上面的DynamicProxyImpl类就是一个调用处理程序的实现，这里的关键就是InvocationHandler。

接着看方法体中的代码主要是几个过程：
1. 获取/创建代理类Class：Class

Spring中的AOP

了解了代理后再来看AOP的相关概念还是理解不了，什么切面、连接点、通知、切入点之类的，所以说还是抛开吧，这样要轻松许多。相信大家看aop的时候肯定是看到了Advice这个东东吧？嗯，就从它入手吧。

在Spring中Advice下面这些类型：
- Before Advice：在目标方法被调用前调用，涉及接口org.springframework.aop.MethodBeforeAdvice
- After Advice：在目标方法被调用后调用，涉及接口为org.springframework.aop.AfterReturningAdvice
- Throws Advice：目标方法抛出异常时调用，涉及接口org.springframework.aop.ThrowsAdvice
- Around Advice：拦截对目标对象方法调用，涉及接口为org.aopalliance.intercept.MethodInterceptor
- Introduction Advice：为拦截的目标增加方法，涉及的接口为org.springframework.aop.support.DelegatingIntroductionInterceptor

嗯，都是些啥意思？Berfore Advice可以理解为SayHello方法，那么ThumbUp就是After Advice，两个加一起就是Around Advice。对于Throws Advice是针对异常抛出时的增强。最后还有一个比较牛的就是Introduction Advice则是可以对即有的对象进行增加方法，这个貌似更强大点。

从这些描述可以总结出来和前面动态代理时有异曲同工之处，在Spring中其实就是利用了动态代理的技术，结合AOP的概念对代码提供了一种更友好的扩展方式。当然也可以说换了一个角度来理解代码。举个例子说，希望在现有系统中监控所有action的执行时间，就可以拦截所有的action，加一个Before Advice记录一下进入的时间，再加一个After Advice计算一下完成的时间。这样就不会对现有action代码做什么修改，非常优雅啊，这对于系统设计时会有非常有用。

进一步理解Spring AOP

为了能够更深入的理解Spring AOP，还是需要更深入的去阅读源代码。这里再以DynamicProxyImpl为例子，如果使用Spring如何实现它的功能呢？以Spring xml配置方式试一下吧。

• 首先实现用于增强SayImpl的代码，这里使用环绕增强，和前面DynamicProxyImpl的效果一致。

package aop.demo;import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;public class SayImplAroundAdvice implements MethodInterceptor{    public Object invoke(MethodInvocation invocation) throws Throwable {        SayHello();        Object result = invocation.proceed();        ThumbUp();        return result;    }    void SayHello() {        System.out.print("大家好:");    }    void ThumbUp() {        System.out.println("希望大家多多点赞.");    }}

• 使用Spring的配置文件声明对象和AOP代理,spring.xml如下：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans       http://www.springframework.org/schema/beans/spring-beans.xsd       http://www.springframework.org/schema/context       http://www.springframework.org/schema/context/spring-context.xsd">    <!-- 声明被代理的目标对象 -->    <bean id="sayImpl" class="aop.demo.SayImpl"></bean>    <!-- 声明用于增强的拦截器对象 -->    <bean id="sayImplAroundAdvice" class="aop.demo.SayImplAroundAdvice"></bean>    <!-- 声明代理对象 -->    <bean id="sayProxy" class="org.springframework.aop.framework.ProxyFactoryBean">        <property name="interfaces" value="aop.demo.ISay"/>            <!-- 这个就是被代理的接口 -->        <property name="target" ref="sayImpl"/>                        <!-- 这个就是被代理的对象 -->        <property name="interceptorNames" value="sayImplAroundAdvice"/><!-- 这个就是代理的增强器 -->     </bean></beans>

• 实现代理的访问

package aop.demo;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Client {    @SuppressWarnings("resource")    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("aop/demo/spring.xml");        ISay say = (ISay)context.getBean("sayProxy");        say.say();    }}

最后执行一下程序输出的结果是：

大家好:我是5207.希望大家多多点赞.

哎呀呀和前面的动态代理一致，效果达成。^_^

当然也可以通过代码方式完成上面的功能

package aop.demo;import org.springframework.aop.framework.ProxyFactory;public class ClientCode {    public static void main(String[] args) {        ProxyFactory proxyFactory = new ProxyFactory();     // 创建代理工厂        proxyFactory.setTarget(new SayImpl());         // 射入目标类对象        proxyFactory.addAdvice(new SayImplAroundAdvice());        ISay say = (ISay) proxyFactory.getProxy();        say.say();    }}

总结

写了一天才写到这里，只不过还是值得的。原来一直以为AOP就是动态代理，没想到自己错了，AOP是一种规范，而动态代理只是实现AOP的一种方式而已。

接下来继续研究spring aop，进一步学习ProxyFactoryBean和ProxyFactory。

引用与参考

AOP 那点事儿
Java之美[从菜鸟到高手演练]之JDK动态代理的实现及原理
JDK动态代理实现原理
Spring AOP代理详解

注：此文章为原创，欢迎转载，请在文章页面明显位置给出此文链接！
若您觉得这篇文章还不错请点击下右下角的推荐，非常感谢！
http://blog.csdn.net/5207