Spring学习-- AOP入门动态代理

 AOP 的拦截功能是由 java 中的动态代理来实现的。说白了，就是在目标类的基础上增加切面逻辑，生成增强的目标类（该切面逻辑或者在目标类函数执行之前，或者目标类函数执行之后，或者在目标类函数抛出异常时候执行。不同的切入时机对应不同的Interceptor的种类，如BeforeAdviseInterceptor，AfterAdviseInterceptor以及ThrowsAdviseInterceptor等）。

package com.itdoc.spring.aop.proxy;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:34
 */
public interface Arithmetic {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

package com.itdoc.spring.aop.proxy;

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:35
 */
public class ArithmeticProxyImpl implements Arithmetic {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

package com.itdoc.spring.aop.proxy;

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

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:45
 */
public class ArithmeticProxyHandle {

    //要代理的对象
    private Arithmetic target;

    public ArithmeticProxyHandle(Arithmetic target) {
        this.target = target;
    }

    public ArithmeticProxyHandle() {
    }

    public Arithmetic getLoggingProxy() {
        Arithmetic proxy = null;
        //代理对象由哪个类加载器负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型, 即其中有哪些方法
        Class [] interfaces = new Class[]{Arithmetic.class};
        //当调用代理对象中的方法时, 执行该代码
        InvocationHandler h = new InvocationHandler() {
            /**
             *
             * @param proxy  正在返回的那个代理对象, 一般情况下, 在 invoke 方法中都不使用该对象。
             * @param method 正在被调用的方法。
             * @param args   调用方法时, 传入的参数。
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String name = method.getName();
                System.out.println("The method " + name + " begins with" + Arrays.asList(args));
                Object result = method.invoke(target, args);
                System.out.println("The method " + name + "ends with " + result);
                return result;
            }
        };
        proxy = (Arithmetic) Proxy.newProxyInstance(loader, interfaces, h);
        return proxy;
    }
}

package com.itdoc.spring.aop.proxy;


/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:42
 */
public class Main {

    public static void main(String[] args) {
        Arithmetic arithmetic = new ArithmeticProxyImpl();
        arithmetic = new ArithmeticProxyHandle(arithmetic).getLoggingProxy();

        int result = arithmetic.add(1, 2);
        System.out.println(result);
        result = arithmetic.sub(3, 2);
        System.out.println(result);

    }
}

控制台输出：

The method add begins with[1, 2]
The method addends with 3
3
The method sub begins with[3, 2]
The method subends with 1
1

动态代理实现前置通知 , 后置通知 , 返回通知 , 异常通知：

package com.itdoc.spring.aop.proxy;

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

/**
 * http://www.cnblogs.com/goodcheap
 *
 * @author: Wáng Chéng Dá
 * @create: 2017-03-03 19:45
 */
public class ArithmeticProxyHandle {

    //要代理的对象
    private Arithmetic target;

    public ArithmeticProxyHandle(Arithmetic target) {
        this.target = target;
    }

    public ArithmeticProxyHandle() {
    }

    public Arithmetic getLoggingProxy() {
        Arithmetic proxy = null;
        //代理对象由哪个类加载器负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        //代理对象的类型, 即其中有哪些方法
        Class [] interfaces = new Class[]{Arithmetic.class};
        //当调用代理对象中的方法时, 执行该代码
        InvocationHandler h = new InvocationHandler() {
            /**
             *
             * @param proxy  正在返回的那个代理对象, 一般情况下, 在 invoke 方法中都不使用该对象。
             * @param method 正在被调用的方法。
             * @param args   调用方法时, 传入的参数。
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String name = method.getName();
                Object result = null;
                try {
                    //前置通知
                    System.out.println("The method " + name + " begins with" + Arrays.asList(args));
                    //执行方法
                    result = method.invoke(target, args);
                    //返回通知
                    System.out.println("The method " + name + " ends with " + result);
                } catch (Exception e) {
                    Throwable ex = new Throwable("出现异常", e);
                    //异常通知
                    System.out.println("The method " + name + " exception with " + ex);
                } finally {
                    //后置通知
                    System.out.println("The method " + name + " ends");
                }
                return result;
            }
        };
        proxy = (Arithmetic) Proxy.newProxyInstance(loader, interfaces, h);
        return proxy;
    }
}