Java代理模式

Java代理模式

代理模式是一种常见的结构型设计模式，其目的是为另一个对象提供一个占位符或代理以控制对该对象的访问。代理对象充当另一个对象的接口，从而为基础对象提供一种间接访问方式。

在Java程序设计中，代理模式通常由一个代理类和一个实际类组成。代理类充当客户端和实际类之间的中介，它担负着向实际类传递客户端请求的责任。实际类则执行客户端请求，但是客户端并不直接访问实际类，而是通过代理类来访问。

优点

• 客户端与实际类之间的解耦。代理类充当中介，隔离了客户端和实际类之间的直接联系。
• 可以提高代码的可复用性。由于代理类采用了与实际类相似的接口，使得代理对象可以在不影响客户端的情况下被替换。
• 可以提高程序性能。代理类可以控制对实际类的访问，可以在需要时缓存实际类的结果，从而提高程序的执行效率。

缺点

• 增加代码实现的复杂度。代理类的引入增加了程序的复杂度，需要开发人员额外去设计和实现代理类。
• 可能会降低程序的执行效率。由于代理类需要额外的处理，可能会导致程序执行效率较低。

代码示例

下面是一个简单的计算器应用程序，其中定义了两个接口，分别是计算器和日志记录器。使用代理模式，客户端不直接访问计算器对象，而是通过代理对象来访问。代理对象会将客户端的请求传递给实际的计算器对象，并在执行计算操作时记录运算日志。

计算器接口

public interface Calculator {
    int add(int x, int y);
    int subtract(int x, int y);
    int multiply(int x, int y);
    int divide(int x, int y) throws Exception;
}

计算器实现类

public class SimpleCalculator implements Calculator {
    public int add(int x, int y) {
        return x + y;
    }
    public int subtract(int x, int y) {
        return x - y;
    }
    public int multiply(int x, int y) {
        return x * y;
    }
    public int divide(int x, int y) throws Exception {
        if (y == 0) {
            throw new Exception("Cannot divide by zero");
        }
        return x / y;
    }
}

日志记录器接口

public interface Logger {
    void log(String message);
}

日志记录器实现类

public class ConsoleLogger implements Logger {
    public void log(String message) {
        System.out.println(message);
    }
}

计算器代理类

public class CalculatorProxy implements Calculator {
    private Calculator calculator;
    private Logger logger;

    public CalculatorProxy(Calculator calculator, Logger logger) {
        this.calculator = calculator;
        this.logger = logger;
    }

    public int add(int x, int y) {
        int result = calculator.add(x, y);
        logger.log(x + " + " + y + " = " + result);
        return result;
    }

    public int subtract(int x, int y) {
        int result = calculator.subtract(x, y);
        logger.log(x + " - " + y + " = " + result);
        return result;
    }

    public int multiply(int x, int y) {
        int result = calculator.multiply(x, y);
        logger.log(x + " * " + y + " = " + result);
        return result;
    }

    public int divide(int x, int y) throws Exception {
        int result = calculator.divide(x, y);
        logger.log(x + " / " + y + " = " + result);
        return result;
    }
}

客户端代码

public class Main {
    public static void main(String[] args) throws Exception {
        Calculator calculator = new SimpleCalculator();
        Logger logger = new ConsoleLogger();
        Calculator proxy = new CalculatorProxy(calculator, logger);

        System.out.println("Addition: " + proxy.add(2, 3));
        System.out.println("Subtraction: " + proxy.subtract(5, 3));
        System.out.println("Multiplication: " + proxy.multiply(2, 3));
        System.out.println("Division: " + proxy.divide(10, 2));
    }
}

输出结果

2 + 3 = 5
Addition: 5
5 - 3 = 2
Subtraction: 2
2 * 3 = 6
Multiplication: 6
10 / 2 = 5
Division: 5

在这个示例中，我们定义了两个接口，一个代表计算器，一个代表日志记录器。然后我们实现了这两个接口的实现类，并定义了一个计算器代理类。客户端代码创建了一个计算器代理对象，并通过代理对象调用计算器方法。在执行计算操作时，代理对象会记录运算日志。

总结

代理模式是一种常见的结构型设计模式，它可以将客户端与实际类之间解耦，并提高程序的可复用性和性能。在Java程序设计中，代理模式通常由一个代理类和一个实际类组成。代理类充当中介，隔离了客户端和实际类之间的直接联系。代理类采用了与实际类相似的接口，使得代理对象可以在不影响客户端的情况下被替换。但是代理模式也存在一些缺点，可能会增加代码实现的复杂性，以及降低程序的执行效率。