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

在Java的浩瀚设计模式中，代理模式（Proxy Pattern）以其独特的魅力，成为了解决间接访问对象、增强对象功能等问题的利器。那么，Java代理模式究竟有何妙用？又该如何实现其精髓——动态代理与静态代理呢？

Java代理模式的妙用

代理模式的核心思想是：为其他对象提供一种代理以控制对这个对象的访问。它主要用于：

• 访问控制：隐藏真实对象的实现细节，通过代理层控制对真实对象的访问。
• 功能增强：在客户端与目标对象之间插入代理对象，可以在不修改目标对象代码的前提下，增加额外的功能处理。
• 智能指引：根据客户端的请求，代理可以决定调用哪个具体对象的方法，以及如何进行调用。

静态代理的实现

静态代理是在编译时就确定了代理类，需要手动编写代理类。步骤如下：

1. 创建接口：定义目标对象与代理对象共同遵守的接口。
2. 实现目标类：实现接口的具体业务逻辑。
3. 创建代理类：同样实现该接口，并在内部持有目标对象的引用，通过调用目标对象的方法来完成业务逻辑，同时可加入额外操作。

示例：

interface Subject {
    void request();
}

class RealSubject implements Subject {
    public void request() {
        System.out.println("访问真实对象");
    }
}

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("请求前处理");
    }

    private void postRequest() {
        System.out.println("请求后处理");
    }
}

动态代理的实现

动态代理则是在运行时动态生成代理类，无需手动编写代理类代码。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。

步骤：

1. 创建目标接口。
2. 创建实现InvocationHandler接口的处理器。在该处理器中，通过反射调用目标对象的方法，并可在调用前后加入自定义逻辑。
3. 通过Proxy.newProxyInstance()方法创建代理对象，传入类加载器、目标对象实现的接口数组和处理器对象。

示例（省略了部分异常处理）：

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("方法调用前处理");**
        Object result = method.invoke(target, args);
        **System.out.println("方法调用后处理");**
        return result;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getProxy(T target) {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new DynamicProxyHandler(target)
        );
    }
}

通过对比静态代理与动态代理，我们可以看到动态代理的灵活性和强大之处，它能够在运行时根据需要动态地生成代理类，极大地提升了代码的复用性和可维护性。