设计模式-中介者模式

定义

中介者模式，是一种行为设计模式，它允许你减少多个组件或对象之间的直接通信，而是通过一个中介者对象来进行通信。

这种模式有助于减少相互作用的组件之间的依赖关系，从而增加它们的可重用性和可维护性。

UML 类图

typescript 实现

1. 定义中介者接口

interface Mediator {
  notify(sender: object, event: string): void;
}

2. 创建具体组件

class BaseComponent {
  protected mediator: Mediator;
  
  constructor(mediator?: Mediator) {
    this.mediator = mediator;
  }
  public setMediator(mediator: Mediator): void {
    this.mediator = mediator;
  }
}

class Component1 extends BaseComponent {
  public operationA() {
    console.log("Component1 does A");
    this.mediator.notify(this, "A");
  }
}

class Component2 extends BaseComponent {
  public operationB() {
    console.log("Component2 does B");
    this.mediator.notify(this, "B");
  }
}

3. 创建具体中介者

class ConcreteMediator implements Mediator {
  private component1: Component1;
  private component2: Component2;
  
  constructor(component1: Component1, component2: Component2) {
    this.component1 = component1;
    this.component1.setMediator(this);
    this.component2 = component2;
    this.component2.setMediator(this);
  }
  public notify(sender: object, event: string): void {
    if（event === "A") {
      console.log("Mediator reacts on A and triggers following operations.");
      this.component2.operationB();
    }
    if (event === "B") {
      console.log("Mediator reacts on B and triggers following operation.");
      this.component1.operationA();
    }
  }
}

4. 使用示例

const c1 = new Component1();
const c2 = new Component2();

const mediator = new ConcreteMediator(c1, c2);

console.log("Client triggers operation A.");
c1.doA();

console.log("Client triggers operation D.");
c2.doB();

通用实现

// 公共代码
export abstract class Mediator {
  protected colleagues: Map<string, Colleague<this>> = new Map();
  
  public abstract notify(sender: Colleague<this>, ...args: any[]): void;
  public register(name: string, colleague: Colleague<this>): void {
    this.colleagues.set(name, colleague);
  }
}

export abstract class Colleague<T extends Mediator> {
  protected mediator: T;
  
  protected constructor(mediator: T) {
    this.mediator = mediator;
  }
  public abstract send(...args: any[]): void;
}



// 私有代码，使用示例
class ConcreteMediator extends Mediator {
  notify(sender: Colleague<this>, args: string): void {
    const colleague = this.colleagues.get(args);
    if(colleague) {
      colleague.send()
    }
  }
}
class ConcreteColleague extends Colleague<ConcreteMediator> {
  constructor(mediator: ConcreteMediator) {
    super(mediator);
  }
  send(args: any): void {
    this.mediator.notify(this, 'ConcreteColleague2');
  }
}
class ConcreteColleague2 extends Colleague<ConcreteMediator> {
  constructor(mediator: ConcreteMediator) {
    super(mediator);
  }
  send(args: any): void {
    this.mediator.notify(this, 'ConcreteColleague');
  }
}
const mediator = new ConcreteMediator();
const colleague1 = new ConcreteColleague(mediator);
const colleague2 = new ConcreteColleague2(mediator);
mediator.register("ConcreteColleague1", colleague1);
mediator.register("ConcreteColleague2", colleague2);
colleague1.send("ConcreteColleague2");