设计模式学习--------11.中介者模式学习

场景：

构建一个部门管理和人员管理的模块.比如一个部门可以有多个人,一个人可以属于多个部门。

现增加一些功能:

1.部门被撤销,就需要通知清除这个部门下面的所有人后再删除部门.

2.部门之间合并,需要把原来的两个部门撤销,新增一个新部门,将原来两个部门的人员归入新部门中.

3.人员离职,需要从原来的部门将其清除.

4. 人员调动,从原来部门清除,新增到新部门.

可以看到,部门类和人员类之间耦合交互频繁,每个类的改变都会影响到其他类。如何简化多个对象的交互呢？

定义：

用一个中介者对象来封装一系列的对象交互。中介者使得各对象不需要显示的相互引用，从而使其耦合松散，

而且可以独立改变它们之间的交互。

角色:

Mediator:

中介者接口.在里面定义各个同事之间交互需要的方法。

package com.kris.study;

public interface Mediator {
public void changed(Colleague colleage);
}

ConcreteMediator:

具体中介者实现对象,它需要了解并维护各个同事对象,并负责具体的协调各同事对象的交互关系。

package com.kris.study;

public class ConcreteMediator implements Mediator {

private ConcreteColleagueA colleagueA;

private ConcreteColleagueB colleagueB;

public void setColleagueA(ConcreteColleagueA colleagueA) {
this.colleagueA = colleagueA;
}

public void setColleagueB(ConcreteColleagueB colleagueB) {
this.colleagueB = colleagueB;
}

@Override
public void changed(Colleague colleage) {
//某个Colleague对象发生了变化,需要与其他同事交互
//具体协调相应的同事对象来实现协作行为
}

}

Colleague:

同事类的定义,通常实现成为抽象类。主要负责约束同事对象的类型，并实现一些具体同事对象之间的公共功能。

package com.kris.study;

public abstract class Colleague {
private Mediator mediator;

public Colleague(Mediator mediator){
this.mediator = mediator;
}

public Mediator getMediator(){
return mediator;
}
}

ConcreteColleague:

具体的同事类，实现自己的业务。在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他同事

的交互。

package com.kris.study;

public class ConcreteColleagueA extends Colleague {

public ConcreteColleagueA(Mediator mediator) {
super(mediator);
}

public void someOperation(){
getMediator().changed(this);
}
}

package com.kris.study;

public class ConcreteColleagueB extends Colleague {

public ConcreteColleagueB(Mediator mediator) {
super(mediator);
}

public void someOperation(){
getMediator().changed(this);
}
}

在实际开发中，经常会简化中介者模式，来使开发变得简单。

比如会去掉同事对象的父类Colleague,任意对象只需要相互交互，就可以成为同事。

不定义Mediator接口，把具体的中介者对象实现为单例。

同事对象不再持有中介者，而是在需要的时候直接获取调用。

这样简化后的中介者模式称为广义中介者。

使用广义中介者模式解决场景中的例子：

package com.kris.study;

/**
*   部门类
*/
public class Dep {
private String depId;
private String depName;

public String getDepId() {
return depId;
}

public void setDepId(String depId) {
this.depId = depId;
}

public String getDepName() {
return depName;
}

public void setDepName(String depName) {
this.depName = depName;
}

public boolean deleteDep(){
Mediator mediator = Mediator.getInstance();
mediator.deleteDep(depId);
return true;
}
}

package com.kris.study;

/**
*  人员类
*/
public class User {
private String userId;
private String userName;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}

public boolean deleteUser(){
Mediator mediator = Mediator.getInstance();
mediator.deleteDep(userId);
return true;
}

}

package com.kris.study;

/**
*  部门与人员对应关系类
*/
public class DepUserModel {
private String depUserId;
private String depId;
private String userId;
public String getDepUserId() {
return depUserId;
}
public void setDepUserId(String depUserId) {
this.depUserId = depUserId;
}
public String getDepId() {
return depId;
}
public void setDepId(String depId) {
this.depId = depId;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}

}

package com.kris.study;

import java.util.ArrayList;
import java.util.Collection;

public class Mediator {
private static Mediator mediator = new Mediator();

private Mediator() {
}

public static Mediator getInstance() {
return mediator;
}

private Collection<DepUserModel> depUserCol = new ArrayList<DepUserModel>();

/**
* 删除撤销某个部门
*/
public boolean deleteDep(String depId) {
Collection<DepUserModel> tempCol = new ArrayList<DepUserModel>();
for (DepUserModel du : depUserCol) {
if (du.getDepId().equals(depId)) {
tempCol.add(du);
}
}
depUserCol.removeAll(tempCol);
return true;
}

/**
* 人员离职
*/
public boolean deleteUser(String userId){
Collection<DepUserModel> tempCol = new ArrayList<DepUserModel>();
for (DepUserModel du : depUserCol) {
if (du.getUserId().equals(userId)) {
tempCol.add(du);
}
}
depUserCol.removeAll(tempCol);
return true;
}
}

原理分析：

优点：松散耦合，集中控制

缺点： 过度集中化。同事对象交互过多,中介者对象就变得十分复杂,难于维护。

本质： 封装交互