Java代理模式有何用，怎样实现动态和静态代理？

在Java编程的广阔天地中，代理模式（Proxy Pattern）作为一种重要的设计模式，扮演着举足轻重的角色。它不仅增强了代码的灵活性和可扩展性，还在诸如远程调用、事务处理、安全控制等多个领域发挥着关键作用。代理模式的核心思想是为其他对象提供一种代理以控制对这个对象的访问。

Java代理模式的作用

• 增强功能：在不修改原类代码的前提下，为原类增加新的功能。
• 控制访问：对访问原类的操作进行过滤，如权限校验、日志记录等。
• 远程调用：通过代理实现网络上的远程方法调用。
• 缓存和懒加载：提高程序性能，减少不必要的资源消耗。

怎样实现动态和静态代理

静态代理

静态代理是指在编译时期就确定代理类，代理类和被代理类实现同一接口或继承同一父类。重点是通过代理类手动编写方法，调用目标类的方法，并在调用前后加入自定义操作。

interface Subject {
    void request();
}

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

class StaticProxy implements Subject {
    private Subject realSubject;

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

    @Override
    public void request() {
        **// 自定义操作，如权限检查**
        preRequest();
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        System.out.println("Pre-request processing.");
    }

    private void postRequest() {
        System.out.println("Post-request processing.");
    }
}

动态代理

动态代理则是在运行时动态地生成代理类。Java的动态代理主要利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。重点是通过反射机制在运行时动态生成代理类，无需手动编写代理类代码。

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

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("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getProxyInstance(Class<T> interfaceClass, Object target) {
        return (T) Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            new Class<?>[] { interfaceClass },
            new DynamicProxyHandler(target)
        );
    }
}

通过动态代理，我们可以更加灵活地控制代理逻辑，且无需为每一个目标类编写对应的代理类，极大地提高了开发效率。