Spring AOP（一） —— 手动实现

1 前言

Spring 中使用了 jdk 代理 跟 CGLIB 代理 实现 AOP 编程，我们将使用 jdk 代理一个简单的例子概述 Spring AOP 遵循的约定编程。

2 手动实现

2.1  service 接口与实现（被代理类）

/**
 * @author pancc
 * @version 0.0.1
 */
public interface HelloService {
    void sayHello(String name);
}

 

/**
 * @author pancc
 * @version 0.0.1
 */
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        if (Objects.isNull(name) || name.isEmpty()) {
            throw new IllegalArgumentException();
        }
        System.out.printf("hello , %s
", name);
    }
}

2.2 Interceptor 接口与实现

其中的 Invocation 是 2.3 中的。

/**
 * The interface Interceptor.
 *
 * @author pancc
 * @version 1.0
 */
public interface Interceptor {

    /**
     * 事前方法
     *
     */
    void before();

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

    /**
     * 取代原有事件方法
     *
     * @param invocation 回调参数，通过他的 proceed 方法回调原有方法
     * @return 原有事件返回对象 object
     * @throws InvocationTargetException the invocation target exception
     * @throws IllegalAccessException    the illegal access exception
     */
    Object around(Invocation invocation) throws InvocationTargetException, IllegalAccessException;

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

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

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

/**
 * @author pancc
 * @version 0.0.1
 */
public class MyInterceptorImpl implements Interceptor {
    @Override
    public void before() {
        System.out.println("before ......");
    }

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

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

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

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

    }

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

2.3 Invocation 类

proceed 方法通过反射调用原有的方法。

/**
 * @author pancc
 * @version 0.0.1
 */
@AllArgsConstructor
public class Invocation {

    private Object[] params;

    private Method method;

    private Object target;

    /**
     * Proceed object.
     *
     * @return the object
     * @throws InvocationTargetException the invocation target exception
     * @throws IllegalAccessException    the illegal access exception
     */
    public Object proceed() throws InvocationTargetException, IllegalAccessException {
        return method.invoke(target, params);
    }
}

2.4 ProxyBean

按照 aop 的设计本质，我们将编写一个工具类，我们向这个工具类的方法 getProxyBean() 传入需要被代理的实例（service），与代理事件（Interceptor），并通过 jdk 代理获得一个被代理的对象 (特点在debug 视图以 $Proxy0 开始)。我们使用 jdk 代理，我们还需要实现 InvocationHandler 接口。

/**
 * The type Proxy bean.
 *
 * @author pancc
 * @version 0.0.1
 */
public class ProxyBean implements InvocationHandler {

    private Object target;
    private Interceptor interceptor;

    /**
     * Gets proxy bean.
     *
     * @param target      the target
     * @param interceptor the interceptor
     * @return the proxy bean
     */
    public static Object getProxyBean(Object target, Interceptor interceptor) {

        ProxyBean proxyBean = new ProxyBean();
        proxyBean.target = target;
        proxyBean.interceptor = interceptor;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), proxyBean);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        boolean e = false;
        Object ret = null;
        Invocation invocation = new Invocation(args, method, target);
        interceptor.before();
        try {
            if (interceptor.useAround()) {
                ret = interceptor.around(invocation);
            } else {
                ret = method.invoke(target, args);
            }
        } catch (InvocationTargetException | IllegalAccessException | IllegalArgumentException ex) {
            e = true;
        }
        interceptor.after();
        if (e) {
            interceptor.afterThrowing();
        } else {
            interceptor.afterReturning();
            return ret;
        }
        return null;
    }
}

3 工作视图

上述的代码工作流程十分简单：

 根据上述的描述我们可以写出下边的测试代码：

/**
 * @author pancc
 * @version 0.0.1
 */
public class PreTest {
    public static void main(String[] args) {
        HelloService service = new HelloServiceImpl();

        HelloService proxy = (HelloService) ProxyBean.getProxyBean(service, new MyInterceptorImpl());
        proxy.sayHello("pen");
    }
}

并且得到如下结果：