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