Go和Java实现中介者模式

Go和Java实现中介者模式

下面通过一个同事之间相互通信的例子来说明中介者模式的使用。

1、中介者模式

中介者模式是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的

通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

• 意图：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松

  散，而且可以独立地改变它们之间的交互。

• 主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发

  生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

• 何时使用：多个类相互耦合，形成了网状结构。

• 如何解决：将上述网状结构分离为星型结构。

• 关键代码：对象 Colleague 之间的通信封装到一个类中单独处理。

• 应用实例：1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。

  2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。

• 优点：1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。

• 缺点：中介者会庞大，变得复杂难以维护。

• 使用场景：1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该

  对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

• 注意事项：不应当在职责混乱的时候使用。

• 适用性：

  一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。

  一个对象引用其他很多对象并且直接与这些对象通信，导致难以复现该对象。

  想定制一个分布在多个类中的行为，而又不想生成太多的子类。

2、Go实现中介者模式

package mediator

// ========== Colleague同事类 ==========
type Colleague interface {
	Send(string)
	Notify(string)
}

package mediator

import "fmt"

// ========== ColleagueA同事类A ==========
type ColleagueA struct {
	Mediator
}

func (colleagueA *ColleagueA) Send(message string) {
	colleagueA.Mediator.Send(message, colleagueA)
}

func (colleagueA *ColleagueA) Notify(message string) {
	fmt.Println("同事A得到信息:" + message)
}

package mediator

import "fmt"

// ========== ColleagueB同事类B ==========
type ColleagueB struct {
	Mediator
}

func (colleagueB *ColleagueB) Send(message string) {
	colleagueB.Mediator.Send(message, colleagueB)

}

func (colleagueB *ColleagueB) Notify(message string) {
	fmt.Println("同事B得到信息:" + message)

}

package mediator

// ========== Mediator中介者类 ==========
type Mediator interface {
	Send(string, Colleague)
}

package com.mediator;

// ========== ConcreteMediator ==========
public class ConcreteMediator extends Mediator{

    private ColleagueA colleagueA;

    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA){
            colleagueB.notify(message);
        }else{
            colleagueA.notify(message);
        }
    }
}

package main

import . "proj/mediator"

func main() {
	concreteMediator := ConcreteMediator{}
	colleagueA := ColleagueA{Mediator: &concreteMediator}
	colleagueB := ColleagueB{Mediator: &concreteMediator}
	concreteMediator.SetColleagueA(colleagueA)
	concreteMediator.SetColleagueB(colleagueB)
	colleagueA.Send("吃过饭了没?")
	colleagueB.Send("没有呢,你打算请客吗?")
}

# 程序输出
同事A得到信息:吃过饭了没?
同事A得到信息:没有呢,你打算请客吗?

3、Java实现中介者模式

package com.mediator;

// ========== Colleague同事类 ==========
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }

    public void send(String message){
        this.mediator.send(message,this);
    }
    public abstract void notify(String message);
}

package com.mediator;

// ========== ColleagueA同事类A ==========
public class ColleagueA extends Colleague{
    public ColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void notify(String message){
        System.out.println("同事A得到信息:"+message);
    }
}

package com.mediator;

// ========== ColleagueB同事类B ==========
public class ColleagueB extends Colleague{
    public ColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void notify(String message){
        System.out.println("同事B得到信息:"+message);
    }
}

package com.mediator;

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

package com.mediator;

// ========== ConcreteMediator ==========
public class ConcreteMediator extends Mediator{

    private ColleagueA colleagueA;

    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA){
            colleagueB.notify(message);
        }else{
            colleagueA.notify(message);
        }
    }
}

package com.mediator;

public class Test {
    public static void main(String[] args) {
        ConcreteMediator concreteMediator = new ConcreteMediator();
        ColleagueA colleagueA = new ColleagueA(concreteMediator);
        ColleagueB colleagueB = new ColleagueB(concreteMediator);
        concreteMediator.setColleagueA(colleagueA);
        concreteMediator.setColleagueB(colleagueB);
        colleagueA.send("吃过饭了没?");
        colleagueB.send("没有呢,你打算请客吗?");
    }
}

# 程序输出
同事B得到信息:吃过饭了没?
同事A得到信息:没有呢,你打算请客吗?