设计模式-代理模式

参考：https://blog.csdn.net/weixin_43025343/article/details/131072680

概述

代理模式是一种结构型设计模式，它允许我们通过添加一个代理对象来控制对另一个对象的访问。代理对象和实际对象具有相同的接口，使得客户端在不知情的情况下可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。
在 Java 中，代理模式主要有两种实现方式：静态代理和动态代理。静态代理需要手动编写代理类，通常需要针对每个实际对象编写一个代理类，在系统中管理多个代理类比较麻烦。而动态代理则可以在运行时动态生成代理类，使得客户端代码更加简洁和易于维护。本文将分别介绍这两种代理模式的实现方法和使用场景。

静态代理

静态代理是最基本的代理模式，它需要手动编写代理类。在 Java 中，可以通过实现或继承相同的接口或父类，使得代理对象拥有与实际对象相同的方法和属性。代理对象在调用实际对象的方法时，可以在方法前或方法后添加一些额外的操作，以实现特定的功能。

示例

假设我们需要实现一个简单的计算器程序，我们首先需要定义一个计算器接口：

public interface Calculator {
    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);
}

然后，我们可以实现一个实际的计算器类：

public class RealCalculator implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }

    @Override
    public int mul(int a, int b) {
        return a * b;
    }

    @Override
    public int div(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零");
        }
        return a / b;
    }
}

接下来，我们可以编写一个代理类来控制对计算器对象的访问：

public class CalculatorProxy implements Calculator {
    private final Calculator calculator;
    
    public CalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public int add(int a, int b) {
        System.out.println("执行加法操作");
        return calculator.add(a, b);
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("执行减法操作");
        return calculator.sub(a, b);
    }

    @Override
    public int mul(int a, int b) {
        System.out.println("执行乘法操作");
        return calculator.mul(a, b);
    }

    @Override
    public int div(int a, int b) {
        System.out.println("执行除法操作");
        return calculator.div(a, b);
    }
}

在上面的代码中，我们使用一个 CalculatorProxy 类来代理计算器对象。当客户端调用代理类的方法时，代理类会通过实际对象来真正执行计算操作。在代理类的方法前或方法后，可以添加一些额外的操作，例如日志记录、性能监控等。

使用场景

对象创建和销毁比较频繁，例如数据库连接池等场景；
在调用实际对象的方法前或方法后需要添加一些额外的操作，例如日志记录、性能监控等；
对象需要在不同的环境中进行不同的处理，例如权限控制、事务管理等。

缺点

静态代理的实现方式比较简单，但也存在一些问题。首先，由于代理类需要手动编写，因此无法应对复杂的对象结构；其次，代理类与实际对象存在强耦合关系，当实际对象发生变化时需要修改代理类；最后，为每个实际对象编写一个代理类会增加系统中类的数量，使得系统变得更加复杂和难以维护。

动态代理

JDK动态代理

JDK 动态代理是 Java 标准库提供的一种动态代理实现方式，它基于接口代理实现。在 JDK 动态代理中，我们需要通过 java.lang.reflect.Proxy 类来生成代理对象。

假设我们还是需要一个计算器程序，我们可以重新定义一个计算器接口：

public interface Calculator {
    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);
}

然后，我们可以使用 JDK 动态代理来生成代理对象：

public class CalculatorInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
        System.out.println("执行方法前");
        Object result = method.invoke(target, args);
        System.out.println("执行方法后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new RealCalculator();
        CalculatorInvocationHandler handler = new CalculatorInvocationHandler(calculator);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
            calculator.getClass().getClassLoader(),
            calculator.getClass().getInterfaces(),
            handler);

        int a = 1, b = 2;
        System.out.println("add: " + proxy.add(a, b));
        System.out.println("sub: " + proxy.sub(a, b));
        System.out.println("mul: " + proxy.mul(a, b));
        System.out.println("div: " + proxy.div(a, b));
    }
}

在上面的代码中，我们定义了一个 CalculatorInvocationHandler 类来实现 java.lang.reflect.InvocationHandler 接口。当客户端调用代理对象的方法时，JDK 动态代理会自动调用 invoke 方法，并将原始方法的调用转发给 RealCalculator 对象。在 invoke 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

CGlib动态代理

CGLIB 动态代理是一种不基于接口的动态代理实现方式，它可以代理没有实现接口的类。在 CGLIB 动态代理中，我们需要通过 net.sf.cglib.proxy.Enhancer 类来生成代理对象。

假设我们有一个没有实现任何接口的类：

public class UserService {
    public void addUser(String username, String password) {
        System.out.println("add user: " + username + ", " + password);
    }

    public void updateUser(String username, String password) {
        System.out.println("update user: " + username + ", " + password);
    }

    public void deleteUser(String username) {
        System.out.println("delete user: " + username);
    }
}

然后，我们可以使用 CGLIB 动态代理来生成代理对象：

public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("执行方法前");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("执行方法后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());
        UserService proxy = (UserService) enhancer.create();

        proxy.addUser("Tom", "123456");
        proxy.updateUser("Tom", "654321");
        proxy.deleteUser("Tom");
    }
}

在上面的代码中，我们定义了一个 UserServiceInterceptor 类来实现 net.sf.cglib.proxy.MethodInterceptor 接口。当客户端调用代理对象的方法时，CGLIB 动态代理会自动调用 intercept 方法，并将原始方法的调用转发给 UserService 类。在 intercept 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

使用场景

对象结构比较复杂，手动编写代理类比较困难；
需要对多个对象进行代理操作，手动编写代理类比较繁琐；
在不修改实际对象的情况下添加一些额外的功能，例如日志记录、性能监控等。

posted @ 2023-11-20 17:31 hasome 阅读(4) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Hasome

设计模式-代理模式

概述

静态代理

示例

使用场景

缺点

动态代理

JDK动态代理

CGlib动态代理

使用场景

公告