中介者模式

先看图：

　　　　　　　　　　　　　　图一
　
　　　　　　　　　　　　　　图二
　
　　　　　　　　　　　　　　图三

　　在大公司中，部门越完善，同事之间的关系就越复杂，就比如说你要申请买某个办公设备，需要你领导同意，然后找采购部门同事，采购部门同事需要找财务部门同事，最后买好了才下发到你手上，整个流程之间涉及到多个部门，关系复杂，同事之间涉及越多就越像蜘蛛网，如图一、二所示。

我们加入了中介者就可以让他们之间的关系简单化，如图三。这就是中介模式。

中介者模式定义
　　中介者模式：Define an object that encapsulates how a set of objects interact mediator prometes loose coupling by keeping objects from refering to each other explicitly,and it lets you vary their interaction independtly.(用一个中介对象封装一系列的对象交互，中介者使各个对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变他们之间的交互。)

中介者模式中的角色
　　Mediator抽象中介者角色
　　抽象中介者角色定义统一的接口，用于各部门之间的通信。
　　Concrete Mediator 具体中介者角色
　　具体中介者角色通过协调各种角色实现协作行为，因此他必须依赖于各个同事角色。
　　Colleague同事角色
　　每个同事角色都需要知道中介者角色，而且与其他的同事角色通信的时候，一定要中介者角色协作。

下面来看实例代码：
　　公司正常上班都会有群聊来发送通知或者讨论问题，就以群聊过程来演示中介者模式（服务器相当于中介者）。
抽象中介者：

public  interface Mediator
{
        //同事登录群聊系统
        public  void login(Colleague colleague);
        //发送消息到每个同事
        public  void dispatch(Colleague colleague,String msg);
}

具体中介者：

public class ConcreteMediator implements Mediator
{
     private ArrayList<Colleague> userList=new ArrayList<Colleague>();  
    @Override
    public void login(Colleague colleague)
    {
        // TODO Auto-generated method stub
        if (colleague!=null && !userList.contains(colleague)) {
            userList.add(colleague);
        }
    }

    @Override
    public void dispatch(Colleague colleague, String msg)
    {
        // TODO Auto-generated method stub
        for(Colleague c : userList)
        {
             if(!c.equals(colleague)){  
                    c.receiveMessage(msg);  
                }  
        }
    }

}

抽象同事：

public  abstract class Colleague
{
        private Mediator mediator;  
        private String name;  

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

        public String getName() {  
            return name;  
        }  
        //接受消息  
        public void receiveMessage(String msg){  
            System.out.println(this.name+"收到消息："+msg);  
        }  
        //发送消息 
        public void sendMessage(String msg){  
            System.out.println(this.name+"说："+msg);  
            mediator.dispatch(this,msg);  
        }  
}

同事张三：

public class Zhangsan extends Colleague
{

    public ColleagueA(String name, Mediator mediator)
    {
        super(name, mediator);
        // TODO Auto-generated constructor stub
        mediator.login(this);
    }

}

同事李四：

public class Lisi extends Colleague
{

    public ColleagueA(String name, Mediator mediator)
    {
        super(name, mediator);
        // TODO Auto-generated constructor stub
        mediator.login(this);
    }

}

同事王五：

public class Wangwu extends Colleague
{

    public ColleagueA(String name, Mediator mediator)
    {
        super(name, mediator);
        // TODO Auto-generated constructor stub
        mediator.login(this);
    }

}

场景类：

public class Client
{
        public static void main(String[] args) {  
            Mediator mediator=new ConcreteMediator();  
           Zhangsan zhangsan =new ColleagueA("张三", mediator);  
           Lisi lisi =new ColleagueB("李四", mediator);  
           Wangwu wangwu =new ColleagueC("王五", mediator);  

            zhangsan.sendMessage("项目完美上线！");  
            System.out.println("---------");  
            lisi.sendMessage("大家辛苦了！");  
            System.out.println("---------");  
            wangwu.sendMessage("领导辛苦了！");  
        }  
}

运行结果：

张三说：项目完美上线！
李四收到消息：项目完美上线！
王五收到消息：项目完美上线！
---------
李四说：大家辛苦了！
张三收到消息：大家辛苦了！
王五收到消息：大家辛苦了！
---------
王五说：领导辛苦了！
张三收到消息：领导辛苦了！
李四收到消息：领导辛苦了！

中介者优点
　　减少类间的依赖，把原有的一对多的依赖变成一对一的依赖，同事类只依赖中介者，减少了依赖，当然也降低了类间的耦合。
中介者缺点
　　中介者会膨胀的很大，而且逻辑复杂，同事越多，中介者逻辑越复杂。