常见设计模式-代理模式-CSDN博客

定义：

代理模式提供了一个对象的代理，以控制对这个对象的访问。代理对象作为客户端和目标对象之间的中介，可以在不修改目标对象的前提下，增加额外的功能，如访问控制、延迟加载、日志记录、缓存等。

代理模式分类：

代理模式通常分为 静态代理 和 动态代理 两种。静态代理需要为每个目标类创建一个代理类，而动态代理则可以 在运行时 动态地创建代理类，无需为每个目标类编写单独的代理类代码。

静态代理（模拟记录日志）：

在加载图片之前和之后添加了一些额外的逻辑，比如记录日志。

// ImageService 接口
interface ImageService {
    void loadImage(String imagePath);
}

// RealImageService 类，实现 ImageService 接口
class RealImageService implements ImageService {
    @Override
    public void loadImage(String imagePath) {
        // 模拟加载图片的过程
        System.out.println("加载图片：" + imagePath);
    }
}

// ImageServiceProxy 类，作为静态代理
class ImageServiceProxy implements ImageService {
    private RealImageService realService;

    public ImageServiceProxy(RealImageService realService) {
        this.realService = realService;
    }

    @Override
    public void loadImage(String imagePath) {
        // 在加载图片之前记录日志
        System.out.println("加载图片之前日志信息。。。");
        realService.loadImage(imagePath);
        // 在加载图片之后记录日志
        System.out.println("加载图片之后日志信息。。。");
    }
}

// 客户端代码
public class StaticProxyDemo {
    public static void main(String[] args) {
        RealImageService realService = new RealImageService();
        ImageService proxy = new ImageServiceProxy(realService);
        proxy.loadImage("path/to/image.jpg");
    }
}

动态代理（模拟更新缓存）：

在调用 getData 方法时会首先检查缓存，如果缓存中有数据则直接返回，否则调用 RealDataService 来获取数据并更新缓存。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

// DataService 接口
interface DataService {
    String getData(String key);
}

// RealDataService 类，实现 DataService 接口
class RealDataService implements DataService {
    @Override
    public String getData(String key) {
        // 模拟从数据库或其他来源获取数据
        System.out.println("获取数据：" + key);
        return "缓存数据为：" + key;
    }
}

// DataServiceInvocationHandler 类，作为动态代理的处理器
class DataServiceInvocationHandler implements InvocationHandler {
    private Object target;
    private Map<String, String> cache = new HashMap<>();

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String key = (String) args[0];
        //判断是否为 getData 方法
        if ("getData".equals(method.getName())) {
            // 检查缓存
            if (cache.containsKey(key)) {
                System.out.println("存在缓存: " + key);
                return cache.get(key);
            }
            // 缓存中没有数据，调用目标对象的方法获取数据
            String data = (String) method.invoke(target, args);
            // 更新缓存
            cache.put(key, data);
            System.out.println("更新缓存" + data);
            return data;
        }
        // 如果不是 getData 方法，则直接调用目标对象的方法
        return method.invoke(target, args);
    }
}

// 客户端代码
public class DynamicProxyDemo {
    public static void main(String[] args) {
        RealDataService realService = new RealDataService();
        DataService proxyInstance = (DataService) Proxy.newProxyInstance(
                realService.getClass().getClassLoader(),
                realService.getClass().getInterfaces(),
                new DataServiceInvocationHandler(realService)
        );

        // 第一次调用，数据不在缓存中，应该调用 RealDataService
        System.out.println(proxyInstance.getData("key1"));

        // 第二次调用，数据已经在缓存中，应该直接返回缓存的数据
        System.out.println(proxyInstance.getData("key1"));
    }
}