实现Spring JDK代理和CGLIB代理

JDK代理：

JDK动态代理其实也是基本接口实现的。因为通过接口指向实现类实例的多态方式，可以有效地将具体实现与调用解耦，便于后期的修改和维护。

1. 创建"Car"接口：

package com.example.demo;

/**
 * 定义Car接口
 */
public interface Car {
    void whatCar();
}

2.创建"Mazda"类，实现接口"Car"，并实现方法"whatCar"：

package com.example.demo;

public class Mazda implements Car {
    @Override
    public void whatCar() {
        System.out.println("I am Mazda");
    }
}

3.创建一个动态代理类,需要实现InvocationHandler接口，代码中有详细注解：

package com.example.demo;

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

/**
 * 创建一个动态代理类,需要实现InvocationHandler接口
 */
public class CarInvocationHandler implements InvocationHandler{

    //被代理对象 即真实对象
    private Object target;

    Object bind(Object target) {
        this.target = target;
        /* Proxy.newProxyInstance 参数解释:
         * 第一个是类加载器，这里采用的是类本身的类加载器
         * 第二个是把生成的动态代理对象下挂到哪些接口下,这里就是放在obj实现的接口下，在本文即Car接口
         * 第三个是定义实现方法逻辑的代理类，哪个类的方法就将哪个类传进去
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**
     * 代理方法：当我们使用了代理对象调度真实对象的方法后，它就会进入到invoke方法里面
     * @param proxy 方法被调用的代理实例，被代理类
     * @param method 当前调度对象
     * @param args 用于方法调用的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("----调用前处理");
        //反射原有方法
        Object invoke = method.invoke(target, args);
        System.out.println("----调用后处理");
        return invoke;
    }
}

4.main方法进行测试：

public static void main(String[] args){
   Mazda mazda = new Mazda();
   CarInvocationHandler aih = new CarInvocationHandler();
   //返回接口类型，类似与@Autowired
   Car mazdaBind = (Car) aih.bind(mazda);
   mazdaBind.whatCar();
}

当调用mazdaBind.whatCar()时，会进入到invoke()
这就是AOP实现的基本原理，只是Spring不需要开发人员自己维护。

5.输出结果：

CGLIB代理：

cglib动态代理通过实现子类的方式对目标类进行增强。
举个例子：
如果想知道谁是复仇者联盟（TheAvengers），就要找到尼克（AvengersMethodInterceptor），尼克再去找到英雄，让他告诉你他是哪个英雄。

1.创建"TheAvengers"类：

package com.example.demo;

public class TheAvengers {
    public void whichHero(){
        System.out.println("I am Iron Man");
    }
}

2.创建"AvengersMethodInterceptor"类，实现MethodInterceptor接口，对被代理对象方法进行拦截：

package com.example.demo.cglib;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * cglib实现动态代理,对被代理对象方法进行拦截
 */
public class AvengersMethodInterceptor implements MethodInterceptor {
    /*
     * Object：cglib生成的代理对象
     * Method：被代理对象的方法
     * Object[]：方法参数
     * MethodProxy：代理对象的方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        Object obj = methodProxy.invokeSuper(o,objects); //invokeSuper：在指定的对象上调用原始（父类）方法。
        System.out.println("调用后");
        return obj;
    }
}

3.创建"CGLIBTest"测试类：

package com.example.demo.cglib;

import org.springframework.cglib.proxy.Enhancer;

public class CGLIBTest {

    public static void main(String[] args){
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer en = new Enhancer();
        // 设置enhancer对象的父类
        en.setSuperclass(TheAvengers.class);
        // 设置enhancer的回调对象
        en.setCallback(new AvengersMethodInterceptor());
        // 创建代理对象
        TheAvengers avengers = (TheAvengers)en.create();
        // 通过代理对象调用目标方法
        avengers.whichHero();
    }

}

当通过代理对象调用目标方法（avengers.whichHero();）时，会进入到AvengersMethodInterceptor中的intercept方法。

4.结果如下：

大概流程

1. 设置父类（目标类）、设置回调对象（方法拦截器），并生成代理类的字节码文件
2. 使用ClassLoader将字节码文件加载到JVM
3. 创建代理类实例对象，执行对象的目标方法

参考博客：
https://blog.csdn.net/yu_kang/article/details/88530016
https://www.cnblogs.com/godoforange/p/11587321.html