java 动态代理技术简介

什么是代理模式？

代理模式是一种设计模式，它允许我们通过创建一个代理对象来控制对另一个对象的访问。代理对象可以在不改变原始对象的情况下，增加一些额外的逻辑或控制访问行为。

静态代理 vs 动态代理

在Java中，我们有两种类型的代理：静态代理和动态代理。

静态代理

静态代理是在编译时期创建的代理类，它的代理对象和目标对象是一对一关系。我们需要为每个目标对象编写一个代理类，这样会导致代码冗余和维护困难。
下面是一个简单的示例，展示了如何使用静态代理模式：

// 目标接口
public interface Image {
    void display();
}
// 目标类
public class RealImage implements Image {
    private String filename;
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }
    private void loadFromDisk() {
        System.out.println("Loading image: " + filename);
    }
    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}
// 代理类
public class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;
    public ImageProxy(String filename) {
        this.filename = filename;
    }
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Image image = new ImageProxy("image.jpg");
        image.display();
    }
}

动态代理

动态代理是在运行时期创建的代理类，它允许我们在运行时期动态地创建代理对象，并将方法调用转发到目标对象。相对于静态代理，动态代理更加灵活和易于扩展。
在Java中，有两种方式实现动态代理：JDK动态代理和CGLIB。

JDK动态代理

JDK动态代理是Java提供的一种机制，它基于接口实现代理。通过使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口，我们可以创建代理类并处理方法调用。
下面是一个简单的示例，展示了如何使用JDK动态代理模式：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 目标接口
public interface Calculator {
    int add(int a, int b);
}
// 目标类
public class CalculatorImpl implements Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}
// InvocationHandler实现
public class LoggingHandler implements InvocationHandler {
    private Object target;
    public LoggingHandler(Object target) {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Calculator target = new CalculatorImpl();
        LoggingHandler handler = new LoggingHandler(target);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler
        );
        int result = proxy.add(10, 20);
        System.out.println("Result: " + result);
    }
}

CGLIB

CGLIB是一个基于字节码生成的代理机制，它允许我们在运行时期动态地创建代理类，并继承目标对象。相对于JDK动态代理，CGLIB不需要目标对象实现接口，因此更加灵活。
下面是一个简单的示例，展示了如何使用CGLIB动态代理模式：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
// 目标类
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}
// MethodInterceptor实现
public class LoggingInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}
// 客户端代码
public class Client {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Calculator.class);
        enhancer.setCallback(new LoggingInterceptor());
        Calculator proxy = (Calculator) enhancer.create();
        int result = proxy.add(10, 20);
        System.out.println("Result: " + result);
    }
}

总结

通过代理模式和动态代理，我们可以在不改变原始对象的情况下，增加额外的逻辑或控制访问行为。静态代理在编译时期创建代理类，而动态代理在运行时期创建代理类。JDK动态代理基于接口实现代理，而CGLIB动态代理基于字节码生成代理。
使用动态代理有助于提高代码的灵活性和可维护性。我们可以根据需要选择适合的代理方式来满足不同的需求。