灵巧守门员——代理模式（Java实现）

news2024/11/15 7:01:11

代理模式不仅在控制对象访问上展现了其独特的优势，还在功能扩展和系统安全性上起到了重要作用。上期我们介绍了代理模式在Python中的实现，今天，我们将继续探讨代理模式，并展示如何在Java中实现它。

什么是代理模式？

代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供了一种代理以控制对这些对象的访问；可以把代理模式理解为一个“守门员”，在客户（Client）和真实对象（RealSubject）之间充当中介，控制请求的传递和处理—— 就像你想看一部付费电影时，需要先通过一个“守门员”确认你是否支付了费用，这名守门员就是代理，他会在你访问电影资源之前先做一些检查，确保你有权利观看。

UML图

示意图

代码实现

接下来，我们通过代码展示如何在Java中实现一些常用的代理模式——静态代理、动态代理、保护代理、虚拟代理。

静态代理实现

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

// 真实对象类
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("真实对象：处理请求。");
    }
}

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

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

    @Override
    public void request() {
        System.out.println("代理：在真实对象之前检查权限。");
        realSubject.request();
        System.out.println("代理：在真实对象之后记录日志。");
    }
}

// 使用代理
public class StaticProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Proxy proxy = new Proxy(realSubject);
        proxy.request();
    }
}

代码解析： 在这个例子中，Proxy 类通过组合的方式持有 RealSubject 的实例，并在 request 方法的执行前后分别加入了权限检查和日志记录功能，静态代理的代理行为在编译时确定，适合结构固定的场景。

动态代理实现

Java中的动态代理通过java.lang.reflect.Proxy类和InvocationHandler接口来实现，它可以在运行时动态生成代理类：

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

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

// 真实对象类
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("真实对象：处理请求。");
    }
}

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

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理：在真实对象之前执行操作。");
        Object result = method.invoke(realObject, args);
        System.out.println("代理：在真实对象之后执行操作。");
        return result;
    }
}

// 使用动态代理
public class DynamicProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Subject proxyInstance = (Subject) Proxy.newProxyInstance(
            realSubject.getClass().getClassLoader(),
            realSubject.getClass().getInterfaces(),
            new DynamicProxyHandler(realSubject)
        );

        proxyInstance.request();
    }
}

代码解析： 在这个例子中，动态代理通过 InvocationHandler 来拦截方法调用，并在调用前后加入了自定义的处理逻辑，动态代理允许我们在运行时为任意接口生成代理对象，非常适合需要灵活扩展的场景。

保护代理实现

保护代理用于控制对对象的访问权限，以下是一个简单的保护代理实现：

// 定义接口
interface Subject {
    void request(String userRole);
}

// 真实对象类
class RealSubject implements Subject {
    @Override
    public void request(String userRole) {
        System.out.println(userRole + " 访问：执行敏感操作。");
    }
}

// 保护代理类
class ProtectionProxy implements Subject {
    private RealSubject realSubject;

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

    @Override
    public void request(String userRole) {
        if ("Admin".equals(userRole)) {
            realSubject.request(userRole);
        } else {
            System.out.println("访问被拒绝：" + userRole + " 没有权限。");
        }
    }
}

// 使用保护代理
public class ProtectionProxyDemo {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProtectionProxy proxy = new ProtectionProxy(realSubject);

        proxy.request("Admin"); // 输出: Admin 访问：执行敏感操作。
        proxy.request("Guest"); // 输出: 访问被拒绝：Guest 没有权限。
    }
}

代码解析： 在这个保护代理的例子中，ProtectionProxy 类根据用户的角色决定是否允许访问真实对象，只有管理员（Admin）角色的用户才能执行操作，其他角色则被拒绝访问，这种模式非常适用于权限控制系统。

虚拟代理实现

虚拟代理用于延迟加载昂贵的资源，只有在真正需要时才创建对象：

// 定义接口
interface Resource {
    void load();
}

// 重型资源类
class HeavyResource implements Resource {
    @Override
    public void load() {
        System.out.println("加载大量数据...");
    }
}

// 虚拟代理类
class VirtualProxy implements Resource {
    private HeavyResource realResource;

    @Override
    public void load() {
        if (realResource == null) {
            realResource = new HeavyResource();
            realResource.load();
        }
        System.out.println("资源已加载，执行操作。");
    }
}

// 使用虚拟代理
public class VirtualProxyDemo {
    public static void main(String[] args) {
        Resource proxy = new VirtualProxy();
        proxy.load(); // 首次调用会加载数据
        proxy.load(); // 第二次调用不会再次加载数据
    }
}