1、理解

/**
 *  一、AOP的意思
 *    AOP的意思（aspect oriented programming）面向切面编程
 *    OOP的意思（Object oriented programming）面向对象编程
 *
 *  二、AOP的作用
 *    解偶
 *
 *  三、定义
 *
 *    基于OOP基础之上新的编程思想，指在程序运行期间、将某段代码动态的切入到指定方法的指定位置进行运行的这种编程方式叫面向切面编程。
 *
 *  四、底层
 *
 *    底层基于动态代理
 *
 *  五、动态代理的优缺点
 *
 *     1）优点：动态代理能实现结偶，能将某段代码动态的切入到指定方法的指定位置进行运行
 *     2）缺点：写的麻烦、被代理类必须实现接口否则不能创建代理类。
 *
 *
 */

2、动态代理的使用

public interface Calculator {

    public int add(int num,int num1);
    public int sub(int num,int num1);
    public int mul(int num,int num1);
    public int div(int num,int num1);


}

public class MyMathCalculator implements Calculator {
    @Override
    public int add(int num, int num1) {
        return num + num1;
    }

    @Override
    public int sub(int num, int num1) {
        return num - num1;
    }

    @Override
    public int mul(int num, int num1) {
        return num * num1;
    }

    @Override
    public int div(int num, int num1) {
        return num / num1;
    }
}

public class DynamicProxyFactory {

    //维护一个 被代理类 对象 用 Object 就可以了因为不知道 被代理类是那样的。 通过 构造器 初始化 属性
    private static   Object target;
    // 利用构造器对 代理对象 进行初始化
    public DynamicProxyFactory(Object target) {
        this.target = target;
    }


    //给目标对象生成一个代理对象

    /**三个参数的说明：
     *     classLoder 代理类使用的类加载器和 被代理类使用的是一样的 加载器
     *     interfaces[]  和被代理类实现了共同的接口
     *     handler 调用处理器    实现了 InvocationHandler 这个接口的匿名实现类。重写方法
     *     这个方法里面利用反射 调用 被代理类的方法。
     *
     *
     */

     //代理对象和被代理对象的关系

    /**
     *
     *
     *
     *  代理类和被代理类 都实现了同一个接口，这个是他们俩能产生关联的唯一地方。
     *
     *  public static Object getProxyInstance() 这个是一个proxy类，和 被代理类不是同一个类型
     *
     *  缺点：如果被代理类没有实现任何接口则没有办法创建被代理类
     *
     */



    public static Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("JDK代理开始了");

                System.out.println(method.getName()+"方法开始执行了参数是"+ Arrays.asList(args));
                Object  val = null;
                try{
                    val = method.invoke(target,args);
                }catch (Exception e){
                    System.out.println(method.getName()+"方法执行出现了异常"+ Arrays.asList(args));

                }

                System.out.println(method.getName()+"方法执行完了结果是"+ val);
                return val;
            }
        });
    }
}

    @RequestMapping("/add")
    public void add(){

        MyMathCalculator myMathCalculator = new MyMathCalculator();
        DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactory(myMathCalculator);
        System.err.println(DynamicProxyFactory.getProxyInstance().getClass());
        Calculator calculator = (Calculator)DynamicProxyFactory.getProxyInstance();


        System.out.println(calculator.add(12,12));

        System.err.println(calculator.sub(23,21));

        System.out.println(calculator.div(12,0));
    }