设计模式学习笔记——中介者模式

中介者模式

中介者模式，又称为调停者模式，用一个中介者对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立改变它们之间的交互。（行为类模式）

结构图

抽象中介者Mediator：定义好同事类到中介者对象的接口，用于各个同事类之间的通信。一般包括一个或几个抽象事件方法，并由子类去实现。

中介者实现类ConcreteMediator：继承自抽象中介者，实现抽象中介者中定义的事件方法。从同事类接受消息，通过消息影响其他同事类。

同事类Colleague：如果一个对象会影响其他对象，同时也会被其他对象影响，那么这两个对象成为同事类。同事类可以表现为继承了一个抽象类的一组实现组成。中介者模式中，同事类之间必须同事中介者才能进行消息传递。

demo

未添加中介者

抽象中介者Mediator：

package com.xk.day0430.Mediator;

/**
* 抽象同事类
*
* @author xukai 2016年4月30日 下午2:55:47
*
*/
public abstract class AbstractColleague {

protected int number;

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

/**
* 设置数值
*
* @param number
* @param impl
*/
public abstract void setNumber(int number, AbstractColleague impl);

}

同事类ColleagueA：

/**
* 同事类A
* A.number = B.number / 100
* @author xukai 2016年4月30日 下午2:59:40
*
*/
public class ColleagueA extends AbstractColleague {

@Override
public void setNumber(int number, AbstractColleague impl) {
this.number = number;
impl.setNumber(number * 100);
}

}

同事类ColleagueB：

/**
* 同事类B
* B.number = A.number * 100
* @author xukai 2016年4月30日 下午3:00:31
*
*/
public class ColleagueB extends AbstractColleague {

@Override
public void setNumber(int number, AbstractColleague impl) {
this.number = number;
impl.setNumber(number / 100);
}

}

前提：同事类B中的数值为同事类A中数值的100倍。
客户端测试：

package com.xk.day0430.Mediator;

public class Client {

public static void main(String[] args) {
AbstractColleague implA = new ColleagueA();
AbstractColleague implB = new ColleagueB();

// A->B B.number = A.number * 100;
implA.setNumber(1234, implB);
System.out.println("implA.number= " + implA.getNumber());
System.out.println("implB.number= " + implB.getNumber());

// B->A A.number = B.number / 100;
implB.setNumber(45600, implA);
System.out.println("implA.number= " + implA.getNumber());
System.out.println("implB.number= " + implB.getNumber());

}

}

添加中介者

抽象中介者AbstractColleague：

/**
* 抽象中介者类
*
* @author xukai 2016年4月30日 下午5:06:01
*
*/
public abstract class AbstractMediator {

protected AbstractColleague implA;

protected AbstractColleague implB;

public AbstractMediator(AbstractColleague implA, AbstractColleague implB) {
this.implA = implA;
this.implB = implB;
}

/**
* A->B A影响B
*/
public abstract void implAB();

/**
* B->A B影响A
*/
public abstract void implBA();

}

具体中介者Mediator：

package com.xk.day0430.Mediator.demo;

/**
* 中介者实现
*
* @author xukai 2016年4月30日 下午5:09:55
*
*/
public class Mediator extends AbstractMediator {

public Mediator(AbstractColleague implA, AbstractColleague implB) {
super(implA, implB);
}

@Override
public void implAB() {
implB.setNumber(implA.getNumber() * 100);
}

@Override
public void implBA() {
implA.setNumber(implB.getNumber() / 100);
}

}

抽象同事类：

package com.xk.day0430.Mediator.demo;

/**
* 抽象同事类
*
* @author xukai 2016年4月30日 下午5:04:39
*
*/
public abstract class AbstractColleague {

protected int number;

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

/**
* 设置数值
*
* @param number
* @param mediator
*            中介者
*/
public abstract void setNumber(int number, AbstractMediator mediator);

}

同事类：

/**
* 同事类A
* A.number = B.number / 100
* @author xukai 2016年4月30日 下午2:59:40
*
*/
public class ColleagueA extends AbstractColleague {

@Override
public void setNumber(int number, AbstractMediator mediator) {
this.number = number;
mediator.implAB();
}

}

/**
* 同事类B
* B.number = A.number * 100
* @author xukai 2016年4月30日 下午3:00:31
*
*/
public class ColleagueB extends AbstractColleague {

@Override
public void setNumber(int number, AbstractMediator mediator) {
this.number = number;
mediator.implBA();
}

}

客户端：

public class Client {

public static void main(String[] args) {
AbstractColleague implA = new ColleagueA();
AbstractColleague implB = new ColleagueB();

// 中介者
AbstractMediator mediator = new Mediator(implA, implB);

// 通过中介者：A->B B.number = A.number * 100;
implA.setNumber(1234, mediator);
System.out.println("implA.number= " + implA.getNumber());
System.out.println("implB.number= " + implB.getNumber());

// 通过中介者：B->A A.number = B.number / 100;
implB.setNumber(45600, mediator);
System.out.println("implA.number= " + implA.getNumber());
System.out.println("implB.number= " + implB.getNumber());
}
}

控制台：

implA.number= 1234
implB.number= 123400
implA.number= 456
implB.number= 45600

下图说明中介者的作用：


    

总结

优点

1.可以避免同事类之间的耦合过度，使同事类之间可以相互独立使用。（迪米特原则）

2.一对多关联转变为一对一关联，对象关系容易理解和维护。

3.使用中介者模式可以将对象的行为和协作进行抽象，灵活处理对象之间的作用。

大多数情况下，将对象间的依赖关系封装在同事类内部就可以，没必要非要引入中介者模式，否则，可能更加复杂。