Java设计模式之中介者模式怎么实现

前言

中介者模式是一种行为型设计模式，用于解耦多个对象之间的交互关系。在软件系统中，当一些对象之间存在复杂的交互逻辑时，直接的对象之间关系的耦合将会导致系统变得难以维护和扩展。这时候，使用中介者模式来管理对象之间的交互将会更加合理和灵活。

概述

中介者模式通过引入一个中介者对象，将对象之间的交互转移到中介者对象上进行处理，从而减少对象之间的直接依赖关系。中介者通过封装一系列对象之间的交互行为，使得这些对象可以以一种松散的方式通信。这样的模式将对象之间的一对多依赖关系转换为一对一的依赖关系，从而降低了系统的复杂度。

在实际应用中，中介者模式尤其适合处理以下情况：

• 系统中的对象之间存在复杂的交互关系，导致对象之间的耦合度很高。
• 系统设计初期，多个对象之间的交互关系尚未完全确定，需要一种灵活的方式来管理这些交互行为。
• 系统中的对象需要在运行时动态地改变交互逻辑。
• 系统中的对象需要对其他对象的状态进行监控，并在特定状态下做出相应的响应。

实现方式

中介者模式一般包含以下几个角色：

• 抽象中介者（Mediator）：定义了对象之间的交互接口，声明了各个同事对象的通信方法。
• 具体中介者（ConcreteMediator）：实现了抽象中介者接口，负责协调各个同事对象之间的交互关系。
• 抽象同事类（Colleague）：定义了同事对象的基本行为，维护一个指向中介者对象的引用，提供了与其他同事对象交互的方法。
• 具体同事类（ConcreteColleague）：实现了抽象同事类定义的方法，并在需要与其他同事对象交互时，通过中介者进行协作。

下面是一个简单的示例代码：

// 抽象中介者
public abstract class Mediator {
    public abstract void send(String message, Colleague colleague);
}

// 具体中介者
public class ConcreteMediator extends Mediator {
    private ConcreteColleagueA colleagueA;
    private ConcreteColleagueB colleagueB;
    
    public void setColleagueA(ConcreteColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }
    
    public void setColleagueB(ConcreteColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }
    
    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else if (colleague == colleagueB) {
            colleagueA.receive(message);
        }
    }
}

// 抽象同事类
public abstract class Colleague {
    protected Mediator mediator;
    
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    
    public abstract void receive(String message);
    public abstract void send(String message);
}

// 具体同事类A
public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }
    
    @Override
    public void receive(String message) {
        System.out.println("Colleague A received: " + message);
    }
    
    @Override
    public void send(String message) {
        mediator.send(message, this);
    }
}

// 具体同事类B
public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }
    
    @Override
    public void receive(String message) {
        System.out.println("Colleague B received: " + message);
    }
    
    @Override
    public void send(String message) {
        mediator.send(message, this);
    }
}

public class Main {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        
        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);
        
        colleagueA.send("Hello, Colleague B!");
        colleagueB.send("Hi, Colleague A!");
    }
}

总结

中介者模式通过引入中介者对象，将对象之间的交互关系集中管理，避免了对象之间的直接依赖关系，简化了系统的设计和维护。中介者模式的核心思想是通过封装一系列对象之间的交互行为，在中介者对象中进行统一管理和调度。这种模式可以降低对象之间的耦合度，提高系统的灵活性和可扩展性。但是，过度使用中介者模式可能会导致中介者对象变得过于复杂。因此，在设计时需要根据实际情况权衡利弊，合理应用中介者模式。