设计模式之中介者

一.简介

现实生活中常有许多对象存在复杂的交互关系，这种关系常是“网状结构”，把这种“网状结构”改为“星形结构”的话，将大大降低它们之间的“耦合性”，这时只要添加一个“中介者”就可以了。

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

模式结构：
1.抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。

2.具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。

3.抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。

4.具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

优点：
降低了对象之间的耦合性，使得对象易于独立地被复用。
将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

缺点：
当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护。

二.实现

package com.vincent;


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


/**
 * 设计模式
 *
 */
public class App {
    public static void main( String[] args ) throws Exception {
        AbstructMediator mediator = new Mediator();
        AbstructColleague colleagueA = new Colleague(mediator,"A");
        AbstructColleague colleagueB = new Colleague(mediator,"B");

        mediator.register(colleagueA);
        mediator.register(colleagueB);

        colleagueA.send();
    }
}


/**
 * 抽象中介
 */
abstract class AbstructMediator{
    List<AbstructColleague> colleagues = new ArrayList<>();

    /**
     * 注册同事对象到中介
     * @param colleague
     */
    public void register(AbstructColleague colleague){
        if(!colleagues.contains(colleague)){
            colleagues.add(colleague);
        }
    }

    public void forward(AbstructColleague colleague){
        for(AbstructColleague colg : colleagues){
            if(colg != colleague || !colg.equals(colleague)){
                colg.receive(colleague);
            }
        }
    }
}



/**
 * 具体中介
 *
 */
class Mediator extends AbstructMediator{

}


/**
 * 抽象同事类
 */
abstract class AbstructColleague{
    abstract void send();

    abstract void receive(AbstructColleague colleague);
}


/**
 * 具体同事
 */
class Colleague extends AbstructColleague{

    private AbstructMediator mediator;
    private String name;

    public Colleague(AbstructMediator mediator,String name){
        this.mediator = mediator;
        this.name = name;
    }

    @Override
    void send() {
        this.mediator.forward(this);
    }

    @Override
    void receive(AbstructColleague colleague) {
        System.out.println(String.format("接受到同事信息----%s\n",colleague));
    }

    @Override
    public String toString() {
        return "Colleague{" +
                "name='" + name + '\'' +
                '}';
    }
}

实现效果：

三.总结

1.中介者模式将对象间的一对多关联转变为一对一的关联，对象与对象之间的交互通过中介者传递，提高系统的灵活性、扩展性

本文地址：https://blog.csdn.net/Zllvincent/article/details/107361645