详细解读SpringAop实现原理——动态代理

1.aop 底层是采用动态代理机制实现的：接口+实现类

1.如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代
理对象。
2.没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会
使用 Cglib 生成一个被代理对象的子类来作为代理。

2.何为动态代理

一种在运行时动态创建代理对象的机制，它允许我们在不修改原始类的情况下，向原始类添加额外的功能或行为。

用代码比较一下使用常规手段创建对象和使用动态代理创建对象的区别：

2.1.使用常规方式创建对象代码

假设我们现在有三个类

class ObjectA {
    public void methodA() {
        System.out.println("在执行ObectC和ObjectB的方法之前都要先执行methodA");
    }
}
class ObjectB {
    public void methodB() {
        System.out.println("methodB");
    }
}
class ObjectC {
    public void methodC() {
        System.out.println("methodC");
    }
}

要求在ObjectB,ObjectC的方法在被调用之前都要先执行ObjectA的方法

我可以想到的实现方式无非就是以下两种

1.在调用ObjectB,ObjectC的方法被调用前都调用一下ObjectA的方法：

public class NormalObject {
    public static void main(String[] args) {
        ObjectA objectA = new ObjectA();
        ObjectB objectB = new ObjectB();
        ObjectC objectC = new ObjectC();

        objectA.methodA();
        objectB.methodB();

        objectA.methodA();
        objectC.methodC();
    }
}

这样写的话，如果ObjectB,ObjectC的方法被多次调用，每次调用前都要先调用ObjectA的方法，代码过于冗余

2.在ObjectB,ObjectC的方法中实例化一个ObjectA的对象，调用ObjectA的方法：

class ObjectA {
    public void methodA() {
        System.out.println("在执行ObectC和ObjectB的方法之前都要先执行methodA");
    }
}
class ObjectB {
    public void methodB() {
        ObjectA objectA = new ObjectA();
        objectA.methodA();
        System.out.println("methodB");
    }
}
class ObjectC {
    public void methodC() {
        ObjectA objectA = new ObjectA();
        objectA.methodA();
        System.out.println("methodC");
    }
}
public class NormalObject {
    public static void main(String[] args) {
        ObjectB objectB = new ObjectB();
        ObjectC objectC = new ObjectC();

        objectB.methodB();
        objectC.methodC();
    }
}

这样写的话，需要修改ObjectB和ObjectC中的业务代码，在大型项目中，不利于维护。 

2.2使用JDK动态代理创建对象

首先声明一下JDK动态代理实现原理：

• JDK动态代理是基于接口的代理，它要求被代理的对象实现接口。
• JDK动态代理使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来创建代理对象。
• 代理对象实现了与原始对象相同的接口，当调用代理对象的方法时，会触发InvocationHandler中的逻辑，从而实现代理的功能。

2.2.1首先定义一个接口，并实现它，作为被代理的类

// 定义一个接口
interface MyInterface {
    void doSomething(String param);
}

// 实现接口的类
class MyImplementation implements MyInterface {
    @Override
    public void doSomething(String param) {
        System.out.println("Doing something in the implementation class." + param);
    }
}

2.2.2定义一个MyInvocationHandler 类

该类实现InvocationHandler接口，并重写了InvocationHandler的invoke方法

// 实现InvocationHandler接口
class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method execution with parameter: " + args[0]);
        Object result = method.invoke(target, args);
        System.out.println("After method execution");
        return result;
    }
}

2.2.3定义一个创建动态对象的工具类

在类中定义一个创建动态对象的方法，接受一个类的Class对象作为参数，返回该类的一个代理对象。

class CreateProxyObject {
    public static <T> T createProxy(Class<T> clazz) throws InstantiationException, IllegalAccessException {
        //根据传入类型创建一个对象
        T obj = clazz.newInstance();
        //实例化一个MyInvocationHandler对象，将上边的对象传入
        MyInvocationHandler handler = new MyInvocationHandler(obj);
        //使用Proxy创建代理对象，并return
        T proxyObj = (T) Proxy.newProxyInstance(
                obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(),
                handler
        );
        return proxyObj;
    }
}

2.2.4创建代理对象，调用代理对象的doSomething()方法

public class JdkDynamicProxyObject {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        // 给类创建代理对象
        MyInterface proxyObj = (MyInterface)CreateProxyObject.createProxy(MyImplementation.class);
        proxyObj.doSomething("test parameter");
    }
}

2.2.5运行结果

可以发现，在调用代理对象的doSomething()方法时，执行了InvocationHandler的invoke()方法，并在 doSomething()执行之前执行了Object result = method.invoke(target, args);上方的代码，在doSomething()执行之后执行了Object result = method.invoke(target, args);下方的代码。

2.3使用cglib实现动态代理

首先申明：使用cglib前请将jdk版本降低到1.8版本及以下，否则会报InaccessibleObjectException错误，这个报错是由于Java的模块化系统引入的安全限制导致的。在Java 9及之后的版本中，模块系统对反射访问进行了限制，以防止对核心Java类的不安全访问。

2.3.1定义一个被代理的类

// 被代理的类
class MyOriginalClass {
    public void doSomething() {
        System.out.println("Doing something in the original class.");
    }
}

2.3.2实现MethodInterceptor接口

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method execution");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method execution");
        return result;
    }
}

2.3.3定义一个创建动态对象的工具类

class CreateCglibProxyObject {
    public static <T> T createProxy(Class<T> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(new MyMethodInterceptor());
        return (T) enhancer.create();
    }
}

2.3.4创建代理对象

public class CglibDynamicProxyObject {
    public static void main(String[] args) {
        MyOriginalClass proxyObj = (MyOriginalClass) CreateCglibProxyObject.createProxy(MyOriginalClass.class);
        proxyObj.doSomething();
    }
}

2.3.5运行结果

可以发现，在调用代理对象的doSomething()方法时，执行了MyMethodInterceptor的intercept()方法，并在 doSomething()执行之前执行了Object result = proxy.invokeSuper(obj, args);上方的代码，在doSomething()执行之后执行了Object result = proxy.invokeSuper(obj, args);下方的代码。 

2.4对比总结

1.使用动态代理创建对象，可以在不修改原始类的方法的情况下，向原始类方法执行前后添加额外的功能或行为。

2.能够很好的降低代码冗余度，只需要创建一个代理对象，每次调用代理对象的方法时，在方法前后执行的逻辑都会自动执行，不需要再手动调用。