设计模式学习--------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;
	}
}

原理分析：

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

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

本质： 封装交互