中介者模式(Mediator Pattern)

中介者模式顾名思义，就是通过一个中间人来完成不同类的交互.

中介者模式的实例

在租客和房东之间，中介者只需要负责进行租客或房东的交易，或者在交易中收取回扣。那么我们可以完全不用管租客或房东类的方法如何变化。

  1. class Middleman {
  2.     constructor(tenant, landlord) {
  3.         this.tenant = tenant;
  4.         this.landlord = landlord;
  5.     }
  6.     sendLandlord(money){
  7.        this.tenant.money-=money;
  8.        this.landlord.money+=money;
  9.        console.log(`Now: ${this.tenant.name} have $${this.tenant.money}`
  10.        +`,${this.landlord.name} have $${this.landlord.money}`);
  11.     }
  12.     sendTenant(money){
  13.         this.landlord.money-=money;
  14.         this.tenant.money+=money;
  15.         console.log(`Now: ${this.tenant.name} have $${this.tenant.money}`
  16.        +`,${this.landlord.name} have $${this.landlord.money}`);
  17.     }
  18. }

比如原来有租客和房东，假设如果要在租客类中的方法来给给房东的钱，那么必然要直接涉及和房东类的方法互相调用，那么这两个类就是耦合在一起。

那么如果中介者模式，可以通过中介者来进行缴纳，而不需要在租客的方法中操作房东的类，保证了两个类不会进行耦合。

  1. // 租客
  2. class Tenant {
  3.     constructor(name, money) {
  4.         this.name  = name;
  5.         this.money  = money;
  6.         console.log(`${name} have $${money}`);
  7.     }
  8.     payDeposit(money,middleman) {
  9.         console.log(`${this.name} pay $${money} deposit`);
  10.         middleman.sendLandlord(money);
  11.     }
  12.     payRent(money,middleman) {
  13.         console.log(`${this.name} pay $${money} for rent`);
  14.         middleman.sendLandlord(money);
  15.     }
  16. }
  18. // 房东
  19. class Landlord{
  20.     constructor(name, money) {
  21.         this.name  = name;
  22.         this.money  = money;
  23.         console.log(`${name} have $${money}`);
  24.     }
  25.     refundDeposit(money,middleman) {
  26.         console.log(`${this.name} refund $${money} deposit`);
  27.         middleman.sendTenant(money)
  28.     }
  29. }

在我们调用的时候也更加直观。

  1. const tenant = new Tenant('Jack',1000);
  2. const landlord = new Landlord('Zero',0);
  3. const middleman = new Middleman(tenant, landlord);
  4. tenant.payDeposit(300, middleman);
  5. tenant.payRent(100, middleman);
  6. tenant.payRent(100, middleman);
  7. tenant.payRent(100, middleman);
  8. landlord.refundDeposit(200, middleman);
  9. /**
  10.  * output:
  11.  * Jack have $1000
  12.  * Zero have $0
  13.  * Jack pay $300 deposit
  14.  * Now: Jack have $700,Zero have $300
  15.  * Jack pay $100 for rent
  16.  * Now: Jack have $600,Zero have $400
  17.  * Jack pay $100 for rent
  18.  * Now: Jack have $500,Zero have $500
  19.  * Jack pay $100 for rent
  20.  * Now: Jack have $400,Zero have $600
  21.  * Zero refund $200 deposit
  22.  * Now: Jack have $600,Zero have $400
  23.  */

中介者优势

通过中介者模式，可以不需要管需要交互的类如何变化，只需通过中介者特定的接口访问，在两种不同模型的类来交互时，能起到解耦作用。

上一页(迭代器模式)

下一页(备忘录模式)