Java中介者模式

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

目录

定义

结构

案例

优点

缺点

使用场景


定义

又叫调停模式,定义一个中介角色来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。

结构

中介者模式包含以下主要角色:

  • 抽象中介者角色:它是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。
  • 具体中介者角色:实现中介者接口,定义一个 List 来管理同事对象,协调各个同事角色之间的交互关系,因此它依赖于同事角色。
  • 抽象同事类角色:定义同事类的接口,保存中介者对象,提供同事对象交互的抽象方法,实现所有相互影响的同事类的公共功能。
  • 具体同事类角色:是抽象同事类的实现者,当需要与其他同事对象交互时,由中介者对象负责后续的交互。

案例

//抽象中介类
public abstract class Mediator {
    public abstract void contact(String message,Person person);

    public abstract void getMessage(Person person);
}

具体中介类 

public class MediatorStructure extends Mediator {
    private List<HouseOwner> houseOwners = new ArrayList<>();
    private List<Tenant> tenants = new ArrayList<>();
    //购房者的要求
    private Map<Tenant, List<String>> tenantRequest = new HashMap<>();
    //房主的服务
    private Map<HouseOwner, List<String>> houseOwnerResponse = new HashMap<>();

    public List<HouseOwner> getHouseOwners() {
        return houseOwners;
    }

    public void setHouseOwners(HouseOwner houseOwner) {
        houseOwners.add(houseOwner);
    }

    public List<Tenant> getTenants() {
        return tenants;
    }

    public void setTenants(Tenant tenant) {
        tenants.add(tenant);
    }

    @Override
    public void contact(String message, Person person) {
        List<String> list = null;
        if (person instanceof HouseOwner) {
            //说明是房主联系中介,中介需要把消息给对应的购房者
            //首先判断信息map中有没有这个房主信息
            HouseOwner houseOwner = (HouseOwner) person;
            list = houseOwnerResponse.get(person);
            if (list == null || list.size() <= 0) {
                //说明没有这个房主的信息
                list = new ArrayList<>();
                list.add(message);
                houseOwnerResponse.put(houseOwner, list);
            } else {
                if (list.contains(message)) {
                    //说明已经存在这个消息了
                    return;
                }
                list.add(message);
                houseOwnerResponse.put(houseOwner, list);
            }
        } else {
            //说明购房者发起了消息
            Tenant tenant = (Tenant) person;
            list = tenantRequest.get(tenant);
            if (list == null || list.size() <= 0) {
                list = new ArrayList<>();
                //说明没有这个购房者的信息
                list.add(message);
                tenantRequest.put(tenant, list);
            } else {
                if (list.contains(message)) {
                    //说明已经存在这个消息了
                    return;
                }
                list.add(message);
                tenantRequest.put(tenant, list);
            }
        }
    }

    public void getMessage(Person person) {
        Set<String> set = new HashSet<>();
        if (person instanceof HouseOwner) {
            //房主主动获取购房者的需求
            for (Tenant tenant : tenantRequest.keySet()) {
                List<String> list = tenantRequest.get(tenant);
                set.addAll(list);
            }
            ((HouseOwner) person).getMessage(set);
        } else {
            //购房者只需要知道符合自己的就可以
            List<String> list = tenantRequest.get(person);
            for (String s : list) {
                for (HouseOwner houseOwner : houseOwnerResponse.keySet()) {
                    List<String> response = houseOwnerResponse.get(houseOwner);
                    if (response.contains(s)) {
                        set.add(houseOwner.name);
                    }
                }
            }
            ((Tenant) person).getMessage(set);
        }
    }
}

 抽象同事类

public abstract class Person {
    protected String name;
    protected Mediator mediator;

    public String getName() {
        return name;
    }

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

    public Mediator getMediator() {
        return mediator;
    }

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

    public Person(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    abstract void contact(String message);
}

 房主

public class HouseOwner extends Person {

    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }

    @Override
    void contact(String message) {
        System.out.println(name+"房主发布了一条消息:"+message);
        mediator.contact(message,this);
    }

    public void getMessage(Set message){
        System.out.println(name+"房主获得了消息:"+message);
    }
}


public class Tenant extends Person{
    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }

    @Override
    void contact(String message) {
        System.out.println(name+"购房者发布了一条消息:"+message);
        mediator.contact(message,this);
    }

    void getMessage(Set message){
        System.out.println(name+"购房者获得了消息:"+message);
    }
}

测试 

public class Client {
    public static void main(String[] args) {
        MediatorStructure mediatorStructure = new MediatorStructure();
        HouseOwner houseOwnerOne = new HouseOwner("房主一号", mediatorStructure);
        HouseOwner houseOwnerTwo = new HouseOwner("房主二号", mediatorStructure);

        Tenant tenantOne = new Tenant("买房一号",mediatorStructure);
        Tenant tenantTwo = new Tenant("买房一号",mediatorStructure);

        mediatorStructure.setHouseOwners(houseOwnerOne);
        mediatorStructure.setHouseOwners(houseOwnerTwo);

        mediatorStructure.setTenants(tenantOne);
        mediatorStructure.setTenants(tenantTwo);

        tenantOne.contact("汤臣一品");
        tenantOne.contact("汤臣二品");

        tenantTwo.contact("汤臣三品");
        tenantTwo.contact("汤臣四品");

        houseOwnerOne.contact("汤臣一品");
        houseOwnerTwo.contact("汤臣六品");

        mediatorStructure.getMessage(houseOwnerOne);
        mediatorStructure.getMessage(tenantOne);

    }
}

买房一号购房者发布了一条消息:汤臣一品

买房一号购房者发布了一条消息:汤臣二品

买房一号购房者发布了一条消息:汤臣三品

买房一号购房者发布了一条消息:汤臣四品

房主一号房主发布了一条消息:汤臣一品

房主二号房主发布了一条消息:汤臣六品

房主一号房主获得了消息:[汤臣三品, 汤臣四品, 汤臣二品, 汤臣一品]

买房一号购房者获得了消息:[房主一号]

案例中存在两种同事角色,购房者以及房主,中介类保存不同同事类对象,然后根据不同同事类给出不同返回结果。

优点

  • 松散耦合中介者模式通过把多个同事对象之间的交互封装到中介者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。
  • 集中控制交互多个同事对象的交互,被封装在中介者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改中介者对象就可以了,当然如果是已经做好的系统,那么就扩展中介者对象,而各个同事类不需要做修改。
  • 一对多关联转变为一对一的关联没有使用中介者模式的时候,同事对象之间的关系通常是一对多的,引入中介者对象以后,中介者对象和同事对象的关系通常变成双向的一对一,这会让对象的关系更容易理解和实现。

缺点

当同事类太多时,中介者的职责将很大,它会变得复杂而庞大,以至于系统难以维护。文章来源地址https://www.toymoban.com/news/detail-765574.html

使用场景

  • 系统中对象之间存在复杂的引用关系,系统结构混乱且难以理解。
  • 当想创建一个运行于多个类之间的对象,又不想生成新的子类时。

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

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

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

相关文章

  • 【中介者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    中介者模式(Mediator Pattern)是一种行为型模式。它限制对象之间的直接交互,它用一个中介对象来封装一系列的动作,以让对象之间进行交流。中介者使各个对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。 当一些对象和其他对象紧密

    2023年04月19日
    浏览(36)
  • 设计模式——中介者模式

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

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

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

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

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

    2024年01月22日
    浏览(38)
  • 设计模式之中介者模式

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

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

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

    2024年02月04日
    浏览(38)
  • 行为型设计模式——中介者模式

    中介者模式主要是将关联关系由一个中介者类统一管理维护,一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下左图中,有六个同事类对象

    2024年01月18日
    浏览(47)
  • 大话设计模式之中介者模式

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

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

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

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

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

    2024年02月09日
    浏览(41)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包