代理模式（权限、远程调用、延迟加载、日志和缓存）

榴月~

于 2024-09-05 19:46:52 发布

阅读量642

点赞数 18

分类专栏： Java 文章标签：代理模式 java

本文链接：https://blog.csdn.net/qq_34358193/article/details/141939325

版权

Java 专栏收录该内容

56 篇文章 0 订阅

订阅专栏

1、权限保护代理模式

使用 代理模式 实现一个“干饭村约会系统服务”的示例，能够通过代理控制对实际对象（比如用户的约会资料）访问、保护隐私、限制不正当操作等。

需求分析：

用户（Person）：干饭村的用户有自己的个人资料（如名字、性别、兴趣等），他们可以查看自己的和其他人的资料，并且可以修改自己的资料。
代理：分为两种代理：
- 自己代理（Owner Proxy）：允许用户查看和修改自己的资料。
- 其他人代理（Non-Owner Proxy）：允许其他人查看用户的资料，但不允许修改。
约会系统：负责管理用户资料的创建、展示和操作，使用代理控制访问权限。

解决方案：

代理模式：通过创建代理对象来控制对实际对象的访问。我们创建不同的代理类，分别控制用户本人和其他人对其资料的操作权限。

代码实现

1. 创建 `Person` 接口

定义用户基本操作的接口。

public interface Person {
    String getName();
    String getGender();
    String getInterests();
    int getHotOrNotRating();

    void setName(String name);
    void setGender(String gender);
    void setInterests(String interests);
    void setHotOrNotRating(int rating);
}

2. 实现 `PersonImpl` 类（实际的用户类）

这是实际的用户实现，存储用户的资料。

public class PersonImpl implements Person {
    private String name;
    private String gender;
    private String interests;
    private int rating;
    private int ratingCount = 0;

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getGender() {
        return gender;
    }

    @Override
    public String getInterests() {
        return interests;
    }

    @Override
    public int getHotOrNotRating() {
        if (ratingCount == 0) return 0;
        return rating / ratingCount;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public void setInterests(String interests) {
        this.interests = interests;
    }

    @Override
    public void setHotOrNotRating(int rating) {
        this.rating += rating;
        ratingCount++;
    }
}

3. 创建代理 `OwnerProxy` 和 `NonOwnerProxy`

3.1 `OwnerProxy` 类（自己代理）

用户只能修改自己的资料，但不能为自己打分。

public class OwnerProxy implements Person {
    private Person person;

    public OwnerProxy(Person person) {
        this.person = person;
    }

    @Override
    public String getName() {
        return person.getName();
    }

    @Override
    public String getGender() {
        return person.getGender();
    }

    @Override
    public String getInterests() {
        return person.getInterests();
    }

    @Override
    public int getHotOrNotRating() {
        return person.getHotOrNotRating();
    }

    @Override
    public void setName(String name) {
        person.setName(name);
    }

    @Override
    public void setGender(String gender) {
        person.setGender(gender);
    }

    @Override
    public void setInterests(String interests) {
        person.setInterests(interests);
    }

    @Override
    public void setHotOrNotRating(int rating) {
        throw new UnsupportedOperationException("You cannot rate yourself.");
    }
}

3.2 `NonOwnerProxy` 类（其他人代理）

其他人可以查看用户的资料并为其打分，但不能修改资料。

public class NonOwnerProxy implements Person {
    private Person person;

    public NonOwnerProxy(Person person) {
        this.person = person;
    }

    @Override
    public String getName() {
        return person.getName();
    }

    @Override
    public String getGender() {
        return person.getGender();
    }

    @Override
    public String getInterests() {
        return person.getInterests();
    }

    @Override
    public int getHotOrNotRating() {
        return person.getHotOrNotRating();
    }

    @Override
    public void setName(String name) {
        throw new UnsupportedOperationException("You cannot change someone else's name.");
    }

    @Override
    public void setGender(String gender) {
        throw new UnsupportedOperationException("You cannot change someone else's gender.");
    }

    @Override
    public void setInterests(String interests) {
        throw new UnsupportedOperationException("You cannot change someone else's interests.");
    }

    @Override
    public void setHotOrNotRating(int rating) {
        person.setHotOrNotRating(rating);
    }
}

4. 创建 `PersonProxyFactory` 工厂类

用于创建不同类型的代理。

public class PersonProxyFactory {
    public static Person getOwnerProxy(Person person) {
        return new OwnerProxy(person);
    }

    public static Person getNonOwnerProxy(Person person) {
        return new NonOwnerProxy(person);
    }
}

5. 测试代码

展示如何使用代理模式控制用户资料的访问权限。

public class DatingSystemTest {
    public static void main(String[] args) {
        Person joe = new PersonImpl();
        joe.setName("Joe");
        joe.setGender("Male");
        joe.setInterests("Eating, Cooking");

        // 作为自己访问
        Person ownerProxy = PersonProxyFactory.getOwnerProxy(joe);
        System.out.println("Name: " + ownerProxy.getName());
        ownerProxy.setInterests("Gaming, Running"); // 修改成功
        try {
            ownerProxy.setHotOrNotRating(10); // 无法为自己打分
        } catch (Exception e) {
            System.out.println("Cannot rate yourself.");
        }

        // 作为他人访问
        Person nonOwnerProxy = PersonProxyFactory.getNonOwnerProxy(joe);
        System.out.println("Name: " + nonOwnerProxy.getName());
        try {
            nonOwnerProxy.setInterests("Hiking"); // 无法修改他人资料
        } catch (Exception e) {
            System.out.println("Cannot modify interests.");
        }
        nonOwnerProxy.setHotOrNotRating(8); // 允许为他人打分
        System.out.println("Rating: " + nonOwnerProxy.getHotOrNotRating());
    }
}

输出结果：

Name: Joe
Cannot rate yourself.
Name: Joe
Cannot modify interests.
Rating: 8

代码解释：

Person 接口：定义了用户的基本操作，如获取和设置姓名、性别、兴趣以及打分等功能。
PersonImpl 类：用户的实际实现类，存储用户的基本信息。
代理类：
- OwnerProxy：允许用户修改自己的资料，但不允许为自己打分。
- NonOwnerProxy：允许其他人查看用户的资料并为其打分，但不允许修改资料。
PersonProxyFactory：通过该工厂类，可以为用户生成自己代理（OwnerProxy）或他人代理（NonOwnerProxy）。
DatingSystemTest：测试代理模式的功能，展示不同代理如何控制对用户资料的访问。

代理模式的优点：

控制访问：可以为不同的用户提供不同的权限。比如用户自己可以修改资料，而其他人只能查看并打分。
保护敏感信息：通过代理可以防止不正当操作，保护用户隐私和资料安全。
灵活性：代理类可以很容易地根据需求调整行为。

2、远程调用

远程调用（Remote Method Invocation, RMI）是一种允许对象在不同的 Java 虚拟机中调用方法的机制，适用于分布式系统。在 RMI 中，客户端可以通过代理（代理模式）调用远程服务器上的方法，而不需要知道方法的具体实现。

Java RMI 示例

我们将通过一个简单的 Java RMI 示例来展示如何进行远程调用。假设我们有一个远程接口 Calculator，客户端可以调用远程服务器上的加法和减法操作。

步骤：

定义远程接口 Calculator
实现远程接口
启动 RMI 注册表并绑定远程对象
编写客户端来调用远程对象

1. 创建远程接口 `Calculator`

远程接口需要继承 java.rmi.Remote 接口，并声明所有的远程方法可能抛出的 RemoteException。

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculator extends Remote {
    // 声明远程方法
    int add(int a, int b) throws RemoteException;
    int subtract(int a, int b) throws RemoteException;
}

2. 实现远程接口

远程对象的实现类需要继承 UnicastRemoteObject，这是为了使对象可以被远程调用。

import java.rmi.server.UnicastRemoteObject;
import java.rmi.RemoteException;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    
    // 必须定义一个构造器，并抛出 RemoteException
    protected CalculatorImpl() throws RemoteException {
        super();
    }

    @Override
    public int add(int a, int b) throws RemoteException {
        return a + b;
    }

    @Override
    public int subtract(int a, int b) throws RemoteException {
        return a - b;
    }
}

3. 创建服务器端

服务器端需要启动 RMI 注册表，并将远程对象绑定到注册表中，使客户端能够通过注册表获取该远程对象。

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class CalculatorServer {
    public static void main(String[] args) {
        try {
            // 启动 RMI 注册表，默认端口是 1099
            LocateRegistry.createRegistry(1099);

            // 创建远程对象
            Calculator calculator = new CalculatorImpl();

            // 绑定远程对象到 RMI 注册表
            Naming.rebind("rmi://localhost:1099/CalculatorService", calculator);

            System.out.println("Calculator Service is running...");
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 创建客户端

客户端通过 RMI 注册表查找远程对象，并调用其方法。

import java.rmi.Naming;

public class CalculatorClient {
    public static void main(String[] args) {
        try {
            // 查找远程对象
            Calculator calculator = (Calculator) Naming.lookup("rmi://localhost:1099/CalculatorService");

            // 调用远程方法
            int sum = calculator.add(5, 3);
            int difference = calculator.subtract(10, 4);

            System.out.println("Sum: " + sum);
            System.out.println("Difference: " + difference);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5. 编译和运行

编译步骤：

先编译所有类：

javac Calculator.java CalculatorImpl.java CalculatorServer.java CalculatorClient.java

运行 RMI 注册表：
在命令行中输入：
```
rmiregistry
```
注意：RMI 注册表必须在服务器启动之前启动。否则，服务器端程序将无法绑定远程对象。
启动服务器：
在命令行中运行：
```
java CalculatorServer
```
运行客户端：
在客户端机器或同一台机器上，运行客户端程序：
```
java CalculatorClient
```

6. 运行结果：

当客户端成功调用远程方法时，输出类似如下：

Sum: 8
Difference: 6

解释：

Calculator 接口：定义了远程服务的行为，客户端和服务器都需要这个接口。
CalculatorImpl 类：这是远程服务的实际实现，服务器将它绑定到 RMI 注册表中。
服务器端：通过 LocateRegistry.createRegistry() 创建一个 RMI 注册表，然后使用 Naming.rebind() 方法将远程对象绑定到特定名称（在这个例子中是 CalculatorService）。
客户端：通过 Naming.lookup() 查找远程对象，然后调用远程对象的方法。RMI 底层处理网络通信，客户端可以像调用本地方法一样调用远程方法。

总结：

RMI 的核心思想是让客户端可以透明地调用位于远程服务器上的方法，就像调用本地对象的方法一样。
在实现时，接口用于定义服务契约，客户端和服务器都依赖接口进行通信。
代理模式在 RMI 中的应用体现在客户端通过代理对象（远程对象的存根）调用远程服务，而不是直接操作远程服务对象。

3、延迟加载

延迟加载代理模式（Virtual Proxy）是代理模式的一种，它用于推迟对昂贵资源的加载，直到真正需要时才初始化该资源。这种模式适用于那些初始化成本高但并非总是立即使用的对象，比如图像、文件等。

下面是一个基于延迟加载代理模式的 Java 示例：假设我们有一个图像浏览器，图像可能非常大，所以我们希望在需要显示时才加载图像。

示例场景：

Image 接口：定义图像的行为。
RealImage 类：实际的图像类，加载图像的过程可能比较耗时。
ImageProxy 类：代理类，只有在需要显示图像时才加载 RealImage。
Client：客户端使用图像代理来控制加载。

代码实现

1. 定义 `Image` 接口

首先定义 Image 接口，包含一个 display() 方法，用于显示图像。

public interface Image {
    void display();
}

2. 创建 `RealImage` 类

RealImage 类是图像的实际实现类，加载过程可能比较耗时，比如从磁盘加载大文件。在构造函数中模拟加载过程。

public class RealImage implements Image {
    private String filename;

    // 模拟加载过程
    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    // 模拟图像从磁盘加载的操作
    private void loadImageFromDisk() {
        System.out.println("Loading image from disk: " + filename);
        try {
            Thread.sleep(3000); // 模拟耗时的加载
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void display() {
        System.out.println("Displaying image: " + filename);
    }
}

3. 创建 `ImageProxy` 类（延迟加载代理）

代理类 ImageProxy 实现 Image 接口，但它不会立即加载图像，只有在调用 display() 方法时才初始化 RealImage。

public class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;

    public ImageProxy(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        // 延迟加载 RealImage，只有在真正需要时才初始化
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

4. 测试客户端

客户端不直接与 RealImage 交互，而是通过代理 ImageProxy 访问图像。

public class Client {
    public static void main(String[] args) {
        Image image1 = new ImageProxy("photo1.jpg");
        Image image2 = new ImageProxy("photo2.jpg");

        // 图像还未被加载，此时不显示加载信息
        System.out.println("Images are created, but not loaded yet.");

        // 当需要显示图像时，图像才会被加载
        image1.display();  // 第一次显示图像，加载后再显示
        image1.display();  // 第二次显示图像，已经加载过，直接显示

        image2.display();  // 第一次显示图像，加载后再显示
    }
}

输出结果

Images are created, but not loaded yet.
Loading image from disk: photo1.jpg
Displaying image: photo1.jpg
Displaying image: photo1.jpg
Loading image from disk: photo2.jpg
Displaying image: photo2.jpg

代码分析

Image 接口：定义了图像的基本行为 display()，它是 RealImage 和 ImageProxy 共同的接口。
RealImage 类：这是实际的图像实现类，包含从磁盘加载图像的模拟过程（耗时操作），并实现了 display() 方法来显示图像。
ImageProxy 类：代理类实现了 Image 接口，但它控制 RealImage 的创建和加载。只有在 display() 方法被调用时，ImageProxy 才会创建 RealImage 对象并调用它的 display() 方法。这种设计避免了不必要的图像加载，从而提高了性能。
延迟加载：图像只有在需要显示时才会加载，这就是延迟加载的特点。如果客户端从不调用 display() 方法，图像也不会被加载。

延迟加载代理模式的优点

性能优化：通过延迟加载减少不必要的初始化操作，特别是在加载过程非常耗时的情况下。
资源节省：当图像、文件或其他资源较大或较多时，代理模式可以有效节省内存和CPU资源。
透明性：客户端代码不需要改变，仍然使用统一的 Image 接口，代理类控制实际的加载过程。

适用场景

当对象的创建开销非常大，且并非每次都会使用到时。
当需要延迟加载某些资源，比如大文件、图像、数据库连接等。
在某些情况下，可以在需要时才执行某些昂贵的操作，而不是在对象初始化时立即执行。

通过这个示例，延迟加载代理模式 通过代理对象在需要时才实例化真正的对象，避免了不必要的资源浪费，提高了系统性能。

4、日志和缓存代理模式

日志代理模式和缓存代理模式都是代理模式的扩展，用于在不改变原始类代码的情况下添加额外的功能。日志代理用于记录方法调用日志，而缓存代理用于减少重复计算或数据获取，提升性能。

下面是基于 日志代理模式 和 缓存代理模式 的示例代码，展示如何使用代理模式记录方法调用日志和缓存计算结果。

示例场景

假设我们有一个简单的计算器类，进行一些复杂计算。我们将使用日志代理记录每次计算的调用，使用缓存代理存储计算结果以避免重复计算。

1. 创建 `Calculator` 接口

定义一个基本的 Calculator 接口，包含一个用于进行复杂计算的方法 compute()。

public interface Calculator {
    int compute(int a, int b);
}

2. 实现 `Calculator` 类

RealCalculator 类是计算器的实际实现类，它执行复杂的计算操作。在此示例中，假设 compute() 方法执行复杂的乘法运算。

public class RealCalculator implements Calculator {
    @Override
    public int compute(int a, int b) {
        // 假设这是一个耗时的计算
        System.out.println("Performing complex calculation...");
        return a * b;
    }
}

3. 日志代理类 `LoggingProxy`

LoggingProxy 代理类用于记录每次调用 compute() 方法时的日志信息。该代理类会在方法调用前后打印日志，但不改变原始计算逻辑。

public class LoggingProxy implements Calculator {
    private Calculator calculator;

    public LoggingProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public int compute(int a, int b) {
        System.out.println("Logging: About to compute (" + a + ", " + b + ")");
        int result = calculator.compute(a, b);
        System.out.println("Logging: Computation result is " + result);
        return result;
    }
}

4. 缓存代理类 `CachingProxy`

CachingProxy 类用于缓存先前的计算结果，以避免重复计算。它使用一个 Map 来存储输入参数和对应的计算结果。

import java.util.HashMap;
import java.util.Map;

public class CachingProxy implements Calculator {
    private Calculator calculator;
    private Map<String, Integer> cache = new HashMap<>();

    public CachingProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public int compute(int a, int b) {
        String key = a + "," + b;

        // 检查缓存中是否已有该计算结果
        if (cache.containsKey(key)) {
            System.out.println("Cache hit for (" + a + ", " + b + ")");
            return cache.get(key);
        }

        // 如果缓存中没有，进行计算并存入缓存
        int result = calculator.compute(a, b);
        cache.put(key, result);
        return result;
    }
}

5. 测试客户端

在客户端中，我们先创建一个 RealCalculator 实例，然后通过代理类进行调用。

public class Client {
    public static void main(String[] args) {
        // 创建实际的计算器对象
        Calculator realCalculator = new RealCalculator();

        // 包装成日志代理
        Calculator loggingCalculator = new LoggingProxy(realCalculator);

        // 包装成缓存代理
        Calculator cachingCalculator = new CachingProxy(loggingCalculator);

        // 执行一些计算操作
        System.out.println("First calculation:");
        System.out.println("Result: " + cachingCalculator.compute(3, 4));

        System.out.println("\nSecond calculation (same values, should use cache):");
        System.out.println("Result: " + cachingCalculator.compute(3, 4));

        System.out.println("\nThird calculation (different values):");
        System.out.println("Result: " + cachingCalculator.compute(5, 6));
    }
}

6. 运行结果

First calculation:
Logging: About to compute (3, 4)
Performing complex calculation...
Logging: Computation result is 12
Result: 12

Second calculation (same values, should use cache):
Cache hit for (3, 4)
Result: 12

Third calculation (different values):
Logging: About to compute (5, 6)
Performing complex calculation...
Logging: Computation result is 30
Result: 30

代码解释

RealCalculator 类：这是实际的计算类，它执行真实的计算操作。每次调用 compute() 方法时，它都会进行一次“复杂”的计算（在此示例中为乘法）。
LoggingProxy 类：它是日志代理类，用于记录计算的调用过程。在调用 compute() 方法之前，代理类会记录日志，表示即将开始计算；在调用方法之后，代理类会记录计算结果。
CachingProxy 类：它是缓存代理类，负责缓存先前的计算结果，避免重复计算。如果相同的输入参数之前已经计算过，代理类会直接返回缓存中的结果，而不再调用实际的计算逻辑。
客户端：客户端使用代理类来操作计算器对象，而不直接操作 RealCalculator。客户端并不关心计算器是直接执行的还是通过代理执行的，只关心计算的结果。

总结

日志代理模式 可以在不修改原始类的前提下增加方法调用日志记录，方便调试和监控。
缓存代理模式 可以通过缓存计算结果来提高性能，避免重复计算，适用于昂贵的计算任务。
代理模式通过使用代理类包装原始类，增强了系统的灵活性，同时保持了客户端的调用方式不变。

榴月~

关注

18
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
代理模式（权限、远程调用、延迟加载、日志和缓存）

代理模式通过代理对象控制对真实对象的访问，既可以提高系统的安全性和可控性，也可以减少客户端和真实对象之间的耦合。干饭村的约会系统通过代理模式保护用户的个人资料，保证只有自己能够修改资料，而其他人只能查看和打分，从而增强系统的安全性和公平性。RMI 的核心思想是让客户端可以透明地调用位于远程服务器上的方法，就像调用本地对象的方法一样。在实现时，接口用于定义服务契约，客户端和服务器都依赖接口进行通信。
复制链接

扫一扫