程序员必知!中介者模式的实战应用与案例分析

发布时间:2024年01月08日

程序员必知!中介者模式的实战应用与案例分析 - 程序员古德

中介者模式通过引入中介类降低对象间耦合度,在电商平台中,卖家、买家、物流公司和支付平台原本需复杂交互,在引入“交易中介”类后,各角色只需与中介交互,由中介协调各方操作,从而简化了交互流程,降低了类间依赖,使系统更灵活可维护。

定义

程序员必知!中介者模式的实战应用与案例分析 - 程序员古德

中介者模式主要用于减少类之间的耦合,它用一个中介类来封装一系列对象间的交互,使这些对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

举一个业务中的例子来说明,假设有一个电商平台,其中有卖家、买家、物流公司和支付平台四个角色,在没有中介者的情况下,这四个角色之间可能需要进行复杂的交互,比如卖家要直接联系物流公司发货,买家要直接联系支付平台进行支付等,这样的设计会导致类之间的耦合度很高,一旦某个角色发生变化,可能会影响到其他角色。

而引入中介者模式后,可以设计一个电商平台的“交易中介”类,这个类中介了卖家、买家、物流公司和支付平台之间的所有交互,卖家只需要将商品信息和买家信息提交给交易中介,交易中介会负责联系物流公司进行发货,并通知买家进行支付,买家支付完成后,交易中介会通知卖家和物流公司更新订单状态,这样,卖家、买家、物流公司和支付平台之间的耦合度就大大降低了,每个角色只需要和交易中介进行交互,而不需要直接和其他角色进行交互。

在这个场景中中,交易中介类就起到了中介者的作用,它将一系列对象间的交互封装起来,使这些对象之间的耦合度降低,提高了系统的灵活性和可维护性。

代码案例

程序员必知!中介者模式的实战应用与案例分析 - 程序员古德

反例

下面是一个未使用中介者模式的反例代码,假如,有一个聊天应用的简单模型,其中包括User(用户)和GroupChat(群聊)类,每个User对象都直接与其他User对象通信,如下代码演示:

public class User {  
    private String name;  
      
    public User(String name) {  
        this.name = name;  
    }  
      
    public String getName() {  
        return name;  
    }  
      
    public void sendMessage(User receiver, String message) {  
        System.out.println(name + " sends a message to " + receiver.getName() + ": " + message);  
    }  
}  
  
public class GroupChat {  
    private List<User> users = new ArrayList<>();  
      
    public void addUser(User user) {  
        users.add(user);  
    }  
      
    public void notifyAllUsers(String message) {  
        for (User user : users) {  
            for (User otherUser : users) {  
                if (!user.equals(otherUser)) {  
                    user.sendMessage(otherUser, message);
                }  
            }  
        }  
    }  
}  
  
public class Client {  
    public static void main(String[] args) {  
        User alice = new User("Alice");  
        User bob = new User("Bob");  
        User charlie = new User("Charlie");  
          
        GroupChat chat = new GroupChat();  
        chat.addUser(alice);  
        chat.addUser(bob);  
        chat.addUser(charlie);  
          

        alice.sendMessage(bob, "Hi Bob, how are you?"); 
        alice.sendMessage(charlie, "Hi Charlie, what's up?"); 
          
        chat.notifyAllUsers("Everyone, there will be a maintenance tonight.");  
    }  
}

输出结果,如下:

Alice sends a message to Bob: Hi Bob, how are you?  
Alice sends a message to Charlie: Hi Charlie, what's up?  
Alice sends a message to Bob: Everyone, there will be a maintenance tonight.  
Alice sends a message to Charlie: Everyone, there will be a maintenance tonight.  
Bob sends a message to Alice: Everyone, there will be a maintenance tonight.  
Bob sends a message to Charlie: Everyone, there will be a maintenance tonight.  
Charlie sends a message to Alice: Everyone, there will be a maintenance tonight.  
Charlie sends a message to Bob: Everyone, there will be a maintenance tonight.

在这个反例中,User类直接持有对其他User对象的引用,并直接调用其方法,这导致了类之间的紧密耦合,因为User类需要知道如何与其他User对象通信,此外,GroupChat类虽然被设计出来,但并没有起到中介消息的作用,实际上,当notifyAllUsers方法被调用时,每个用户都会向其他每个用户发送消息,导致了重复的消息和不必要的复杂性。

正例

下面是一个使用中介者模式的正例代码,在这个例子中,有一个聊天应用的模型,包括User(用户)和ChatMediator(聊天中介)类,ChatMediator类作为中介者,封装了用户之间的通信逻辑,使得用户之间不需要直接相互引用,如下代码:

import java.util.*;  
  
// User.java  
public class User {  
    private String name;  
    private ChatMediator chatMediator;  
      
    public User(String name, ChatMediator chatMediator) {  
        this.name = name;  
        this.chatMediator = chatMediator;  
    }  
      
    public String getName() {  
        return name;  
    }  
      
    // 用户通过中介者发送消息  
    public void sendMessage(String receiverName, String message) {  
        chatMediator.relayMessage(this, receiverName, message);  
    }  
}  
  
// ChatMediator.java  
public class ChatMediator {  
    private Map<String, User> users = new HashMap<>();  
      
    public void registerUser(User user) {  
        users.put(user.getName(), user);  
    }  
      
    // 中介者负责将消息传递给指定的接收者  
    public void relayMessage(User sender, String receiverName, String message) {  
        User receiver = users.get(receiverName);  
        if (receiver != null) {  
            System.out.println(sender.getName() + " sends a message to " + receiver.getName() + ": " + message);  
            // 这里可以添加额外的逻辑,比如记录消息、通知其他服务等  
        } else {  
            System.out.println("Receiver " + receiverName + " is not online.");  
        }  
    }  
}  
  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        // 创建中介者和用户  
        ChatMediator chatMediator = new ChatMediator();  
        User alice = new User("Alice", chatMediator);  
        User bob = new User("Bob", chatMediator);  
          
        // 用户注册到中介者  
        chatMediator.registerUser(alice);  
        chatMediator.registerUser(bob);  
          
        // Alice通过中介者发送消息给Bob  
        alice.sendMessage("Bob", "Hi Bob, how are you?");  
          
        // Bob通过中介者回复消息给Alice  
        bob.sendMessage("Alice", "I'm good, thanks!");  
          
        // 尝试发送消息给一个未注册的用户  
        alice.sendMessage("Charlie", "Hey Charlie, are you there?");  
    }  
}

输出结果:

Alice sends a message to Bob: Hi Bob, how are you?  
Bob sends a message to Alice: I'm good, thanks!  
Receiver Charlie is not online.

在这个正例中,User类不直接持有对其他User对象的引用,而是通过ChatMediator中介者来发送消息,ChatMediator维护了一个用户列表,并负责将消息从发送者传递给接收者,这样,User类之间的耦合度降低了,因为用户不需要知道如何与其他用户直接通信,他们只需要与中介者交互。此外,如果未来需要改变通信方式或添加额外的通信逻辑,只需要修改ChatMediator类即可,而不影响User类。

核心总结

程序员必知!中介者模式的实战应用与案例分析 - 程序员古德

中介者模式总结

通过引入中介者,使得各个组件之间不再直接相互依赖,减少了系统的复杂性,他将原本分散的交互逻辑集中管理,使得这些逻辑更加清晰和易于维护,由于组件间的通信都通过中介者进行,因此添加新组件或修改现有组件的交互方式变得更加容易。但随着系统的扩展,它可能需要处理越来越多的交互逻辑,导致其代码变得庞大且难以维护,为了实现中介者模式,有时可能需要创建额外的抽象类和接口,这可能会增加系统的复杂性和理解难度。

在确实需要降低组件间耦合度的情况下使用中介者模式,避免过度设计,可以考虑与其他设计模式(如观察者模式)结合使用,以实现更灵活和强大的功能。

和其它模式对比

中介者模式和装饰者模式两者的区别:

中介者模式主要用于降低多个对象之间的耦合度,通过引入一个中介者对象,其它所有相关对象都通过该中介者对象进行通信,而不是直接相互引用,当中介者模式中的某一个对象发生改变时,只需要通知中介者对象,由中介者对象负责与其他对象的交互,这样可以简化对象之间的交互,降低系统的复杂性。

装饰者模式则侧重于在不改变对象自身的基础上,动态地给对象添加新的功能或方法,装饰者模式通过创建一个装饰类,将原始类作为成员变量进行包装,并在装饰类中提供与原始类相同的方法,这些方法可以在调用原始类方法之前或之后执行一些额外的操作,这样可以实现对原始类功能的动态扩展,而无需修改原始类的代码。

总结,中介者模式主要用于解决对象之间的紧耦合问题,通过引入中介者来协调对象之间的交互;而装饰者模式则主要用于在不改变原始类的基础上,动态地给对象添加新的功能或方法。

关注我,每天学习互联网编程技术 - 程序员古德

文章来源:https://blog.csdn.net/qusikao/article/details/135455236
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。