Java中动态代理的实现方式

一、什么是动态代理

动态代理（Dynamic Proxy）是一种在运行时创建代理对象的机制，它允许我们在不事先知道具体类型的情况下，通过代理对象来调用目标对象的方法。

动态代理通常使用在面向对象编程中的AOP（面向切面编程）中，用于在目标对象的方法执行前后，添加一些额外的逻辑（如日志记录、性能监控、事务管理等），而不需要修改目标对象的源代码。

二、Java中的动态代理

1. JDK动态代理

在Java的java.lang.reflect包中，Proxy类和InvocationHandler接口提供了生成动态代理类的功能。

Proxy类提供了用于创建动态代理类的静态方法，而InvocationHandler接口定义了代理对象的调用处理方法。

通过实现InvocationHandler接口并重写其invoke方法，可以在代理对象的方法被调用时添加额外的逻辑。

🎯下面是一个简单的 JDK 动态代理的示例代码：🎯

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

// 定义一个接口
interface Hello {
    void sayHello();
}

// 实现接口的类
class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello World");
    }
}

// 实现 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 invoking sayHello()");
        Object result = method.invoke(target, args);
        System.out.println("After invoking sayHello()");
        return result;
    }
}

public class DynamicProxyDemo {
    public static void main(String[] args) {
        // 创建目标对象
        Hello hello = new HelloImpl();
        
        // 创建 InvocationHandler 对象
        InvocationHandler handler = new MyInvocationHandler(hello);
        
        // 创建动态代理对象
        Hello proxy = (Hello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                handler);
        
        // 通过代理对象调用目标方法
        proxy.sayHello();
    }
}

在上面的示例中，我们首先定义了一个接口 Hello，并实现了该接口的类 HelloImpl。然后，我们自定义了一个实现 InvocationHandler 接口的类 MyInvocationHandler，该类负责在调用目标方法前后添加额外的逻辑。在 main 方法中，我们先创建了目标对象 hello，然后通过创建 MyInvocationHandler 对象并传入目标对象来创建动态代理对象 proxy。最后，通过代理对象 proxy 调用目标方法 sayHello()。

运行上述代码，输出如下：

Before invoking sayHello()
Hello World
After invoking sayHello()

2. Cglib动态代理

Cglib(Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

✨下面是一个使用Cglib动态代理的示例代码：✨

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyDemo {

    public static void main(String[] args) {
        // 创建目标对象
        TargetObject targetObject = new TargetObject();

        // 创建Enhancer对象，用于创建代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TargetObject.class);
        enhancer.setCallback(new MyMethodInterceptor());

        // 创建代理对象
        TargetObject proxyObject = (TargetObject) enhancer.create();

        // 调用代理对象的方法，实际上会调用MyMethodInterceptor的intercept方法
        proxyObject.doSomething();
    }

    static class MyMethodInterceptor implements MethodInterceptor {

        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("Before method: " + method.getName());

            // 执行目标方法
            Object result = methodProxy.invokeSuper(o, objects);

            System.out.println("After method: " + method.getName());

            return result;
        }
    }

    static class TargetObject {
        public void doSomething() {
            System.out.println("Doing something...");
        }
    }
}

在上述示例中，我们使用Cglib创建了一个代理对象。首先，我们创建了一个目标对象 TargetObject，它包含了我们想要扩展的功能。然后，我们创建了一个 Enhancer 对象，设置其父类为 TargetObject，并将我们自定义的 MyMethodInterceptor 设置为回调函数。接下来，我们通过 enhancer.create() 方法创建了代理对象 proxyObject。

当我们调用代理对象的方法时，实际上会调用 MyMethodInterceptor 的 intercept 方法。在该方法中，我们可以在目标方法执行前后添加自定义的逻辑。在示例中，我们在目标方法执行前打印了 "Before method: " + method.getName()，在目标方法执行后打印了 "After method: " + method.getName()。

这样，我们就可以通过Cglib动态代理对目标对象的方法进行扩展，而无需修改目标对象的源代码。

三、动态代理使用场景

🥎以下是一些常见的动态代理的使用场景：🥎

1. AOP编程：

AOP（面向切面编程）是一种编程范式，允许在不修改现有代码的情况下，将额外的功能（如日志记录、性能监控等）应用到现有代码中。动态代理可以用于实现AOP，通过在方法调用前后插入额外的逻辑，实现横切关注点的功能。

2. 事务管理：

在数据库操作中，经常需要对一系列操作进行事务管理，即保证这些操作要么全部成功执行，要么全部回滚。动态代理可以用于创建一个事务代理对象，将事务管理的逻辑添加到原始对象的方法调用前后。

3. 安全检查：

动态代理可以用于在方法调用前进行安全检查，例如检查用户的权限或身份验证。