Spring AOP的两种实现方式——JDK和CGLIB

动态代理

动态代理的意义就是生成一个代理对象，来代理真实对象，从而控制真实对象的访问，这里涉及的代理模式自行了解

代理步骤

1、代理对象和真实对象建立代理关系
2、实现代理对象的代理逻辑方法

JDK动态代理

因为JDK动态代理方式的实现必须借助接口，因此当被代理对象存在接口时，我们使用JDK动态代理的方式，JDK动态代理的实现主要通过两个方法Proxy.newProxyInstance()和InvocationHandle接口的invoke（）方法,代理对象必须实现invoke()方法
代码目的：要实现MyCalculator的代理对象CalculatorProxy
代码1：被代理对象接口

public interface Calculator {

    public int add(int i, int j);

    public int sub(int i, int j);

    public int mult(int i, int j);

    public int div(int i, int j);
}

代码2：被代理对象实现接口

public class MyCalculator implements Calculator {
    @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 mult(int i, int j) {
        int result = i * j;
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

代码3：动态代理绑定和代理逻辑实现

public class CalculatorProxy  {
    public static Calculator getProxy(final Calculator calculator){
        //获取类加载器
        ClassLoader classLoader = calculator.getClass().getClassLoader();
        //获取要实现的对象的接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();

        InvocationHandler handler = new InvocationHandler() {

            Object result = null;
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                try {
                  result = method.invoke(calculator,args);
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {


                }
                return result;
            }
        };
        Object o = Proxy.newProxyInstance(classLoader, interfaces, handler);
        return (Calculator)o;
    }
}

代码4：测试JDK动态代理

public class Test {

    public static void main(String[] args) {
        Calculator proxy = CalculatorProxy.getProxy(new MyCalculator());
        System.out.println(proxy.add(1, 1));
        System.out.println(proxy.getClass());
    }
}

第一步：建立代理对象和被代理对象的关系
注意着三个参数
第一个：类加载器，被代理对象的类加载器
第二个：生成的动态代理对象下挂在哪些接口下，这里是Calculator接口
第三个：定义实现方法的逻辑代理类，这通过创建一个内部类来实现，核心是传入一个实现InvocationHandle接口的invoke（）方法的对象

Proxy.newProxyInstance(classLoader, interfaces, handler);

第二步，实现代理逻辑方法，就是我们如何通过代理类调用被代理方法，是通过invoke（）方法实现的,invoke()也有三个参数
第一个：代理对象
第二个：当前调度的方法
第三个：调度方法参数

	method.invoke(calculator,args);

CGLIB动态代理

JDK动态代理，被代理对象必须实现接口，当被代理类没有实现接口时，这时候就要引入CGLIB 动态代理，它不需要被代理对象提供接口

代码1：被代理对象，没有接口实现

public class MyCalculator  {
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

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

    public int mult(int i, int j) {
        int result = i * j;
        return result;
    }

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

代码2：代理对象和代理逻辑
CGLIB动态代理的实现主要由两部分组成

public class CglibProxyExample implements MethodInterceptor {

    public  Object getProxy(Class cla ){
        //创建cglib获取代理对象的操作对象
        Enhancer enhancer = new Enhancer();
        //设置enhancer对象的父类
        enhancer.setSuperclass(cla);
        //定义代理逻辑对象为当前对象，所以这里是this，这里代理逻辑对象必须实现MethodInterceptoe方法
        enhancer.setCallback(this);
        //生成并返回代理对象
        return enhancer.create();
    }
	/*
 	此方法用来实现方法的拦截，四个参数分别表示的含义：
 	obj:表示增强的对象，即实现这个接口类的一个对象
 	method：表示要拦截的方法
 	args：表示被拦截的方法的参数
 	proxy:表示要触发父类的方法对象
 	*/
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

        //通过反射调用真实方法
        Object result = proxy.invokeSuper(obj, args);
        return result;
    }
}

代码3：测试CGLIB动态代理

public class Test {

    public static void main(String[] args) {

        CglibProxyExample cglibProxyExample = new CglibProxyExample();
        MyCalculator proxy = (MyCalculator)cglibProxyExample.getProxy(MyCalculator.class);
        System.out.println(proxy.add(1, 1));
    }
}

第一步：代理对象和真实对象之间的关系
CGLIB动态代理方式，通过Enhancer对象来实现代理对象和真实对象的关系的创建，先创建一个Enhancer对象，然后通过setSuperclass方法设置超类，在通过setCallback方法设置代理类，其中this就代表当前对象，因此当前对象要实现MethodInterceptor接口的intercept方法，setCallback方法传入对象的要求就是实现MethodInterceptor接口的intercept方法
第二步：实现代理逻辑
CGLIB代理逻辑在MethodInterceptor接口的intercept方法来实现，下面这条语句来实现

 Object result = proxy.invokeSuper(obj, args);