spring 理解Spring AOP 一个简单的约定游戏

　　应该说AOP原理是Spring技术中最难理解的一个部分，而这个约定游戏也许会给你不少的帮助，经过这个约定游戏，就能够理解Spring AOP的含义和实现方法，也能帮助读者更好地运用Spring AOP到实际的编程当中，这对于正确理解Spring AOP是十分重要的

约定规则

　　代码清单：定义Interceptor接口

package com.ssm.chapter11.game;

public interface Interceptor {

    public void before(Object obj);

    public void after(Object obj);

    public void afterReturning(Object obj);

    public void afterThrowing(Object obj);

}

 

　　这里是一个拦截接口，能够对它建立实现类。若是使用过Spring AOP，你就会发现笔者的定义和Spring AOP定义的消息是如此相近。

　　代码清单：ProxyBeanFactory的getBean方法

package com.ssm.chapter11.game;

public class ProxyBeanFactory {
    public static <T> T getBean(T obj, Interceptor interceptor) {
        return (T) ProxyBeanUtil.getBean(obj, interceptor);
    }
}

　　具体类ProxyBeanUtil的getBean方法的逻辑不须要去理会，由于这是笔者须要去完成的内容。可是做为读者，你要知道当使用了这个方法后，存在以下约定

　　当一个对象经过ProxyBeanFactory的getBean方法定义后，拥有这样的约定。
　　（1）Bean必须是一个实现了某一个接口的对象。
　　（2）最早会执行拦截器的before方法。
　　（3）其次执行Bean的方法（经过反射的形式）。
　　（4）执行Bean方法时，不管是否产生异常，都会执行after方法。
　　（5）执行Bean方法时，若是不产生异常，则执行afterReturning方法；若是产生异常，则执行afterThrowing方法。
　　这个约定实际已经十分接近Spring AOP对咱们的约定，因此这个约定十分重要，其流程如图所示。

 

读者的代码

　　上面笔者给出了接口和获取Bean的方式，同时也给出了具体的约定，这个时候读者能够根据约定编写代码，好比打印一个角色信息。
　　代码清单：RoleService接口

package com.ssm.chapter11.game.service;

import com.ssm.chapter11.game.pojo.Role;

public interface RoleService {
    public void printRole(Role role);
}

 

　　代码清单：RoleServiceImpl

package com.ssm.chapter11.game.service.impl;

import com.ssm.chapter11.game.pojo.Role;
import com.ssm.chapter11.game.service.RoleService;

public class RoleServiceImpl implements RoleService {

    // @Override
    public void printRole(Role role) {
        System.out.println("{id =" + role.getId() + ", roleName=" + role.getRoleName() + ", note=" + role.getNote() + "}");
    }

}

 

　　代码清单：角色拦截器RoleInterceptor

package com.ssm.chapter11.game.interceptor;

import com.ssm.chapter11.game.Interceptor;

public class RoleInterceptor implements Interceptor {

    // @Override
    public void before(Object obj) {
        System.out.println("--before-准备打印角色信息");
    }

    // @Override
    public void after(Object obj) {
        System.out.println("-after-已经完成角色信息的打印处理");
    }

    // @Override
    public void afterReturning(Object obj) {
        System.out.println("-afterReturning-刚刚完成打印功能，一切正常。");
    }

    // @Override
    public void afterThrowing(Object obj) {
        System.out.println("-afterThrowing-打印功能执行异常了，查看一下角色对象为空了吗？");
    }

}

 

　　它编写了图中描述流程的各个方法，这个时候你能够清楚地知道代码将按照流程图的流程执行。注意，你并不须要知道笔者如何实现，你只须要知道咱们之间的约定便可
　　代码清单：测试约定流程

package com.ssm.chapter11.game.main;

import com.ssm.chapter11.game.Interceptor;
import com.ssm.chapter11.game.ProxyBeanFactory;
import com.ssm.chapter11.game.interceptor.RoleInterceptor;

import com.ssm.chapter11.game.pojo.Role;
import com.ssm.chapter11.game.service.RoleService;
import com.ssm.chapter11.game.service.impl.RoleServiceImpl;

public class GameMain {

    public static void main(String[] args) {
        RoleService roleService = new RoleServiceImpl();
        Interceptor interceptor = new RoleInterceptor();
        RoleService proxy = ProxyBeanFactory.getBean(roleService, interceptor);
        Role role = new Role(1L, "role_name_1", "role_note_1");
        proxy.printRole(role);
        System.out.println("############## 测试 afterthrowing方法###############");
        role = null;
        proxy.printRole(role);
    }

}

 

笔者的代码

　　上面的代码都基于动态代理模式。
　　下面展现经过JDK动态代理实现上述流程的代码，如代码清单所示。
　　代码清单：使用动态代理实现流程

package com.ssm.chapter11.game;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class ProxyBeanUtil implements InvocationHandler {

    //被代理对象
    private Object obj;
    // 拦截器
    private Interceptor interceptor = null;

    /**
     * 获取动态代理对象.
     *
     * @param obj         被代理对象
     * @param interceptor 拦截器
     * @param aroundFlag  是否启用around方法
     * @return 动态代理对象
     */
    public static Object getBean(Object obj, Interceptor interceptor) {
        //使用当前类，做为代理方法，此时被代理对象执行方法的时候，会进入当前类的invoke方法里
        ProxyBeanUtil _this = new ProxyBeanUtil();
        //保存被代理对象
        _this.obj = obj;
        //保存拦截器
        _this.interceptor = interceptor;
        //生成代理对象，并绑定代理方法
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), _this);
    }

    /**
     * 代理方法
     *
     * @param proxy  代理对象
     * @param method 当前调度方法
     * @param args   参数
     * @return 方法返回
     * @throws Throwable 异常
     */
    // @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object retObj = null;
        //是否产生异常
        boolean exceptionFlag = false;
        //before方法
        interceptor.before(obj);
        try {
            //反射原有方法
            retObj = method.invoke(obj, args);
        } catch (Exception ex) {
            exceptionFlag = true;
        } finally {
            //after方法
            interceptor.after(obj);
        }
        if (exceptionFlag) {
            //afterThrowing方法
            interceptor.afterThrowing(obj);
        } else {
            //afterReturning方法
            interceptor.afterReturning(obj);
        }
        return retObj;
    }
}

 

　　上面的代码使用了动态代理，因为这段代码的重要性，这里有必要讨论其实现过程。
　　首先，经过getBean方法保存了被代理对象、拦截器（inter-ceptor）和参数（args），为以后的调用奠基了基础。而后，生成了JDK动态代理对象（proxy），同时绑定了ProxyBeanUtil的一个实例做为其代理类，这样当代理对象调用方法的时候，就会进入到ProxyBeanUtil实例的invoke方法中，因而焦点又到了invoke方法上。
　　在invoke方法中，笔者将拦截器的方法按照流程图实现了一遍，其中设置了异常标志（exceptionFlag），经过这个标志就能判断反射原有对象方法的时候是否发生了异常，这就是读者的代码可以按照流程打印的缘由。可是，因为动态代理和反射的代码会比较抽象，更多的时候大部分的框架只会告诉你流程图和具体的流程方法的配置，就像笔者以前只是给出约定而已，相信有心的读者已经明白这句话的意思了，这就是说Spring框架也是这样作的。