Java Proxy代理怎样配置和使用

在Java中，代理（Proxy）是一种设计模式，它允许你提供一个代理对象来控制对另一个对象的访问。代理模式可以在不改变原始对象的情况下增加额外的功能或控制访问。

Java中的代理主要分为两种类型：

1. 静态代理：在编译时就已经确定了代理类和被代理类的关系。
2. 动态代理：在运行时动态生成代理类。

下面是静态代理和动态代理的基本配置和使用方法：

静态代理

假设我们有一个接口Subject和它的实现类RealSubject，我们想要在不修改RealSubject的情况下增加一些额外的行为。

// Subject接口
public interface Subject {
    void request();
}

// RealSubject类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 代理类
public class StaticProxy implements Subject {
    private RealSubject realSubject;

    public StaticProxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        // 在调用实际对象的方法前后可以添加额外的逻辑
        System.out.println("StaticProxy: Before handling request.");
        realSubject.request();
        System.out.println("StaticProxy: After handling request.");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        StaticProxy proxy = new StaticProxy(realSubject);
        proxy.request();
    }
}

动态代理

动态代理允许你在运行时创建代理对象，而不需要在编译时定义代理类。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。

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

// Subject接口
public interface Subject {
    void request();
}

// RealSubject类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 动态代理处理器
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用实际对象的方法前后可以添加额外的逻辑
        System.out.println("DynamicProxy: Before handling request.");
        Object result = method.invoke(target, args);
        System.out.println("DynamicProxy: After handling request.");
        return result;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        InvocationHandler handler = new DynamicProxyHandler(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
            realSubject.getClass().getClassLoader(),
            realSubject.getClass().getInterfaces(),
            handler
        );
        proxySubject.request();
    }
}

在上面的动态代理示例中，我们创建了一个DynamicProxyHandler类，它实现了InvocationHandler接口。在invoke方法中，我们可以添加额外的逻辑，并通过反射调用目标对象的方法。然后，我们使用Proxy.newProxyInstance方法创建了一个代理对象，该对象实现了Subject接口，并将DynamicProxyHandler作为调用处理器。

动态代理的优点是可以在运行时为任何接口创建代理，而不需要为每个接口编写具体的代理类。这使得动态代理非常灵活，适用于AOP（面向切面编程）等场景。