1.约定编程

约定编程

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

约定

• 首先来看一个简单不需要去解释的接口，如下代码

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

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

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

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

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

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

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

    /**
     * 是否返回方法。事件没有发生异常执行
     */
    public void afterReturning();

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

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

• 这个接口的定义我也是设计了一番的，后面会给出约定，将这些方法织入流程中。这里我们首先给出around方法中的参数Invocation对象的源码，如下代码

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

    public Invocation(Object target, Method method, Object[] params) {
        this.target = target;
        this.method = method;
        this.params = params;
    }

    /**
     * 反射方法
     *
     * @return
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, params);
    }
}

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

public class MyInterceptor implements Interceptor {
    @Override
    public boolean before() {
        System.out.println("before....");
        return false;
    }

    @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("afterReturning....");
    }

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

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

• 这个拦截器的功能也不复杂，接着就要谈谈我和你的约定了。约定是本节的核心，也是Spring AOP的本质。我先提供一个类——ProxyBean给读者使用，它有一个静态的（static）方法：
  • public static Object getProxyBean(Object target, Interceptor interceptor)：
• 这个方法的说明如下：
  • 要求参数target对象存在接口，而interceptor对象则是代码HelloService的接口对象；
  • 那么它将返回一个对象，我们把这个返回的对象记为proxy，你可以使用target对象实现的接口类型对它进行强制转换。
• 于是你就可以使用它拿到proxy了，例如，下面的代码：

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

• 然后我再提供下面的约定。请注意，这个约定是十分重要的。
• 当调用proxy对象的方法时，其执行流程如下。
  • 1）使用proxy调用方法时会先中
  • 2）如果拦截器的useAround方法返回true，则执行拦截器的around方法，而不调用target对象对应的方法，但around方法的参数invocation对象存在一个proceed方法，它可以调用target对象对应的方法；
  • 3）无论怎么样，在完成之前的事情后，都会执行拦截器的after方法；
  • 4）在执行around方法或者回调target的事件方法时，可能发生异常，也可能不发生异常，也可能不发生异常。如果发生异常，就执行拦截器的afterThrowing方法，否则就执行afterReturning方法。

• 下面我们再用流程图来展示这个约定流程

  
  image
• 有了这个流程图，就可以进行约定编程了。如下代码测试约定流程。

public class testProxy {
    public static void main(String[] args) {
        HelloService helloService = new HelloServiceImpl();
        HelloService proxy = (HelloService) ProxyBean.getProxyBean(helloService, new MyInterceptor());
        proxy.sayHello("zhangsan");
        System.out.println("########### name is null! ###########");
        proxy.sayHello(null);
    }
}

• 按照我们的约定，这段代码打印的信息如下：

before....
around before....
hello zhangsan
around after....
after....
afterReturning....
########### name is null! ###########
before....
around before....
after....
afterThrowing....

ProxyBean的实现

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

  
  image
• 也就是需要一个代理对象。在JDK中，提供了类Proxy的静态方法——newProxyInstance，其内容具体如下：
  • public static Object newProxyinstance (ClassLoader classLoader, Class<?>[] interfaces, InvocationHandler invocationHandler) throws IllegalArguπ1entException
• 给予我们来生成一个代理对象（proxy），它有3个参数：
  • classLoader——类加载器；
  • interface——绑定的接口，也就是把代理对象绑定到哪些接口下，可以是多个；
  • invocationHandler——绑定代理对象逻辑实现。
• 这里的invocationHandler是一个接口InvocationHandler对象，它定义了一个invoke方法，这个方法就是实现代理对象的逻辑的，其定义代码如下

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

• 然后通过目标对象（target），方法（method）和参数（args）就能够反射方法运行了，于是我们可以实现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 null;
    }
}

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

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

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

总结

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