设计模式-中介者模式
一、中介者模式(行为型模式)
1.定义
中介者模式(Mediator Pattern)定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。
2.中介者模式角色
(1).抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
**(2).具体中介者（Concrete Mediator）角色：**实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
**(3).抽象同事类（Colleague）角色：**定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
**(4).具体同事类（Concrete Colleague）角色：**是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
3.代码实现方式
(1).创建一个抽象中介者角色，维护一个同事类集合，定义一个添加同事类和转发同事类信息的方法。
(2).创建具体中介者角色，重写添加同事类和转发同事类信息的方法。
(3).创建一个抽象同事类角色，组合依赖抽象中介者角色，构造器注入，定义一个发送消息方法。
(4).创建一个具体同事类角色，重写发送消息方法，处理完自身业务逻辑后，调用中介者方法，让中介者帮忙转发给其他同事类。
4.代码实现
(1).具体代码
(1-1).普通版
package com.tw.designPattern.mediator.common;
/**
* 抽象中介者
*/
public abstract class Mediator {
public abstract void register(Colleague colleague);
/**
* 转发
* @param colleague
*/
public abstract void relay(Colleague colleague);
}
package com.tw.designPattern.mediator.common;
import java.util.ArrayList;
import java.util.List;
/**
* 具体中介者
*/
public class ConcreteMediator extends Mediator{
private List<Colleague> colleagueList = new ArrayList<>();
@Override
public void register(Colleague colleague) {
if (!colleagueList.contains(colleague)){
colleagueList.add(colleague);
colleague.setMediator(this);
}
}
@Override
public void relay(Colleague colleague) {
for (Colleague o : colleagueList){
if (!o.equals(colleague)){
o.receive();
}
}
}
}
package com.tw.designPattern.mediator.common;
/**
* 抽象同事类
*/
public abstract class Colleague {
protected Mediator mediator;
public void setMediator(Mediator mediator){
this.mediator = mediator;
}
public abstract void receive();
public abstract void send();
}
package com.tw.designPattern.mediator.common;
/**
* 具体同事类
*/
public class ConcreteColleagueOne extends Colleague{
@Override
public void receive() {
System.out.println("具体同事类1收到请求。");
}
@Override
public void send() {
System.out.println("具体同事类1发出请求。");
// 请中介者转发
mediator.relay(this);
}
}
package com.tw.designPattern.mediator.common;
/**
* 具体同事类
*/
public class ConcreteColleagueTwo extends Colleague{
@Override
public void receive() {
System.out.println("具体同事类2收到请求。");
}
@Override
public void send() {
System.out.println("具体同事类2发出请求。");
// 请中介者转发
mediator.relay(this);
}
}
package com.tw.designPattern.mediator.common;
public class MediatorTest {
public static void main(String[] args) {
Mediator md = new ConcreteMediator();
Colleague c1, c2;
c1 = new ConcreteColleagueOne();
c2 = new ConcreteColleagueTwo();
md.register(c1);
md.register(c2);
c1.send();
System.out.println("-------------");
c2.send();
}
}
测试结果
具体同事类1发出请求。
具体同事类2收到请求。
-------------
具体同事类2发出请求。
具体同事类1收到请求。
(1-2).简单版
package com.tw.designPattern.mediator.simplify;
import java.util.ArrayList;
import java.util.List;
/**
* 简单单例中介者
*
*/
public class SimpleMediator {
private static SimpleMediator smd = new SimpleMediator();
private List<SimpleColleague> colleagueList = new ArrayList<>();
private SimpleMediator(){}
public static SimpleMediator getInstance(){
return smd;
}
public void register(SimpleColleague colleague){
if (!colleagueList.contains(colleague)){
colleagueList.add(colleague);
}
}
public void relay(SimpleColleague colleague){
for (SimpleColleague simpleColleague : colleagueList){
if (!simpleColleague.equals(colleague)){
simpleColleague.receive();
}
}
}
}
package com.tw.designPattern.mediator.simplify;
/**
* 抽象同事类
*/
public interface SimpleColleague {
void receive();
void send();
}
package com.tw.designPattern.mediator.simplify;
public class SimpleConcreteColleagueOne implements SimpleColleague{
public SimpleConcreteColleagueOne(){
SimpleMediator smd = SimpleMediator.getInstance();
smd.register(this);
}
@Override
public void receive() {
System.out.println("具体同事1：收到请求。");
}
@Override
public void send() {
SimpleMediator smd = SimpleMediator.getInstance();
System.out.println("具体同事1：发出请求...");
// 请中介者转发
smd.relay(this);
}
}
package com.tw.designPattern.mediator.simplify;
public class SimpleConcreteColleagueTwo implements SimpleColleague{
public SimpleConcreteColleagueTwo(){
SimpleMediator smd = SimpleMediator.getInstance();
smd.register(this);
}
@Override
public void receive() {
System.out.println("具体同事2：收到请求。");
}
@Override
public void send() {
SimpleMediator smd = SimpleMediator.getInstance();
System.out.println("具体同事2：发出请求...");
// 请中介者转发
smd.relay(this);
}
}
package com.tw.designPattern.mediator.simplify;
public class SimpleMediatorTest {
public static void main(String[] args) {
SimpleColleague c1 = new SimpleConcreteColleagueOne();
SimpleColleague c2 = new SimpleConcreteColleagueTwo();
c1.send();
System.out.println("-----------------");
c2.send();
}
}
测试结果
具体同事1：发出请求...
具体同事2：收到请求。
-----------------
具体同事2：发出请求...
具体同事1：收到请求。
注：在实际开发中，通常采用以下两种方法来简化中介者模式，使开发变得更简单。
(1).不定义中介者接口，把具体中介者对象实现成为单例。
(2).同事对象不持有中介者，而是在需要的时候直接获取中介者对象并调用
5.优缺点
(1).优点
(1-1).类之间各司其职，符合迪米特法则。
(1-2).降低了对象之间的耦合性，使得对象易于独立地被复用。
(1-3).将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。
(2).缺点
(2-1).中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。
6.应用场景
(1).当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
(2).当想创建一个运行于多个类之间的对象，又不想生成新的子类时。
注：内容参考网络上各种资料，还有一些本人的理解和思想，仅为了学习记录和分享一下自己所学之处，如有不足的地方麻烦大牛指出，如有侵权的地方，请联系删除，谢谢