设计模式-中介者模式（Mediator）

一、中介者模式概述

1.1 什么是中介者模式

中介者模式，又被称为调停者模式，是一种行为型设计模式，其核心思想是通过引入一个中介对象来封装一系列对象之间的交互。这种模式使得各对象不需要显式地相互引用，从而降低了它们之间的耦合度和依赖性，使得系统更易于维护和扩展。

中介者模式的主要角色包括：

抽象中介者（Mediator）：定义中介者接口，声明各种业务方法。
具体中介者（Concrete Mediator）：实现抽象中介者接口，负责与各个同事对象之间的通信和协调。
抽象同事类（Colleague）：定义同事类接口，声明一些抽象方法，用于与中介者进行通信。
当系统中的对象之间的关系变得复杂，例如形成网状结构时，中介者模式尤为有用。通过引入中介者，可以将原本复杂的网状结构转化为更为清晰的星型结构，使得各个对象之间的交互更加明确和简单。

举个例子，考虑一个团队协作的场景，团队成员之间可能存在大量的沟通和协作。如果不使用中介者模式，那么每个成员都可能需要知道与其他所有成员的联系方式，这样当有新的成员加入或某个成员离开时，整个系统的复杂度都会增加。而使用中介者模式后，团队成员只需要与中介者通信，由中介者负责调度和协调各个成员之间的交互。

1.2 简单实现中介者模式

中介者模式是一种行为型设计模式，它通过引入一个中介者对象来协调多个对象之间的交互。以下是一个简单的Java实现：

首先，创建一个抽象的中介者类（Mediator）：

public abstract class Mediator {
    protected List<Colleague> colleagues = new ArrayList<>();

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void removeColleague(Colleague colleague) {
        colleagues.remove(colleague);
    }

    public abstract void sendMessage(String message, Colleague sender);
}

然后，创建一个具体的中介者类（ConcreteMediator）：

public class ConcreteMediator extends Mediator {
    @Override
    public void sendMessage(String message, Colleague sender) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receiveMessage(message, sender);
            }
        }
    }
}

接下来，创建抽象的同事类（Colleague）：

public abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void sendMessage(String message);

    public abstract void receiveMessage(String message, Colleague sender);
}

最后，创建具体的同事类（ConcreteColleagueA和ConcreteColleagueB）

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("同事A发送消息：" + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message, Colleague sender) {
        System.out.println("同事A收到来自" + sender + "的消息：" + message);
    }
}

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("同事B发送消息：" + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message, Colleague sender) {
        System.out.println("同事B收到来自" + sender + "的消息：" + message);
    }
}

现在，你可以创建中介者和同事对象，并测试它们之间的交互：

public class Main {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Colleague colleagueA = new ConcreteColleagueA(mediator);
        Colleague colleagueB = new ConcreteColleagueB(mediator);

        colleagueA.sendMessage("你好，同事B！");
        colleagueB.sendMessage("你好，同事A！");
    }
}

运行上述代码，你将看到以下输出：

同事A发送消息：你好，同事B！
同事B收到来自同事A的消息：你好，同事B！
同事B发送消息：你好，同事A！
同事A收到来自同事B的消息：你好，同事A！

1.3 使用中介者模式的注意事项

• 1、中介者模式适用于多个对象之间存在复杂的交互关系，需要协调和统一管理的情况。

• 2、中介者模式会增加系统的复杂性和维护成本，因此应该谨慎使用。

• 3、中介者模式可能会导致性能问题，因为所有的消息都需要通过中介者传递。

• 4、中介者模式应该尽量避免过多的中介者对象，否则会导致系统更加复杂。

• 5、在设计中介者模式时，应该考虑到系统的可扩展性和灵活性，以便在未来可以方便地添加或删除对象。

• 6、中介者模式应该避免过度依赖中介者对象，否则会导致系统变得脆弱和不可维护

二、中介者模式的用途

• 1、简化对象之间的关系：中介者模式能够简化系统内各个对象之间的相互关系，将原本复杂的网状结构转变为相对简单的线性结构。

• 2、降低系统的复杂性：通过引入中介者对象，可以减少子类生成，降低了系统的复杂性和维护成本。

• 3、提高系统的灵活性和可扩展性：当需要增加新的功能或者删除某个对象时，只需要对中介者进行修改，而不需要修改其他对象，从而提高了系统的灵活性和可扩展性。

• 4、封装转换规则：中介者模式能够将对象间的交互规则进行封装，使得对象间的交互更加清晰。

三、中介者模式实现方式

3.1 使用接口和类的方式

通过定义一个中介者接口，然后创建具体的中介者类来实现中介者模式。

// 中介者接口
interface Mediator {
    void send(String message, Colleague colleague);
}

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

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    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;
        mediator.addColleague(this);
    }

    public abstract void send(String message);

    public abstract void receive(String message);
}

3.2 使用抽象工厂模式的方式

通过定义一个抽象工厂类来创建具体的中介者对象，然后在具体的工厂类中实现中介者对象的创建。

// 抽象工厂类
abstract class AbstractFactory {
    public abstract Mediator createMediator();
}

// 具体工厂类
class ConcreteFactory extends AbstractFactory {
    @Override
    public Mediator createMediator() {
        return new ConcreteMediator();
    }
}

3.3 使用单例模式的方式

通过定义一个中介者类，并使用单例模式来确保整个系统中只有一个中介者对象。

// 中介者类
class Mediator {
    private static Mediator instance;
    private List<Colleague> colleagues = new ArrayList<>();

    private Mediator() {}

    public static Mediator getInstance() {
        if (instance == null) {
            instance = new Mediator();
        }
        return instance;
    }

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receive(message);
            }
        }
    }
}