代理模式

字数: 0 字 时长: 0 分钟

简介

代理模式（Proxy Pattern）核心思想是：给某个对象提供一个代理对象，并由代理对象来控制对这个对象的访问。其实真实业务逻辑还是真实对象执行的，代理对象只是可以在不改变原生对象代码情况下，对原始对象进行功能增强或控制访问。

UML 类图

• 主题接口（Subject）：定义了真实对象和代理对象都需要实现的方法
• 真实主题（RealSubject）：目标对象，真正去执行核心业务逻辑
• 代理主题（ProxySubject）：代理对象，内部维护一个真实对象的引用，在调用前后进行功能增强

实现示例

延迟加载

利用代理模式来增强真实对象方法，实现延迟加载

// 1. 主题接口 （大文件操作）
interface LargeFile {
    void download();
}

// 2. 真实对象实现  -- 加载成本高
class RealLargeFile implements LargeFile {
    private String fileName;
    public RealLargeFile(String fileName) {
        this.fileName = fileName;
        System.out.println("开始耗时加载任务：" + fileName);
    }
    @Override
    public void download() {
        System.out.println("开始下载：" + fileName);
    }
}

// 3. 代理对象实现
class ProxyLargeFile implements LargeFile {
    private String fileName;
    // 内部维护一个真实对象引用
    private RealLargeFile realFile;
    public ProxyLargeFile(String fileName) {
        this.fileName = fileName;
    }
    @Override
    public void download() {
        // 进行访问增强（首次访问才加载真实对象）
        if (realFile == null) {
            realFile = new RealLargeFile(fileName);
        }
        realFile.download();
    }
}

// 4. 客户端调用
public static void main(String[] args) {
    LargeFile file = new LargeFileProxy("大文件.zip");
    // ... 用户操作
    
    // 直到访问时才加载文件
    file.download();
}

日志代理

利用代理模式来对真实对象进行前置增强和后置增强

// 1. 主题接口 （商务服务接口）
interface BusinessService {
    void operation();
}

// 2. 真实对象 （订单服务）
class OrderService implements BusinessService {
    @Override
    public void operation() {
        System.out.println("订单服务开始处理...");
    }
}

// 3. 代理对象 （日志处理增强）
class LogProxy implements BusinessService {
    private BusinessService realService = new OrderService();
    private Logger logger = Logger.getLogger(LogProxy.class);
    @Override
    public void operation() {
        logger.info("开始处理...");
        realService.operation();
        logger.info("处理完成...");
    }
}

JDK 动态代理

JDK 提供了一整套动态代理实现

public class JdkDynamicProxy {
s
    interface Service {
        void execute();
    }

    static class RealService implements Service {
        @Override
        public void execute() {
            System.out.println("执行实际业务");
        }
    }

    static class ProxyService implements InvocationHandler {
        private Object target;
        public ProxyService(Object target) {
            this.target = target;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            // 调用前增强
            System.out.println(method.getName() + "方法执行前");
            // 执行实际业务
            Object result = method.invoke(target, args);
            // 调用后增强
            System.out.println(method.getName() + "方法执行后");
            return result;
        }
    }

    public static void main(String[] args) {
        Service service = new RealService();
        Service proxy = (Service) Proxy.newProxyInstance(
                Service.class.getClassLoader(),
                new Class<?>[] {Service.class},
                new ProxyService(service)
        );
        proxy.execute();
        /**
         * 输出结果：
         * execute方法执行前
         * 执行实际业务
         * execute方法执行后
         */
    }

}