（十九）JAVA设计模式23种设计模式之中介者模式实例demo

绝对秋香

于 2021-12-08 10:41:54 发布

阅读量318

点赞数

分类专栏： JAVA23种设计模式及六大原则文章标签： java 中介者模式开发语言

本文链接：https://blog.csdn.net/liqita/article/details/121784122

版权

JAVA23种设计模式及六大原则专栏收录该内容

29 篇文章 4 订阅

订阅专栏

中介者模式是一种行为设计模式，通过创建一个中介对象来协调多个类之间的交互，减少他们之间的耦合。在示例中，房屋中介作为中介者，管理房主（房地产商）和客户之间的沟通。当某一方发送消息时，中介者负责广播给合适的接收方，实现了消息的定向传播。该模式提高了系统的可扩展性和可维护性，但可能导致中介者类过于复杂。

摘要由CSDN通过智能技术生成

Mediator: 抽象中介者
ConcreteMediator: 具体中介者
Colleague: 抽象同事类
ConcreteColleague: 具体同事类

租房各位都有过的经历吧！在这个过程中中介结构扮演着很重要的角色，它在这里起到一个中间者的作用，给我们和房主互相传递信息。在外面软件的世界里同样需要这样一个中间者。在我们的系统中有时候会存在着对象与对象之间存在着很强、复杂的关联关系，如果让他们之间有直接的联系的话，必定会导致整个系统变得非常复杂，而且可扩展性很差！在前面我们就知道如果两个类之间没有不必彼此通信，我们就不应该让他们有直接的关联关系，如果实在是需要通信的话，我们可以通过第三者来转发他们的请求。同样，这里我们利用中介者来解决这个问题。

所谓中介者模式就是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。在中介者模式中，中介对象用来封装对象之间的关系，各个对象可以不需要知道具体的信息通过中介者对象就可以实现相互通信。它减少了对象之间的互相关系，提供了系统可复用性，简化了系统的结构。

在中介者模式中，各个对象不需要互相知道了解，他们只需要知道中介者对象即可，但是中介者对象就必须要知道所有的对象和他们之间的关联关系，正是因为这样就导致了中介者对象的结构过于复杂，承担了过多的职责，同时它也是整个系统的核心所在，它有问题将会导致整个系统的问题。所以如果在系统的设计过程中如果出现“多对多”的复杂关系群时，千万别急着使用中介者模式，而是要仔细思考是不是您设计的系统存在问题。

demo

入口类

package mediator_method_mod;

import org.junit.Test;

/**
 * 中介者模式
 * 中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。
 *
 * 介绍
 * 意图：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
 *
 * 主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。
 *
 * 何时使用：多个类相互耦合，形成了网状结构。
 *
 * 如何解决：将上述网状结构分离为星型结构。
 *
 * 关键代码：对象 Colleague 之间的通信封装到一个类中单独处理。
 *
 * 应用实例： 1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。
 *
 * 优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。
 *
 * 缺点：中介者会庞大，变得复杂难以维护。
 *
 * 使用场景： 1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。
 *
 * 注意事项：不应当在职责混乱的时候使用。
 */
public class Client {
    @Test
    public void test(){
        Mediator mediator = new HouseMediator();

        Colleague colleague1 = new SellColleague("SHELL");//成员一 房地產商
        Colleague colleague2 = new CustomerColleague("VIP");//成员二 客戶
        Colleague colleague3 = new CustomerColleague("VIP");//成员三 客戶
        Colleague colleague4 = new CustomerColleague("NOTVIP");//成员四 客戶

        mediator.registor("中原地產",colleague1);
        mediator.registor("代號張三",colleague2);
        mediator.registor("代號李四",colleague3);
        mediator.registor("代號王五",colleague4);

        System.out.println("\n中介代發佈消息");
        colleague1.sendMsg("VIP","北京一環有一套房，優先提供給VIP客戶");

        System.out.println("\n中介代發佈消息II");
        colleague1.sendMsg("ALL","北京五環有十套房，優質高層大房");

        System.out.println("\n中介代發佈消息III");
        colleague2.sendMsg(null,"本人想要北京六環的90平方的房子");


    }
}

主函数打印信息

中介代發佈消息
VIP 代號張三獲得消息：北京一環有一套房，優先提供給VIP客戶
VIP 代號李四獲得消息：北京一環有一套房，優先提供給VIP客戶

中介代發佈消息II
VIP 代號張三獲得消息：北京五環有十套房，優質高層大房
NOTVIP 代號王五獲得消息：北京五環有十套房，優質高層大房
VIP 代號李四獲得消息：北京五環有十套房，優質高層大房

中介代發佈消息III
SHELL 中原地產獲得消息：客戶代號張三，本人想要北京六環的90平方的房子

接口抽象中介者

package mediator_method_mod;

/**
 * 1）Mediator 就是抽象中介者，定义类同事对象到中介者对象的接口。
 */
public interface Mediator {
    /**
     * 成员注册
     * @param name
     * @param colleague1
     */
    void registor(String name, Colleague colleague1);

    /**
     * 发送消息给VIP客户
     * @param msg
     */
    void sendMsgToVIP(String msg);
    /**
     * 发送消息给非VIP客户
     * @param msg
     */
    void sendMsgToNOTVIP(String msg);
    /**
     * 发送消息给所有客户
     * @param msg
     */
    void sendMsgToALLCUSTOMER(String msg);
    /**
     * 发送消息给销售员
     * @param msg
     */
    void sendMsgToSaleperson(String msg);
}

实现类房屋中介

package mediator_method_mod;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 中介
 * 3）ConcreteMediator 具体的中介者对象，实现抽象方法，他需要知道所有的具体的同事类，即以一个集合来管理HashMap，并接收某个同事对象消息，完成相应的任务。
 */
public class HouseMediator implements Mediator {

    Map<String,Colleague> colleagueMap = new HashMap<String,Colleague>();

    @Override
    public void registor(String name, Colleague colleague) {
        colleagueMap.put(name,colleague);
        colleague.setMediator(this);
        colleague.setName(name);
    }

    public void sendMsgToVIP(String msg){
        colleagueMap.forEach((k,v)-> {
            if(v.getType().equals("VIP")){
                v.getMsg(msg);
            }
        });
    }

    @Override
    public void sendMsgToNOTVIP(String msg) {
        colleagueMap.forEach((k,v)-> {
            if(v.getType().equals("NOTVIP")){
                v.getMsg(msg);
            }
        });
    }

    @Override
    public void sendMsgToALLCUSTOMER(String msg) {
        colleagueMap.forEach((k,v)-> {
            if(v.getType().equals("VIP") || v.getType().equals("NOTVIP")){
                v.getMsg(msg);
            }
        });
    }

    @Override
    public void sendMsgToSaleperson(String msg) {
        colleagueMap.forEach((k,v)-> {
            if(v.getType().equals("SHELL")){
                v.getMsg(msg);
            }
        });
    }

}

具体成员：客户

package mediator_method_mod;

/**
 * 客戶
 * 4）ConcreteColleague 具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为（方法），但是他们都是依赖中介者对象。
 */
public class CustomerColleague extends Colleague {
    public CustomerColleague(String type) {
        super(type);
    }

    @Override
    public void sendMsg(String msgType,String msg) {
        getMediator().sendMsgToSaleperson(String.format("客戶%s，%s",getName(),msg));
    }

}

具体成员：房地产商或销售

package mediator_method_mod;

/**
 * 房地產商
 * 4）ConcreteColleague 具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事类的行为（方法），但是他们都是依赖中介者对象。
 */
public class SellColleague extends Colleague {

    public SellColleague(String type) {
        super(type);
    }

    @Override
    public void sendMsg(String msgType,String msg) {
        if("VIP".equals(msgType)){
            getMediator().sendMsgToVIP(msg);
        }
        else if("NOTVIP".equals(msgType)){
            getMediator().sendMsgToNOTVIP(msg);
        }
        else if("ALL".equals(msgType)){
            getMediator().sendMsgToALLCUSTOMER(msg);
        }
    }
}

抽象成员

package mediator_method_mod;

/**
 * 2）Colleague 是抽象同事类。
 */
public abstract class Colleague {
    private String type;//註冊者類型
    private String name;//代號名稱
    private Mediator mediator;

    public abstract void sendMsg(String msgType,String msg);

    public void getMsg(String msg){
        System.out.println(String.format("%s %s 獲得消息：%s",getType(),getName(),msg));
    }

    public Colleague(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Mediator getMediator() {
        return mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

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

设计模式概览