Spring重温（七）— — 通过JDK的动态代理来理解AOP

前言：

        相信学到spring框架的同学都应该或多或少接触到AOP这个东西。AOP是个好东西，不管我们是用注解来开发，还是用xml，我们了解的只是他们的切点，切面，用哪个方法切。但是AOP是如何实现的却不了解。这一篇文章，小编将和大家一起学习AOP的入门——JDK的动态代理来了解AOP。

开发环境：

        win10+idea+jdk8--没啥别的了，也不需要导入架包。

开始学习：

        注意：  JDK的动态代理是基于接口来实现的，所以一定要有个接口                    

                     JDK的动态代理是基于接口来实现的，所以一定要有个接口

                     JDK的动态代理是基于接口来实现的，所以一定要有个接口

                                                        （重要事情说三遍）

         第一步：我们先写一个接口，接口里面有两个方法，一个是add（）方法，一个是delete（）方法。

package com.test.aop;

public interface BagInterface {
    void add();
    void delete();

}

         第二步：   我们写一个书包类来实现这个接口

package com.test.aop;

public class Bag  implements BagInterface{

    @Override
    public void add() {
        System.out.println("往书包里塞东西");
    }

    @Override
    public void delete() {
        System.out.println("往书包外取东西");
    }
}

          第三步：创建一个代理对象类，并实现InvocationHandler接口

package com.test.aop;

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

/**
 * 实现代理。一定要实现InvocationHandler这个接口
 */
public class JDKProxy implements InvocationHandler {
    //引入真实的对象
    private Object proxyDX;

    //用构造注入的方式获得真实的对象
    public JDKProxy(Object o) {
        this.proxyDX = o;
    }

    /**
     * @param proxy
     * @param method 对象里的方法
     * @param args   方法的各种参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始调用method");

        /**
         * 这里我们可以做一些操作，类似于AOP，前置增强
         *
         * 例如我在这里开启事务
         */

        //将真实对象注入
        Object object = method.invoke(proxyDX, args);

        /**
         * 这里我们可以做一些操作，类似于AOP，后置增强
         *
         * 完成后，没异常，可以提交事务了
         */


        System.out.println("调用方法结束");

        return object;
    }
}

            第四步：开始测试一下通不通过~

package com.test.aop;

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

public class Test {


    public static void main(String[] args) {
//        MyTestInterface myTest= new MyTest();
//       HandlerMethod handlerMethod= new HandlerMethod();
//        MyTestInterface a = (MyTestInterface) handlerMethod.getProxy(myTest.getClass());
//        a.add();


        //JDK动态代理
        //多态，new一个真实的对象
        BagInterface bag=  new Bag();
        //new一个对象代理的，并且将真实对象注入到代理对象中
        InvocationHandler invocationHandler=new JDKProxy(bag);
        /**
         * OK，我们要开始代理了。
         *   newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
         *      第一个参数是加载的类，我们用真实对象获取就可以了
         *      第二个参数是我们找到实现过的接口（一定要有个接口，JDK动态代理是基于接口的），这样我们就可以多态来调用方法
         *      第三个参数就是我们代理对象啦！
         */
        BagInterface bagInterface= (BagInterface) Proxy.newProxyInstance(bag.getClass().getClassLoader(),bag.getClass().getInterfaces(),invocationHandler);
        bagInterface.add();
        System.out.println("——————完美的分割线——————");
        bagInterface.add();
    }
}

            第五步：测试结果如下

        

总结：

        上面就是JDK的动态代理的实现，当然这也是学习AOP的基础。其实AOP也是基于JDK动态代理或者是cglib代理来实现的。只不过springAOP封装的比较好。但是换汤不换药，说白了就是个代理，难道我们会了代理，就学不会AOP，不存在滴。但不得不说Spring框架的大智慧，值得我们好好研究。

程序人生，与君共勉