当前位置：首页 > article >正文

Java 代理模式 (Proxy)详解

article 2025/2/25 16:50:41

一、什么是代理模式？

定义： 代理模式是一种结构型设计模式。它为另一个对象（目标对象/被代理对象）提供一个代理（或占位符），以控制对这个对象的访问。
核心思想： 通过引入一个代理对象，客户端不直接访问目标对象，而是通过代理对象来间接访问目标对象。代理对象可以控制对目标对象的访问，并可以在访问前后添加额外的操作。
意图： 控制对一个对象的访问，可以延迟加载、访问控制、增强功能等。

二、代理模式的结构

代理模式通常包含以下几个角色：

Subject (抽象主题):
- 定义了 RealSubject 和 Proxy 的共同接口。客户端通过 Subject 接口访问目标对象。
- 通常是一个接口或抽象类。
RealSubject (真实主题/目标对象/被代理对象):
- 定义了真正的业务逻辑。
- 实现了 Subject 接口。
Proxy (代理):
- 持有 RealSubject 对象的引用。
- 实现了 Subject 接口，与 RealSubject 具有相同的方法。
- 控制对 RealSubject 对象的访问，并可以在访问前后添加额外的操作。
- 客户端通过 Proxy 对象间接访问 RealSubject 对象。

UML 类图:

+----------------+       +----------------+       +----------------+
|   <<Subject>>   |       |     Proxy      |       |  RealSubject   |
+----------------+       +----------------+       +----------------+
| +request()     |------>| -realSubject   |------>| +request()     |
+----------------+       | +request()     |       +----------------+
                             +preRequest()
                             +postRequest()

三、代理模式的类型

根据代理的创建时间和功能，可以将代理模式分为以下几种类型：

静态代理 (Static Proxy):
- 特点： 在编译时就已经确定了代理类和被代理类之间的关系。代理类和被代理类都需要实现相同的接口。
- 优点： 实现简单，易于理解。
- 缺点：
  - 代码冗余： 如果需要代理多个类，就需要创建多个代理类，导致代码冗余。
  - 可维护性差： 如果接口发生变化，代理类和被代理类都需要进行修改。
动态代理 (Dynamic Proxy):
- 特点： 在运行时动态地生成代理类，无需手动创建代理类。
- 优点：
  - 灵活性高： 可以代理任何实现了接口的类，无需修改原始代码。
  - 代码复用： 可以使用同一个代理类来代理多个不同的类。
  - 可维护性好： 如果接口发生变化，只需要修改代理逻辑，无需修改被代理类。
- 缺点：
  - 实现复杂： 动态代理的实现比静态代理复杂。
  - 性能开销： 动态代理需要使用反射机制，性能比静态代理略低。
- Java 中的动态代理：
  - JDK 动态代理： Java 提供的内置动态代理机制，只能代理实现了接口的类。
  - CGLIB 动态代理： 第三方库提供的动态代理机制，可以代理没有实现接口的类。
其他代理
- 保护代理 用于控制对敏感对象的访问。
- 远程代理 用于访问远程对象。
- 虚拟代理 通过代理延迟创建开销大的对象

四、代理模式的实现方式 (Java)

静态代理：

// 抽象主题
interface Image {
    void display();
}

// 真实主题
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading image: " + filename);
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

// 代理
class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;

    public ImageProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// 客户端代码
public class StaticProxyExample {
    public static void main(String[] args) {
        Image image = new ImageProxy("test_image.jpg");

        // 第一次调用 display() 方法，会加载图片
        image.display();

        // 第二次调用 display() 方法，不会再次加载图片
        image.display();
    }
}

JDK 动态代理：

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

// 抽象主题
interface Image {
    void display();
}

// 真实主题
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading image: " + filename);
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

// 调用处理器
class ImageInvocationHandler implements InvocationHandler {
    private Object target; // 被代理的对象

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用目标方法之前执行的操作
        System.out.println("Before invoking method: " + method.getName());

        // 调用目标方法
        Object result = method.invoke(target, args);

        // 在调用目标方法之后执行的操作
        System.out.println("After invoking method: " + method.getName());

        return result;
    }
}

// 客户端代码
public class JDKDynamicProxyExample {
    public static void main(String[] args) {
        // 创建被代理对象
        Image realImage = new RealImage("test_image.jpg");

        // 创建调用处理器
        ImageInvocationHandler handler = new ImageInvocationHandler(realImage);

        // 创建代理对象
        Image proxy = (Image) Proxy.newProxyInstance(
                Image.class.getClassLoader(), // 类加载器
                new Class[] {Image.class}, // 代理类实现的接口列表
                handler // 调用处理器
        );

        // 通过代理对象调用方法
        proxy.display();
    }
}

CGLIB 动态代理：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

// 真实主题 (不需要实现接口)
class RealImage {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }
    public RealImage(){} //需要一个无参构造函数

    private void loadImageFromDisk() {
        System.out.println("Loading image: " + filename);
    }

    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

// 方法拦截器
class ImageMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在调用目标方法之前执行的操作
        System.out.println("Before invoking method: " + method.getName());

        // 调用目标方法
        Object result = proxy.invokeSuper(obj, args);

        // 在调用目标方法之后执行的操作
        System.out.println("After invoking method: " + method.getName());

        return result;
    }
}

// 客户端代码
public class CGLIBDynamicProxyExample {
    public static void main(String[] args) {
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();

        // 设置超类
        enhancer.setSuperclass(RealImage.class);

        // 设置回调
        enhancer.setCallback(new ImageMethodInterceptor());

        // 创建代理对象
        RealImage proxy = (RealImage) enhancer.create();

        // 通过代理对象调用方法
        proxy.display();
    }
}