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实现中介者模式
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);
}
java">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);
}
}
java">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);
}
}
java">package com.mediator;
// ========== Mediator中介者类 ==========
public abstract class Mediator {
public abstract void send(String message,Colleague colleague);
}
java">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);
}
}
}
java">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得到信息:没有呢,你打算请客吗?
