也叫调停者模式，顾名思义，是一个中间人。多个类之间需要相互交互，难以管理，将结构改成星形，所有的交互全都交给中介去管理。
比如有三个彼此需要交互的 colleague(同事)类：DengTa、BangZi、GuiZi。
不使用中介的例子
public class DengTa {
// 收保护费
public void shouBHF() {
GuiZi bz = new GuiZi();
BangZi bz = new BangZi();
gz.jiaoBHF(4); // 鬼子上交 4 千亿
bz.jiaoBHF(1); // 棒子上交 1 千亿
}
// 收拾
public boolean shouShi(String name) {
if (Random().nextInt(2) == 1) {
System.out.println("算了，放他们一码")
return false;
}
if (name.equals("BangZi")) {
System.out.println("狗东西找死");
} else if (name.equals("GuiZi")) {
System.out.println("儿子不听话，找打")
}
return true;
}
}
public class GuiZi {
private bhf = 0;
// 最终交了多少保护费
public int getBFH() {
return bhf;
}
public void setBFH(int number) {
this.bhf = bhf;
}
// 上交保护费
public void jiaoBHF(int number) {
DengTa dt = new DengTa();
BangZi bz = new BangZi();
if (bz.maGuiZi()) { // 棒子骂我
if (dt.shouShi("BangZi")) { // 爸爸帮我收拾它一顿
bhf = number * 2; // 心情好，交两倍
} else { // 爸爸没有帮我收拾
bhf = number / 2; // 心情不好，少交一半
}
}
bhf = number;
System.out.println("给爸爸交保护费：" + bhf);
}
}
public class BangZi {
// 骂它
public boolean maGuiZi() {
System.out.print("鬼子你个混蛋，我与你誓不两立")
return true;
}
public void jiaoBHF(int number) {
DengTa dt = new DengTa();
GuiZi gz = new GuiZi();
int gzBHF = gz.getBFH();
if (gzBHF == 0) {
System.out.println("他还没交，主人先从他那收到钱，我再给");
} else if (gzBHF < 4) {
System.out.println("他才交了这么一点，那我只能交保护费 " + number/2);
} else {
System.out.println("给主人交保护费：" + number);
}
}
}
每一个类都要和另外两个类交互，类越多，关系越复杂。这时候如果有一个中介者(Mediator)，它知道所有类，负责统一处理这些事件，而别的 colleague 只需要和它打交道就行了。
使用中介者
public abstract class AbstractMediator {
protected DengTa dt;
protected GuiZi gz;
protected BangZi bz;
// setter/getter
//中介者最重要的方法叫做事件方法，处理多个对象之间的关系
// str 是具体指令，objects 是可能调用方法需要的参数
public abstract void execute(String str,Object...objects);
}
public class Mediator extends AbstractMediator {
public void execute(String str,Object...objects){
if(str.equals("dengTa.shouBHF")){ //灯塔收保护费
this.dengTaShouBHF();
}else if(str.equals("guiZi.jiaoBHF")){ //鬼子交保护费
this.guiZiJiaoBHF();
}else if(str.equals("bangZi.jiaoBHF")){ //棒子交保护费
this.bangZiJiaoBHF();
}
}
private void dengTaShouBHF() {
gz.jiaoBHF(4); // 鬼子上交 4 千亿
bz.jiaoBHF(1); // 棒子上交 1 千亿
}
private int guiZiJiaoBHF() {
int bhf = number;
if (bz.maGuiZi()) { // 棒子骂我
if (dt.shouShi("BangZi")) { // 爸爸帮我收拾它一顿
bhf = number * 2; // 心情好，交两倍
} else { // 爸爸没有帮我收拾
bhf = number / 2; // 心情不好，少交一半
}
}
bhf = number;
gz.setBHF(bhf);
System.out.println("给爸爸交保护费：" + bhf);
}
private int bangZiJiaoBHF() {
int gzBHF = gz.getBFH();
if (gzBHF == 0) {
System.out.println("他还没交，主人先从他那收到钱，我再给");
} else if (gzBHF < 4) {
System.out.println("他才交了这么一点，那我只能交保护费 " + number/2);
} else {
System.out.println("给主人交保护费：" + number);
}
}
}
改造 colleague，要持有中介引用。
public abstract class AbstractColleague {
protected AbstractMediator mediator;
// 构造控制必须传进来一个中介
public AbstractColleague(AbstractMediator _mediator){
this.mediator = _mediator;
}
}
public class DengTa extends AbstractColleague{
public DengTa(AbstractMediator _mediator){
super(_mediator);
}
// 收保护费，需要和别人交互的全部委托给中介
public void shouBHF() {
super.mediator.execute("dengTa.shouBHF");
}
// 收拾
public boolean shouShi(String name) {
if (Random().nextInt(2) == 1) {
System.out.println("算了，放他们一码")
return false;
}
if (name.equals("BangZi")) {
System.out.println("狗东西找死");
} else if (name.equals("GuiZi")) {
System.out.println("儿子不听话，找打")
}
return true;
}
}
public class GuiZi {
private bhf = 0;
// 最终交了多少保护费
public int getBFH() {
return bhf;
}
public void setBFH(int number) {
this.bhf = bhf;
}
// 上交保护费
public void jiaoBHF(int number) {
super.mediator.execute("guiZi.jiaoBHF");
}
}
public class BangZi {
// 骂它
public boolean maGuiZi() {
System.out.print("鬼子你个混蛋，我与你誓不两立")
return true;
}
public void jiaoBHF(int number) {
super.mediator.execute("bangZi.jiaoBHF");
}
}
这样每个类只需要处理自己的方法，要交互直接扔给中介。
模式定义
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
public abstract class Mediator { //定义同事类
protected ConcreteColleague1 c1;
protected ConcreteColleague2 c2;
//通过getter/setter方法把同事类注入进来
public ConcreteColleague1 getC1() {
return c1;
}
public void setC1(ConcreteColleague1 c1) {
this.c1 = c1;
}
public ConcreteColleague2 getC2() {
return c2;
}
public void setC2(ConcreteColleague2 c2) {
this.c2 = c2;
}
//中介者模式的业务逻辑
public abstract void doSomething1();
public abstract void doSomething2();
}
public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
//调用同事类的方法，只要是public方法都可以调用
super.c1.selfMethod1();
super.c2.selfMethod2();
}
public void doSomething2() {
super.c1.selfMethod1();
super.c2.selfMethod2();
}
}
public abstract class Colleague {
protected Mediator mediator;
public Colleague(Mediator _mediator){
this.mediator = _mediator;
}
}
public class ConcreteColleague1 extends Colleague {
//通过构造函数传递中介者
public ConcreteColleague1(Mediator _mediator){
super(_mediator);
}
//自有方法 self-method
public void selfMethod1(){
//处理自己的业务逻辑
}
//依赖方法 dep-method
public void depMethod1(){
//处理自己的业务逻辑
//自己不能处理的业务逻辑，委托给中介者处理
super.mediator.doSomething1();
}
}
特点
- 减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖。
- 同事类只依赖中介者，减少了依赖，同时也降低了类间的耦合。
- 中介者会膨胀得很大，而且逻辑复杂。
- 适用于多个对象之间紧密耦合的情况，就是在类图中出现了蜘蛛网状结构。在这种情况下要考虑使用中介者模式变成星型结构。
网友评论