写在前面的话
复习、总结23种设计模式
上一篇
中介者模式
记重点
通过引入一个中介者对象来降低多个对象之间的耦合度
定义
中介者模式（Mediator Pattern）是一种行为型设计模式，它通过引入一个中介者对象来降低多个对象之间的耦合度。在中介者模式中，各个对象之间不直接进行通信，而是通过中介者对象进行协调和通信。
中介者模式的核心思想是将复杂的交互逻辑集中到一个中介者对象中，各个对象只需要和中介者对象进行通信，而不需要知道其他对象的存在。这样可以减少对象之间的直接依赖关系，提高系统的可维护性和扩展性。
中介者模式的角色
- 抽象中介者（Abstract Mediator）：定义了中介者对象的接口，用于协调各个同事对象之间的交互。
- 具体中介者（Concrete Mediator）：实现了抽象中介者接口，负责协调各个同事对象的交互，并了解各个同事对象的具体实现。
- 抽象同事类（Abstract Colleague）：定义了同事对象的接口，通常持有一个中介者对象的引用，用于与中介者进行通信。
- 具体同事类（Concrete Colleague）：实现了抽象同事类的接口，实现自身的业务逻辑，并通过中介者对象进行与其他同事对象的通信。
中介者模式适用于需要协调多个对象之间复杂交互的场景，例如GUI应用程序中的UI组件之间的交互、多个服务之间的协作等。通过引入中介者对象，可以简化系统的设计和维护，提高系统的可扩展性和可重用性。
中介者模式用于降低多个对象之间的耦合度，通过引入一个中介者对象来集中处理对象之间的交互。以下是一个使用中介者模式的简单Java代码示例：
java
package com.design.pattern.mediator.test03;
// 抽象中介者
public interface Mediator {
void send(String message, Colleague colleague);
}
// 具体中介者
class ConcreteMediator implements Mediator {
private Colleague colleague1;
private Colleague colleague2;
public void setColleague1(Colleague colleague1) {
this.colleague1 = colleague1;
}
public void setColleague2(Colleague colleague2) {
this.colleague2 = colleague2;
}
@Override
public void send(String message, Colleague colleague) {
if (colleague == colleague1) {
colleague2.receive(message);
} else {
colleague1.receive(message);
}
}
}
java
package com.design.pattern.mediator.test03;
// 抽象同事类
abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public abstract void send(String message);
public abstract void receive(String message);
}
// 具体同事类
class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague1 Received: " + message);
}
}
class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
@Override
public void send(String message) {
mediator.send(message, this);
}
@Override
public void receive(String message) {
System.out.println("ConcreteColleague2 Received: " + message);
}
}DEMO-1 两个人之间互相收发消息
每个人都可以发送消息、接收消息
java
package com.design.pattern.mediator.test01;
// 每个人都可以发送消息、接收消息
public interface Person {
// 发送消息
void sendMsg(String msg);
// 接收消息
void receiveMsg(String msg);
}a给b收发消息
java
package com.design.pattern.mediator.test01;
// a给b收发消息
public class A implements Person {
private B b;
@Override
public void sendMsg(String msg) {
System.out.println("a 发送消息：" + msg);
b.receiveMsg(msg);
}
@Override
public void receiveMsg(String msg) {
System.out.println("a 收到消息：" + msg);
}
public void setB(B b) {
this.b = b;
}
}b给a收发消息
java
package com.design.pattern.mediator.test01;
// b给a收发消息
public class B implements Person {
private A a;
@Override
public void sendMsg(String msg) {
System.out.println("b 发送消息：" + msg);
a.receiveMsg(msg);
}
@Override
public void receiveMsg(String msg) {
System.out.println("b 收到消息：" + msg);
}
public void setA(A a) {
this.a = a;
}
}测试类
java
package com.design.pattern.mediator.test01;
/*
打印结果：
a 发送消息：hello b! I am a!
b 收到消息：hello b! I am a!
b 发送消息：hello a! I am b!
a 收到消息：hello a! I am b!
*/
public class Test01 {
public static void main(String[] args) {
// 定义两个人，分别是a和b
A a = new A();
B b = new B();
a.setB(b);
b.setA(a);
// a 发消息给 b
a.sendMsg("hello b! I am a!");
// b 发消息给 a
b.sendMsg("hello a! I am b!");
}
}DEMO-2 使用中介者模式之后，两个人之间互相收发消息
A和B不再互相依赖了，他们都只负责写信和收信，至于给谁写和收谁的信那就不是他们要做的事情了，同提交给收发室来做
java
package com.design.pattern.mediator.test02;
import com.design.pattern.mediator.test01.Person;
public class A implements Person {
@Override
public void sendMsg(String msg) {
System.out.println("a 发送消息：" + msg);
}
@Override
public void receiveMsg(String msg) {
System.out.println("a 收到消息：" + msg);
}
}
java
package com.design.pattern.mediator.test02;
import com.design.pattern.mediator.test01.Person;
public class B implements Person {
@Override
public void sendMsg(String msg) {
System.out.println("b 发送消息：" + msg);
}
@Override
public void receiveMsg(String msg) {
System.out.println("b 收到消息：" + msg);
}
}定义一个收发室充当中介者的角色
java
package com.design.pattern.mediator.test02;
import com.design.pattern.mediator.test01.Person;
// 收发室
public class MailRoom {
// 收发室负责接受来自fromP的消息，然后发给toP
public void sendMsg(Person fromP, Person toP, String msg) {
fromP.sendMsg(msg);
toP.receiveMsg(msg);
}
}测试类
java
package com.design.pattern.mediator.test02;
public class Test02 {
public static void main(String[] args) {
A a = new A();
B b = new B();
// 定义一个收发室
MailRoom mailRoom = new MailRoom();
mailRoom.sendMsg(a, b, "hello b! I am a!");
mailRoom.sendMsg(b, a, "hello a! I am b!");
}
}中介者模式的优势：
降低耦合度：中介者模式将对象之间的交互集中在中介者对象中，减少了对象之间的直接依赖和耦合度，使系统更加灵活、可扩展和易于维护。
简化对象间的通信：中介者模式通过引入中介者对象，将对象间复杂的相互通信转变为对象与中介者之间的简单交互，简化了对象间的通信逻辑。
集中控制逻辑：中介者模式将对象间的交互逻辑集中在中介者对象中，使得系统的控制逻辑更加清晰明确。通过定义中介者对象来协调对象间的交互，可以更方便地修改和扩展系统的行为。
促进代码重用：中介者模式将公共的交互逻辑封装在中介者对象中，可以被多个对象共享和复用，避免了代码的重复编写，提高了代码的可维护性和可复用性。
中介者模式适用场景
当一个系统中对象之间存在复杂的相互关系，导致对象间的交互逻辑难以维护和扩展时，可以考虑使用中介者模式来简化交互逻辑。
当一个对象需要对多个对象进行操作或通知时，可以引入中介者模式来集中管理这些对象之间的交互。
当系统中的对象之间存在循环依赖关系，不方便直接进行交互时，可以通过引入中介者对象来解决循环依赖问题。
总之，中介者模式可以帮助我们降低系统的耦合度，简化对象间的通信，集中控制逻辑，并促进代码的重用。它适用于复杂的对象交互场景，能够提高系统的可维护性和可扩展性。