• Java设计模式-中介者模式


    简介

    在软件开发中,设计模式是一种被广泛使用的技术,它提供了解决常见问题的可重用方案。中介者模式是其中之一,它通过引入一个中介对象,将各个对象之间的交互解耦,以实现更松散耦合和可维护的系统。

    访问者模式是一种行为型设计模式,它允许你在不改变元素类的前提下定义新的操作。该模式将算法封装在一个访问者对象中,通过访问者对象遍历对象结构,并对每个元素执行相应的操作。元素类不需要关心操作的细节,只需接受访问者的访问。

    中介者模式是一种行为型设计模式,它旨在减少对象之间的直接耦合,通过引入一个中介对象来协调对象之间的通信。这个中介者对象充当了协调者和调解者的角色,它封装了一组对象之间的交互方式,使得这些对象可以松散地进行通信,而不需要直接相互引用。中介者模式使得对象之间的关系更加清晰,易于扩展和维护。

    与其他设计模式的区别 中介者模式与观察者模式和策略模式有一些相似之处,但它们之间仍存在一些区别。

    1. 观察者模式: 观察者模式通过定义一对多的依赖关系,当一个对象的状态发生变化时,它的所有依赖对象都会收到通知并自动更新。观察者模式注重的是对象之间的发布-订阅关系,而中介者模式则注重的是对象之间的协调和通信。
    2. 策略模式: 策略模式通过将一组可互换的行为封装在独立的策略类中,使得这些行为可以动态地替换。策略模式注重的是行为的封装和替换,而中介者模式则注重的是对象之间的交互和协调。

    实现

    步骤1: 定义中介者接口
    首先,我们需要定义一个中介者接口,该接口声明了对象之间的交互方法。以下是一个简单的示例:

    public interface Mediator {
        void sendMessage(String message, Colleague colleague);
    }
    
    • 1
    • 2
    • 3

    步骤2: 实现具体的中介者类
    接下来,我们可以实现具体的中介者类,该类实现了中介者接口,并负责协调对象之间的通信。以下是一个示例:

    public class ConcreteMediator implements Mediator {
        private Colleague colleague1;
        private Colleague colleague2;
    
        public void setColleague1(Colleague colleague1) {
            this.colleague1 = colleague1;
        }
    
        public void setColleague2(Colleague colleague2) {
            this.colleague2 = colleague2;
        }
    
        @Override
        public void sendMessage(String message, Colleague colleague) {
            if (colleague == colleague1) {
                colleague2.receiveMessage(message);
            } else if (colleague == colleague2) {
                colleague1.receiveMessage(message);
            }
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    步骤3: 定义对象接口
    每个参与中介者模式的对象都需要实现一个对象接口,该接口定义了对象与中介者之间的交互方法。以下是一个简单的示例:

    public interface Colleague {
        void sendMessage(String message);
        void receiveMessage(String message);
    }
    
    • 1
    • 2
    • 3
    • 4

    步骤4: 实现具体的对象类
    最后,我们可以实现具体的对象类,这些类实现了对象接口,并通过中介者进行交互。以下是一个示例:

    public class ConcreteColleague1 implements Colleague {
        private Mediator mediator;
    
        public ConcreteColleague1(Mediator mediator) {
            this.mediator = mediator;
        }
    
        @Override
        public void sendMessage(String message) {
            mediator.sendMessage(message, this);
        }
    
        @Override
        public void receiveMessage(String message) {
            System.out.println("ConcreteColleague1 received: " + message);
        }
    }
    
    public class ConcreteColleague2 implements Colleague {
        private Mediator mediator;
    
        public ConcreteColleague2(Mediator mediator) {
            this.mediator = mediator;
        }
    
        @Override
        public void sendMessage(String message) {
            mediator.sendMessage(message, this);
        }
    
        @Override
        public void receiveMessage(String message) {
            System.out.println("ConcreteColleague2 received: " + message);
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    示例用法:

    public class MediatorExample {
        public static void main(String[] args) {
            ConcreteMediator mediator = new ConcreteMediator();
    
            ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
            ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
    
            mediator.setColleague1(colleague1);
            mediator.setColleague2(colleague2);
    
            colleague1.sendMessage("Hello from Colleague1!");
            colleague2.sendMessage("Hi from Colleague2!");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    在上述示例中,我们创建了一个中介者对象(ConcreteMediator)和两个具体对象(ConcreteColleague1和ConcreteColleague2)。通过中介者

    对象,这两个具体对象可以通过sendMessage方法向彼此发送消息。中介者负责接收消息并将其传递给目标对象。

    通过这种方式,我们成功地使用Java语言实现了中介者模式。通过中介者模式,对象之间的耦合性得到了降低,它们之间的通信更加简单和可维护。

    优缺点

    优点

    1. 解耦对象之间的关系:中介者模式通过引入中介者对象,将对象之间的直接耦合解耦,使得它们可以独立变化,易于维护和扩展。
    2. 促进对象之间的松散耦合:中介者模式将对象之间的交互集中在中介者对象上,使得对象之间的通信更加简单直观,避免了复杂的相互引用。
    3. 集中控制逻辑:中介者模式使得系统逻辑集中在中介者对象中,易于管理和修改。

    缺点

    1. 中介者对象可能变得复杂:随着参与中介者模式的对象增加,中介者对象的责任和复杂性可能增加,导致中介者对象的设计和维护变得困难。
    2. 可能降低系统性能:由于中介者模式引入了一个额外的中介者对象,可能会增加对象之间的通信成本,从而导致一定程度上的性能下降。

    运用场景

    1. 对象之间存在复杂的相互关系,彼此之间的交互逻辑难以管理和维护。
    2. 一个对象的变化需要引起其他相关对象的变化,并且这些对象之间的关系较为动态。
    3. 希望减少对象之间的直接依赖关系,以提高系统的灵活性和可维护性。

    总结

    中介者模式是一种有助于减少对象之间直接耦合的设计模式。通过引入一个中介者对象,对象之间的通信变得更加松散,易于维护和扩展。本文介绍了中介者模式的概念和与其他设计模式的区别,并使用Java编程语言实现了该模式。同时,我们还探讨了中介者模式的优缺点和适用场景。通过理解和应用中介者模式,开发人员可以构建更加灵活、可维护的系统。

  • 相关阅读:
    2022 全球 AI 模型周报
    大数据之湖仓一体,未来如何发展
    UE4_UE5播放视频(附工程)
    Node.js躬行记(18)——半吊子的可视化搭建系统
    第十三届蓝桥杯C++C组省赛H题—— 重新排序(AC)
    利用正则表达式进行数据采集和处理
    算法练习16——O(1) 时间插入、删除和获取随机元素
    【AWS系列】第八讲:AWS Serverless之S3
    【语音识别入门】概述
    胖小酱之贪婪的萨米提寓言故事
  • 原文地址:https://blog.csdn.net/yucdsn/article/details/130914633