场景：
构建一个部门管理和人员管理的模块.比如一个部门可以有多个人,一个人可以属于多个部门。
现增加一些功能:
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;
}
}
原理分析：
优点：松散耦合，集中控制
缺点： 过度集中化。同事对象交互过多,中介者对象就变得十分复杂,难于维护。
本质： 封装交互