在用户与用户直接聊天的设计方案中,用户对象之间存在很强的关联性,将导致系统出现如下问题:
中介者模式(
Mediator Pattern
):用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式,它是一种对象行为型模式。
中介者模式包含如下角色:
Mediator
: 抽象中介者ConcreteMediator
: 具体中介者Colleague
: 抽象同事类ConcreteColleague
: 具体同事类首先,是抽象的Mediator
类和具体的ConcreteMediator
类:
/**
* 通用抽象中介者类.
*
* Created by blinkfox on 16/8/21.
*/
public abstract class Mediator {
/** 定义同事类1. */
protected ConcreteColleague1 colleague1;
/** 定义同事类2. */
protected ConcreteColleague2 colleague2;
/* getter 和 setter 方法 */
public ConcreteColleague1 getColleague1() {
return colleague1;
}
public void setColleague1(ConcreteColleague1 colleague1) {
this.colleague1 = colleague1;
}
public ConcreteColleague2 getColleague2() {
return colleague2;
}
public void setColleague2(ConcreteColleague2 colleague2) {
this.colleague2 = colleague2;
}
/**
* 中介者模式的抽象业务逻辑1.
*/
public abstract void doSomething1();
/**
* 中介者模式的抽象业务逻辑2.
*/
public abstract void doSomething2();
}
/**
* 具体的通用中介者类.
*
* Created by blinkfox on 16/8/21.
*/
public class ConcreteMediator extends Mediator {
/**
* 中介者模式的具体业务逻辑1.
*/
@Override
public void doSomething1() {
super.colleague1.selfMethod1();
super.colleague2.selfMethod2();
}
/**
* 中介者模式的具体业务逻辑2.
*/
@Override
public void doSomething2() {
super.colleague1.selfMethod1();
super.colleague2.selfMethod2();
}
}
其实,是抽象的Colleague
类和具体的ConcreteColleague
类:
/**
* 抽象的同事类.
*
* Created by blinkfox on 16/8/21.
*/
public abstract class Colleague {
/** 中介者. */
protected Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
}
/**
* 具体的同事类1.
*
* Created by blinkfox on 16/8/21.
*/
public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator mediator) {
super(mediator);
}
/**
* 自有方法.
*/
public void selfMethod1() {
System.out.println("------ConcreteColleague1-处理自己的业务逻辑1--------");
}
/**
* 依赖方法.
*/
public void depMethod1() {
System.out.println("------ConcreteColleague1-委托给中介者的业务逻辑1--------");
super.mediator.doSomething1();
}
}
/**
* 具体的同事类2.
*
* Created by blinkfox on 16/8/21.
*/
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator mediator) {
super(mediator);
}
/**
* 自有方法2.
*/
public void selfMethod2() {
System.out.println("------ConcreteColleague2-处理自己的业务逻辑2--------");
}
/**
* 依赖方法2.
*/
public void depMethod2() {
System.out.println("------ConcreteColleague2-委托给中介者的业务逻辑2--------");
super.mediator.doSomething2();
}
}
以下是中介者模式的客户端场景类:
/**
* 中介者模式的场景类
* Created by blinkfox on 16/8/21.
*/
public class MediatorClient {
public static void main(String[] args) {
Mediator mediator = new ConcreteMediator();
ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
mediator.setColleague1(colleague1);
mediator.setColleague2(colleague2);
colleague1.depMethod1();
colleague2.depMethod2();
mediator.doSomething1();
mediator.doSomething2();
}
}
中介者模式可以使对象之间的关系数量急剧减少。
中介者承担两方面的职责:
中介者模式的优点:
中介者模式的缺点:
在以下情况下可以使用中介者模式: