约定编程Spring AOP-约定编程

本节我们完全抛开AOP的概念，先看一个约定编程的实例。当你弄明白实例之后，相信Spring AOP的概念也就十分容易理解了，实质上他们是异曲同工的东西。只是需要自己去实践，如果仅仅是看看，那么效果肯定差几个档次。

1. 约定

首先看一个简单到不需要解释的接口。

package cn.hctech2006.boot.bootaop.service;

public interface HelloService {
    public void sayHello(String name);
}

这个接口很简单，就是定义一个sayHello的方法，其中参数name就是名字，这样就对该名字说hello了，于是我们很快得到一个实现类。

package cn.hctech2006.boot.bootaop.service.impl;

import cn.hctech2006.boot.bootaop.service.HelloService;

public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        if (name == null || name .trim() == ""){
            throw new RuntimeException("parameter is null !!");
        }
        System.out.println("hello "+name);
    }
}

好了，这里的代码也很简单，syaHello方法首先判断name是否为空，如果为空，则抛出异常，告诉调用者参数为空，如果不为空，则对改名字说hello。
这样一个几乎就是最简单的服务写好了。下面先来定义一个拦截器接口，他十分简单，只存在几个方法。

package cn.hctech2006.boot.bootaop.intercept;

/**
 * 拦截器接口
 */
public interface Interceptor {
    /**
     * 事前方法
     * @return
     */
    public boolean before();

    /**
     * 事后方法
     */
    public void after();

    /**
     * 取代原有事件方法
     * @param invocation　回调参数，可以通过他的proceed方法，回调原有事件。         
     * @return　原有事件返回对象
     * @throws java.lang.reflect.InvocationTargetException
     * @throws IllegalAccessException
     */
    public Object around(Invocation invocation);

    /**
     * 是否返回方法，事后没有异常执行
     */
    public void afterReturning();

    /**
     * 事后异常方法，事情发生异常执行。
     */
    public void afterThrowing();

    /**
     * 是否使用around方法取代原有方法
     * @return
     */
    boolean useAround();
}

这些方法后面会给出约定，将这些方法织入流程中。这里我们首先给出around方法中的参数Invocation对象的源码

package cn.hctech2006.boot.bootaop.invoke;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Invocation {
    private Object[] params;
    private Method method;
    private Object target;

    /**
     * 构造函数
     * @param params　参数
     * @param method　方法
     * @param target　对象
     */
    public Invocation(Object[] params, Method method, Object target) {
        this.params = params;
        this.method = method;
        this.target = target;
    }
    //反射方法
    public Object proceed() throws InvocationTargetException, IllegalAccessException{
        return method.invoke(target,params);
    }
}

他没有太多可以探讨的内容，唯一值得探讨的就是proceed方法，他会以反射的形式去调用原有的方法。
接着你可以根据拦截器（Interceptor）接口的定义开发一个属于你自己的拦截器MyInterceptor。

package cn.hctech2006.boot.bootaop.intercept;

import cn.hctech2006.boot.bootaop.invoke.Invocation;

import java.lang.reflect.InvocationTargetException;

/**
 * 开发自己的拦截器
 */
public class MyInterceptor implements Interceptor {

    @Override
    public boolean before() {
        System.out.println("before .....");
        return true;
    }

    @Override
    public void after() {
        System.out.println("after .....");
    }

    @Override
    public Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException {
        System.out.println("around before ....");
        Object obj = invocation.proceed();
        System.out.println("around after .....");
        return obj;
    }

    @Override
    public void afterReturning() {
        System.out.println("after running .....");
    }

    @Override
    public void afterThrowing() {
        System.out.println("after throwing .....");
    }

    @Override
    public boolean useAround() {
        return true;
    }
}

这个拦截器的功能并不复杂，接下来就要谈谈我和你的约定了。约定是本节的核心，也是Spring AOP的本质。我们先提供一个类－ProxyBean给读者使用，他又一个静态的static方法：

public static Object getProxyBean(Object target, Interceptor interceptor)

这个方法说明如下：

• 要求参数target对象存在接口，而interceptor对象则是上述定义的接口对象。
• 那么他将返回一个对象，我们把返回的对象即为proxy，你可以使用target对象实现的接口类型对他进行强制转换。
  于是你就可以使用它拿到proxy了，代码如下

HelloService helloService = new HelloServiceImpl();
HelloService proxy = (HelloService) proxxyBean.getProxyBean(helloService, new MyInterceptor());

然后我们在提供一下约定，请注意，这个约定十分重要
当调用proxy对象的方法时，其执行流程如下。
(1)使用proxy调用方法时会执行拦截器的before方法，
(2) 如果拦截器的useAround方法返回true，则执行拦截器的around方法，而不调用原有对象对应的方法，但是around方法的参数invocation对象存在一个proceed方法，它可以调用target对象对应的方法。如果useAround方法返回false，则直接调用target对象的事件方法。
(3)无论如何，在完成之前的事件之后，都会执行拦截器的after方法。
(4)在执行around方法或者回调target方法时，可能会发生异常，也可能不发生异常。如果发生异常，就执行拦截器的fterThrowing方法，否则就执行afterReturning方法。
下面我们再用图示的流程图来展示这个约定流程，这样会更加清晰一些。

有了这个流程图，就可以进行约定编程了。例如，一下所示的测试约定流程。

public class TestProxyAA {
    public static void testProxy(){
        HelloService helloService = new HelloServiceImpl();
        HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService,new MyInterceptor());
    }
}

按照我们的约定，打印信息如下：
可以看到，我们把服务和拦截器的方法已经织入约定的流程中了。那么是怎么实现把服务和拦截器的方法织入到约定的流程中的呢？那就是ProxyBean的内容了，下面我们来讨论一下他。

2. ProxyBean的实现

如何将服务和拦截方法织入对应的流程，是ProxyBean要实现的功能。首先要理解动态代理模式。其实代理很简单，例如，当你想要采访一位儿童的时候，首先需要经过他父母的同意，在一些问题上父母也许会替他回答，而在另一些问题上也许父母ｊｕｄｅ不太适合这个小孩会拒绝掉，显然父母就是这位儿童的代理（proxy）了。通过代理，可以增强或者控制儿童这个真是对象（target）的访问。如图

也就是需要一个代理对象。在JDK中，提供了类Proxy的静态方法－newProxyInstance，其内容具体如下:

public static Object newProxyInstance(ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler invocationHandler)throws IllegalArgumentException

给予我们来生成一个代理对象（proxy），他又三个参数：

• classLoader－类加载器
• interfaces－绑定的接口，也就是把代理对象绑定到那些接口之下，可以是多个。
• invocationHandler－绑定代理对象逻辑实现。
  这里的invocationHandler是一个接口InvocationHandler对象，他定义一个invoke方法，这个方法就是实现代理对象逻辑的，其具体代码如下。

/**
     * 处理代理对象方法逻辑
     * @param proxy 代理对象
     * @param method　当前方法
     * @param args　运行参数
     * @return　方法调用结果
     */
    public Object invoke(Object proxy, Method method, Object [] args);

然后通过目标对象（target），方法（method）和参数（args）就可以反射方法运行了，于是我们可以实现ProxyBean的源码如下：

package cn.hctech2006.boot.bootaop.proxy;

import cn.hctech2006.boot.bootaop.intercept.Interceptor;
import cn.hctech2006.boot.bootaop.invoke.Invocation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 实现ProxyBean
 */
public class ProxyBean implements InvocationHandler {
    private Object target = null;
    private Interceptor interceptor = null;

    /**
     * 绑定代理对象
     * @param target　被代理对象
     * @param interceptor　拦截器
     * @return　代理对象
     */
    public static Object getProxyBean(Object target, Interceptor interceptor){
        ProxyBean proxyBean = new ProxyBean();
        //保存被代理对象
        proxyBean.target=target;
        //保存拦截器
        proxyBean.interceptor=interceptor;
        //生成代理对象
        Object proxy = Proxy.newProxyInstance
                (target.getClass().getClassLoader(),
                        target.getClass().getInterfaces(),
                        proxyBean);
        //返回代理对象
        return proxy;


    }

    /**
     * 处理代理对象逻辑
     * @param proxy　代理对象
     * @param method　当前方法
     * @param args　运行参数
     * @return　方法调用结果
     * @throws Throwable　异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        boolean exceptionFlag=false;
        Invocation invocation = new Invocation(target,method, args);
        Object retObj = null;
        try{
            if(this.interceptor.before()){
                retObj=this.interceptor.around(invocation);
            }else{
                retObj=method.invoke(target,args);
            }
        }catch (Exception ex){
            exceptionFlag=true;
        }
        this.interceptor.after();
        if (exceptionFlag){
            this.interceptor.afterThrowing();
        }else{
            this.interceptor.afterReturning();
            return retObj;
        }

        return null;
    }
}

首先这个ProxyBean实现了接口InvocationHandler，因此就可以定义invoke方法了。其次在getBean方法中，我们让其生成一个代理对象，并且创建了一个ProxyBean实例保存目标对象（target）和拦截器（inteceptor）。为后面的调用做好了准备。其次生成了一个代理对象，而这个代理对象挂载在target实现的接口之下，所以你可以用target对象实现的接口对这个代理对象实现强制转换，并且将这个代理对象的逻辑挂载在ProxyBean实例之下，这样就可以完成目标对象（target）和代理对象（Proxy）的绑定。最后，将代理对象返回给调用者。于是我们只需要一下两句代码：

 HelloService helloService = new HelloServiceImpl();
        //按照约定获取proxy
        HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService,new MyInterceptor());

就可以获取这个代理对象了，当我们使用他来调用方法时，就会进入到ProxyBean的invoke方法里，而这个invoke方法就是按照就是按照上图所约定的流程实现的，这就是我们可以通过一定的规则完成约定编程的原因。动态代理的概念比较抽象，掌握不易，这里建议对invoke方法进行调试，一步步印证他的运行过程。编程是门实践学科，通过自己动手会有更加深入的理解，一下就是调试的记录。

结果

before .....
around before ....
hello 李登印
around after .....
after .....
after running .....

3. 总结
   到目前为之，我们并没有讲述AOP的概念，本节只是通过约定告诉大家，只要提供一定的约定规则，按照约定编程，就可以把自己开发的代码织入约定的流程中。而实际上在开发中，你只需要知道框架和你的约定就可以了。在现实中很多框架也是这么做的，换句话说，Spring　AOP也是这么做的，它可以通过与我们的约定，把对应的方法通过动态代理的技术织入约定的流程中，这就是Spring AOP编程的本质。所以掌握Spring AOP的根本在于其对我们的约定规则，下面的部分让我们来学习他们。