笨蛋学设计模式行为型模式-中介者模式【24】

这篇具有很好参考价值的文章主要介绍了笨蛋学设计模式行为型模式-中介者模式【24】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

8.11中介者模式

8.11.1概念

​ 中介者模式通过引入一个中介者对象来封装一组对象之间的交互,从而可以使这些对象不需要直接相互引用,也就是将系统内多个对象之间的复杂关系转化为多个对象与中介者之间的简单关系。

8.11.2场景

​ 在生活中,可以看到不少网红在直播卖货,也可以看出中介者模式。在主播卖货的过程中,由于设计到多个对象,比如商品、观众、平台等,每个对象都有自己的任务和职责,但是它们之间需要相互协调和交互才能顺利完成卖货的过程。其中主播可以充当中介者的角色,负责协调和调度各个对象的交互。

8.11.3优势 / 劣势

  • 增加可扩展性:当需要增加新的交互时,只需添加新的中介类,而不需要修改已有的类
  • 提高可维护性:可以将多个对象之间的交互逻辑集中在一个对象中

  • 额外的复杂性:引入中介者模式会增加系统的复杂性,因为需要定义中介者接口和实现类,以及将原有对象与中介者对象进行交互
  • 中介者对象职责过重:中介者对象需要处理所有对象之间的交互,与整个系统进行挂钩,一旦出现问题,整个系统也会出现问题

8.11.4模式可分为

  • 抽象中介者Mediator:定义中介者的接口,用于各个具体同事对象之间的通信
  • 具体中介者ConcreteMediator:实现抽象中介者接口,负责协调各个具体同事对象的交互关系,它需要知道所有具体同事类,并从具体同事接收消息,向具体同事对象发出命令
  • 抽象同事类Colleague:定义同事类的接口,维护一个对中介者对象的引用,用于通信
  • 具体同事类ConcreteColleague:实现抽象同事类接口,每个具体同事类只知道自己的行为,而不了解其他同事类的情况,因为它们都需要与中介者通信,通过中介者协调与其他同事对象的交互

8.11.5模式

package com.technologystatck.designpattern.mode.tertiumquid;

import java.util.ArrayList;
import java.util.List;

public class TertiumQuid {
    public static void main(String[] args) {
        //创建中介者
        ConcreteMediator mediator = new ConcreteMediator();

        //创建同事对象
        Colleague colleague1 = new ConcreteColleague1(mediator);
        Colleague colleague2 = new ConcreteColleague2(mediator);

        //注册同事对象到中介者
        mediator.register(colleague1);
        mediator.register(colleague2);

        //同事对象发送消息
        colleague1.send("Hello, colleague2!");
        colleague2.send("Hello, colleague1!");
    }
}

//抽象中介者
abstract class Mediator {
    void register(Colleague colleague){};

    //定义一个抽象的发送消息方法
    public abstract void send(String message, Colleague colleague);

}

//具体中介者
class ConcreteMediator extends Mediator{
    private List<Colleague> colleagues = new ArrayList<>();

    @Override
    public void register(Colleague colleague) {
        colleagues.add(colleague);
    }

    @Override
    public void send(String message,Colleague colleague) {
        for (Colleague c : colleagues) {
            //排除发送消息的同事对象
            if(c!=colleague){
                c.receive(message);
            }
        }
    }
}

//抽象同事对象
abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator=mediator;
    }

    //发送消息
    public abstract void send(String message);

    //接收消息
    public abstract void receive(String message);
}

//具体同事对象1
class ConcreteColleague1 extends Colleague{
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        mediator.send(message,this);
    }

    @Override
    public void receive(String message) {
        System.out.println("ConcreteColleague1 received: "+message);
    }
}

//具体同事对象2
class ConcreteColleague2 extends Colleague{

    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        mediator.send(message,this);

    }

    @Override
    public void receive(String message) {
        System.out.println("ConcreteColleague1 received: "+message);

    }
}

8.11.6实战

8.11.6.1题目描述

小明正在设计一个简单的多人聊天室系统,有多个用户和一个聊天室中介者,用户通过中介者进行聊天,请你帮他完成这个系统的设计。

8.11.6.2输入描述

第一行包括一个整数N,表示用户的数量(1 <= N <= 100) 第二行是N个用户,比如User1 User2 User3,用空格分隔 第三行开始,每行包含两个字符串,表示消息的发出者和消息内容,用空格分隔

8.11.6.3输出描述

对于每个用户,输出一行,包含该用户收到的所有消息内容。文章来源地址https://www.toymoban.com/news/detail-818467.html

8.11.6.4代码
package com.technologystatck.designpattern.mode.tertiumquid;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nums=scanner.nextInt();

        //获取用户名列表,用于创建用户对象。
        ArrayList<String> userNames = new ArrayList<>();
        for(int i=0;i<nums;i++){
            userNames.add(scanner.next());
        }

        ChatRoomMediator mediator = new ChatRoomMediatorImpl();

        //批量创建用户
        for (String userName : userNames) {
            new ConcreteChatUser(userName,mediator);
        }

        //发送消息并输出
        while(scanner.hasNext()){
            String sender = scanner.next();
            String message = scanner.next();

            //获取发送者信息
            //获取信息具体内容
            ChatUser user = mediator.getUsers().get(sender);
            //若用户不为空,则输出信息,否则输出用户不存在。
            if(user!=null){
                user.sendMessage(message);
            }
        }


    }
}

//抽象中介者
interface ChatRoomMediator {
    //发送消息方法
    void sendMessage(String sender,String message);
    //添加用户方法
    void addUser(ChatUser user);
    //获取用户列表方法,用于输出消息时输出用户列表信息
    Map<String,ChatUser> getUsers();
}

//具体中介者
class ChatRoomMediatorImpl implements ChatRoomMediator{
    //用户列表,用于存储所有用户对象,以便后续发送消息时,
    //遍历所有用户对象,并发送消息给所有用户对象。
    private Map<String,ChatUser> users=new LinkedHashMap<>();

    @Override
    public void sendMessage(String sender, String message) {
        //遍历所有用户对象,并发送消息给所有用户对象。
        for(ChatUser user:users.values()){
            if(!user.getName().equals(sender)){
                user.receiveMessage(sender,message);
            }
        }
    }

    @Override
    public void addUser(ChatUser user) {
        users.put(user.getName(),user);
    }

    @Override
    public Map<String, ChatUser> getUsers() {
        return users;
    }
}

//抽象同事类
abstract class ChatUser{
    private String name;
    private ChatRoomMediator mediator;
    private List<String> receivedMessages=new ArrayList<>();

    public ChatUser(String name, ChatRoomMediator mediator) {
        this.name = name;
        this.mediator = mediator;
        mediator.addUser(this);
    }

    public String getName() {
        return name;
    }

    //发送消息的方法,由子类实现,实现不同的发送方式
    public void sendMessage(String message){
        mediator.sendMessage(name,message);
    }

    //接受到消息的方法,由子类实现,实现不同的接受方式
    public abstract void receiveMessage(String sender,String message);

    //获取接受者的消息
    public List<String> getReceivedMessages() {
        return receivedMessages;
    }

    //添加接受者的消息
    protected void addReceivedMessage(String message){
        receivedMessages.add(message);
    }
}

//具体同事类
class ConcreteChatUser extends ChatUser{
    public ConcreteChatUser(String name, ChatRoomMediator mediator) {
        super(name, mediator);
    }

    //接受到消息的方法,实现不同的接受方式
    @Override
    public void receiveMessage(String sender, String message) {
        String receivedMessage=getName()+" received: "+message;

        addReceivedMessage(receivedMessage);
        System.out.println(receivedMessage);
    }
}

8.11.7总结

  • 优点:将多个对象的复杂关系转化为多个对象与中介者的简单关系
  • 总结:通过引入抽象中介者用于定义中介者的接口完成各个同事对象之间的通信,具体中介者用于实现抽象中介者以及协调具体同事类之间的关系,抽象同事类用于维护一个对中介者对象的引用,具体同事类用于与中介者与其他同事对象通信,可以不用知道其他同事类,来完成多个对象与中介者对象的关系之间的交互
  • 场景:适用于当系统对象之间存在复杂的交互关系或系统需要在不同的对象之间进行灵活的通信时使用

到了这里,关于笨蛋学设计模式行为型模式-中介者模式【24】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式——中介者模式

    中介者模式(Mediator Pattern)是一种行为型设计模式,它旨在减少多个对象之间的相互引用和耦合度。通过引入一个中介对象来封装一系列交互行为,使得原本复杂的网状关系结构转变为星形结构,所有对象与中介者通信而不是彼此直接通信。 抽象中介者(Mediator Interface):

    2024年01月18日
    浏览(36)
  • 设计模式-中介者模式

    本文将详细介绍设计模式中的中介者模式,其中包括,中介者模式的优点、缺点、各组成部分。 中介者模式(Mediator Pattern)是一种设计模式,它定义了一个中介者类,该类将多个对象之间的通信抽象化,使得这些对象可以通过中介者进行通信,从而降低它们之间的直接耦合

    2024年02月09日
    浏览(34)
  • 设计模式之中介者模式

    详细介绍         中介者模式(Mediator Pattern)是一种行为设计模式, 它通过定义一个中介类来封装多个对象之间的交互,使各对象不需要显示地相互引用,从而降低耦合度,提高系统的可维护性和灵活性。中介者模式将原本一对多的网状关系转变为一对多的关系,即每个

    2024年04月29日
    浏览(66)
  • 设计模式篇---中介者模式

    中介者模式:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。 就好比世界各个国家之间可能会产生冲突,但是当产生冲突的时候需要联合国来解决冲突。每个国家之间的关系,就好

    2024年01月22日
    浏览(37)
  • 设计模式(十七)中介者

    义一个对象来封装一系列的对象交互。中介者模式使各对象不需要显示地相互引用,从而使其耦合松散,而且可以让你相对独立地改变它们之间的交互。中介者模式又称为调停模式,它是一种对象说行为型模式。 在中介者模式中,引入了用于协调其他对象/类之间的相互调用

    2024年02月04日
    浏览(38)
  • Java设计模式-中介者模式

    中介者模式,就是用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地互相引用,从而使其耦合松散,而且可以独立的改变它们之间的交互。 其实中介者模式很简单的,就像它的名字一样,中介,调用某个类的某些方法的时候,我们不直接去跟那个类的实

    2024年02月15日
    浏览(39)
  • 大话设计模式之中介者模式

    中介者模式是一种行为型设计模式,它通过引入一个中介者对象来封装一系列对象之间的交互,从而减少对象之间的直接通信,使得对象之间的耦合度降低,同时提高了系统的可维护性和灵活性。 在中介者模式中,对象之间的通信不再直接发生,而是通过中介者对象来进行。

    2024年04月16日
    浏览(42)
  • 设计模式- 中介者模式(Mediator)

    中介者模式(Mediator Pattern),是一种对象行为型模式。该模式的主要目的是定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合变得松散,并且可以独立地改变它们之间的交互。 抽象中介者(Mediator) :这是中介者模式的核心接口,它定义了同事对象注

    2024年04月26日
    浏览(36)
  • 经典的设计模式17——中介者模式

    定义: 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变他们之间的交互。 结构: 抽象中介者角色:是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。 具体中介者角色:实现中

    2024年02月09日
    浏览(41)
  • C++ 设计模式之 中介者模式

    【声明】本题目来源于卡码网(题目页面 (kamacoder.com)) 【提示:如果不想看文字介绍,可以直接跳转到C++编码部分】         -- 什么是中介者模式  (第16种模式)          中介者模式 (Mediator Pattern)也被称为 调停者模式 ,是⼀种 ⾏为型设计模式 ,它通过⼀个中介

    2024年01月19日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包