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

代理模式不仅在控制对象访问上展现了其独特的优势，还在功能扩展和系统安全性上起到了重要作用。上期我们介绍了代理模式在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(); // 第二次调用不会再次加载数据
    }
}

代码解析： 在这个虚拟代理的例子中，VirtualProxy 控制了对 HeavyResource 的访问，只有在第一次调用 load 方法时才会加载实际资源，后续调用不会再次加载，这种模式非常适合需要优化性能的场景。

适用场景

代理模式的应用非常广泛，以下是一些典型的场景：

• 远程代理（Remote Proxy）：在分布式系统中，客户端通过代理与远程服务器交互，隐藏底层的复杂网络通信；
• 虚拟代理（Virtual Proxy）：当创建昂贵对象时，虚拟代理可以延迟对象的创建，直到真正需要时再进行实例化，如大型图片的延迟加载；
• 保护代理（Protection Proxy）：在权限控制系统中，通过代理来控制对敏感数据或操作的访问权限，不同用户的权限判断就是一个典型应用；
• 缓存代理（Caching Proxy）：代理模式可以缓存频繁访问的结果，减少系统负载并提升响应速度，例如缓存数据库查询结果。

优缺点

优点：

• 功能增强：代理模式允许你在不修改原始对象的情况下，添加新的功能；
• 访问控制：代理模式可以帮助控制对原始对象的访问权限，提升系统的安全性和稳定性。

缺点：

• 增加复杂性：引入代理模式后，系统的复杂性会增加，尤其是在多个代理叠加使用时；
• 性能开销：代理模式可能会带来额外的性能开销，特别是在频繁调用的场景中，这一点需要特别注意。

总结

通过这篇文章，希望读者能够更好地理解代理模式在Java中的实现，并能够在实际开发中灵活应用这种设计模式。如果你有任何疑问或想法，欢迎在下方留言！别忘了关注我们的公众号，获取更多有趣的编程知识和实用的代码技巧，我们期待与你的交流与分享！