Java机制/代理：代理介绍

代理介绍

在Java中，代理是一种常用的设计模式，它可以为其他对象提供一个代理或者占位符，以控制对原始对象的访问。代理对象可以在访问原始对象前后添加额外的逻辑，例如权限检查、记录日志、性能监控等，从而增强程序的可维护性、可扩展性和安全性。

Java中的代理分为静态代理和动态代理两种类型。

静态代理是指在编译时就已经确定代理对象和被代理对象的关系，代理对象和被代理对象都要实现同样的接口或者继承同样的父类。静态代理需要手动编写代理类，通过在代理类中调用被代理对象的方法来实现代理功能。静态代理的缺点是需要手动编写代理类，对于大量的业务逻辑和对象类型，需要编写大量的代理类，增加了程序的维护难度。

动态代理是指在程序运行时动态生成代理对象和被代理对象的关系，代理对象和被代理对象不需要实现同样的接口或者继承同样的父类。动态代理使用Java的反射机制来实现，可以动态地生成代理对象，并在代理对象的方法中调用被代理对象的方法。Java中的动态代理主要有两种实现方式，一种是基于JDK的代理，另一种是基于第三方库的代理，例如cglib。

基于JDK的代理使用了Java的反射机制和动态代理API来实现，它可以代理任意实现了接口的类，并且不需要手动编写代理类。基于JDK的代理需要一个InvocationHandler接口的实现类来处理代理对象的方法调用，代理对象的方法调用会被转发给InvocationHandler接口的实现类，从而实现代理功能。基于JDK的代理的缺点是只能代理实现了接口的类，不能代理没有实现接口的类。

基于cglib的代理使用了字节码生成技术来实现，它可以代理任意类，包括没有实现接口的类。基于cglib的代理需要一个MethodInterceptor接口的实现类来处理代理对象的方法调用，代理对象的方法调用会被转发给MethodInterceptor接口的实现类，从而实现代理功能。基于cglib的代理的缺点是生成的代理对象比较笨重，对于一些特殊的类，可能会出现代理失败的情况。

代理在实际开发中广泛应用于AOP（面向切面编程）和RPC（远程过程调用）等领域。通过代理可以将不同的业务逻辑分离开来，降低耦合度，提高程序的可维护性和可扩展性。

示例

以下是一个简单的 Java 代理示例：

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

public interface Hello {
    void sayHello();
}

public class HelloImpl implements Hello {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

public class HelloProxy implements InvocationHandler {
    private Object target;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoke method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After invoke method: " + method.getName());
        return result;
    }

    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        Hello proxy = (Hello) Proxy.newProxyInstance(
            hello.getClass().getClassLoader(),
            hello.getClass().getInterfaces(),
            new HelloProxy(hello)
        );
        proxy.sayHello();
    }
}

运行结果：

Before invoke method: sayHello
Hello, World!
After invoke method: sayHello

在这个例子中，我们定义了一个接口 Hello 和它的实现类 HelloImpl。然后我们创建了一个代理类 HelloProxy，它实现了 InvocationHandler 接口，这个接口中只有一个方法 invoke，当代理对象的方法被调用时，invoke 方法会被自动调用。在 HelloProxy 类中，我们定义了一个成员变量 target，它指向实际的对象，也就是 HelloImpl 的实例。在 invoke 方法中，我们可以在调用实际对象的方法前后添加自己的逻辑，比如在方法前输出日志，并在方法后输出日志。最后，我们在 main 方法中创建了一个代理对象，这个代理对象会拦截 Hello 接口中的方法调用，然后将调用重定向到 HelloImpl 对象中对应的方法上。运行代码会输出上面的结果。