java 内置中介模式_设计模式-中介者模式（Mediator）以及JDK类库中的应用

中介者模式

定义

用一个中介者来封装一系列的对象交互，这一系列对象不需要显示的互相引用，从而使其解耦合，而且可以独立的改变它们之间的交互。

结构

Mediator：抽象中介者，它定义了具体同事类交互的接口。

ConcreteMediator：具体中介者类，它持有所有具体同事类的引用，实现了抽象类中定义的接口，并且维护具体同事类之间交互的业务逻辑。

Colleague：抽象同事类，它持有抽象中介者类的引用，并在构造器中初始化值。

ConcreteColleague：具体同事类，它只知道自己的行为方法和中介者类，而不知道其他类的方法。

类图

抽象中介者类：

public abstract class Mediator {

public abstract void send(String message,Colleague colleague);

}

具体中介者类：

public class ConcreteMediator extends Mediator{

private ConcreteColleague1 colleague1;

private ConcreteColleague2 colleague2;

@Override

public void send(String message, Colleague colleague) {

if(colleague == colleague1){

colleague2.Notify(message);

}else{

colleague1.Notify(message);

}

}

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;

}

}

抽象同事类：

public abstract class Colleague {

public Mediator mediator;

public Colleague(Mediator mediator){

this.mediator = mediator;

}

public Mediator getMediator() {

return mediator;

}

public void setMediator(Mediator mediator) {

this.mediator = mediator;

}

}

具体同事类1：

public class ConcreteColleague1 extends Colleague{

public ConcreteColleague1(Mediator mediator){

super(mediator);

}

public void send(String message){

mediator.send(message, this);

}

public void Notify(String message){

System.out.println("具体同事1收到消息："+message);

}

}

具体同事类2：

public class ConcreteColleague2 extends Colleague{

public ConcreteColleague2(Mediator mediator){

super(mediator);

}

public void send(String message){

mediator.send(message, this);

}

public void Notify(String message){

System.out.println("具体同事2收到消息："+message);

}

}

测试类：

public static void main(String[] args) {

ConcreteMediator cm = new ConcreteMediator();

ConcreteColleague1 c1 = new ConcreteColleague1(cm);

ConcreteColleague2 c2 = new ConcreteColleague2(cm);

cm.setColleague1(c1);

cm.setColleague2(c2);

c1.send("nice to meet you");

c2.send("nice to meet you too");

}

测试结果：

优点

1.具体同事类之间解耦合。

2.符合迪米特法则，如果两个对象需要互相调用可以通过第三方对象转发方法。

缺点

中介者对象需要处理各个具体同事类之间的交互逻辑，它的职责过多，不利于维护，并且不符合开闭原则，即对扩展开放，对修改封闭。

JDK类库中的中介者模式

java.util.Timer

请看下面的例子，timer是一个中介者，它持有新创建到TimerTask的引用，timer负责执行TimerTask的定时任务。

Timer timer = new Timer();

timer.schedule(new TimerTask() {

@Override

public void run() {

System.out.println("nice to meet u");

}

}, new Date(),1000);

timer.schedule(new TimerTask() {

@Override

public void run() {

System.out.println("nice to meet u too");

}

}, new Date(),1000);

java.util.concurrent.Executor#execute(Runnable command)

java.util.concurrent.ExecutorService#submit(Runnable command)

请看下面的例子，exec是一个中介者，它持有Runnable的引用，exec是一个异步任务执行者，它负责执行Runnable任务。

Executor exec = Executors.newFixedThreadPool(100);

exec.execute(new Runnable() {

@Override

public void run() {

System.out.println("nice to meet u");

}

});

exec.execute(new Runnable() {

@Override

public void run() {

System.out.println("nice to meet u too");

}

});

java.lang.reflect.Method#invoke(Obj obj,Object… args)

请看下面的例子，getName是一个中介者，，它持有User实例化对象的引用，它负责执行实例化对象的方法。

Class> clazz = Class.forName("com.headfirst.abstractfactorymode.dao.User");

User user1 = (User) clazz.newInstance();

User user2 = (User) clazz.newInstance();

user1.setName("zhangsan");

user2.setName("lisi");

Method getName = clazz.getMethod("getName");

Object invoke1 = getName.invoke(user1);

Object invoke2 = getName.invoke(user2);

System.out.println(invoke1);

System.out.println(invoke2);