Java设计模式之中介者模式

• 1. 中介者模式概述
• • 1.1 中介者模式简介
  • 1.2 中介者模式类图
• 2. 中介者模式实现
• • 2.1 案例需求分析
  • 2.2 代码实现

1.中介者模式（Mediator Pattern），用一个对象来表达尊贵的对象互动。相互引用，才能导致松散，才能独立地改变它们之间的交互。
2.中介者模式属于行为型模式，使代码维护统一。
3.例如MVC模式，C（控制器控制器）是M（模型模型）和V（查看视图）的中介者，在前回交互时起到了中间人的作用。

1.Mediator就是抽象中介者，定义了同事对象到中介对象的接口。
2.同事是南方同事类。
3.oncreteMediator具体的中介者对象，实现方法抽象，他需要的所有具体的同事类，知道即以一个集合来管理HashMap，并接受某个对象对象消息，完成相应的任务。
4.具体的同事类，自己会有很多具体的同事只知道，而不是了解其他同事类的行为（方法），但是他们都依赖中介对象。

中介者模式更多是用于多个对象协同工作，但是又不会出现耦合情况，解耦作用。

智能家庭项目
1.智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘 等
2.主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为：闹铃响起->咖啡机开始做咖啡->窗帘自动落下->电视机开始播放。

项目结构
Mediator：中介者
ConcreteMediator：具体的中介者类

Colleague：同事抽象类
Alarm：闹钟
CoffeeMachine：咖啡机
Curtains：窗帘
TV：电视

Client：测试类

Mediator

package com.zrj.design.intermediary;


public abstract class Mediator {
    //将给中介者对象，加入到集合中
    public abstract void Register(String colleagueName, Colleague colleague);

    //接收消息, 具体的同事对象发出
    public abstract void GetMessage(int stateChange, String colleagueName);


    public abstract void SendMessage();
}

ConcreteMediator

package com.zrj.design.intermediary;

import java.util.HashMap;


public class ConcreteMediator extends Mediator {
    //集合，放入所有的同事对象
    private HashMap colleagueMap;
    private HashMap interMap;

    public ConcreteMediator() {
        colleagueMap = new HashMap();
        interMap = new HashMap();
    }

    @Override
    public void Register(String colleagueName, Colleague colleague) {
        if (colleague instanceof Alarm) {
            interMap.put( "Alarm", colleagueName );
        } else if (colleague instanceof CoffeeMachine) {
            interMap.put( "CoffeeMachine", colleagueName );
        } else if (colleague instanceof TV) {
            interMap.put( "TV", colleagueName );
        } else if (colleague instanceof Curtains) {
            interMap.put( "Curtains", colleagueName );
        }

    }

    
    @Override
    public void GetMessage(int stateChange, String colleagueName) {
        //处理闹钟发出的消息
        if (colleagueMap.get( colleagueName ) instanceof Alarm) {
            if (stateChange == 0) {
                ((CoffeeMachine) (colleagueMap.get( interMap.get( "CoffeeMachine" ) ))).StartCoffee();
                ((TV) (colleagueMap.get( interMap.get( "TV" ) ))).StartTv();
            } else if (stateChange == 1) {
                ((TV) (colleagueMap.get( interMap.get( "TV" ) ))).StopTv();
            }

        } else if (colleagueMap.get( colleagueName ) instanceof CoffeeMachine) {
            ((Curtains) (colleagueMap.get( interMap.get( "Curtains" ) ))).UpCurtains();

        } else if (colleagueMap.get( colleagueName ) instanceof TV) {// 如果 TV 发现消息

        } else if (colleagueMap.get( colleagueName ) instanceof Curtains) {
            //如果是以窗帘发出的消息，这里处理...
        }

    }

    @Override
    public void SendMessage() {
    }

}

Colleague

package com.zrj.design.intermediary;


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

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

    }

    public Mediator GetMediator() {
        return this.mediator;
    }

    public abstract void SendMessage(int stateChange);
}

Alarm

package com.zrj.design.intermediary;


public class Alarm extends Colleague {
    //构造器
    public Alarm(Mediator mediator, String name) {
        //在创建 Alarm 同事对象时，将自己放入到 ConcreteMediator 对象中[集合] mediator.Register(name, this);
        super( mediator, name );
    }

    public void SendAlarm(int stateChange) {
        SendMessage( stateChange );
    }

    
    @Override
    public void SendMessage(int stateChange) {
        //System.out.println( "闹钟发送信息：" + stateChange );
    }

}

CoffeeMachine

package com.zrj.design.intermediary;


public class CoffeeMachine extends Colleague {

    public CoffeeMachine(Mediator mediator, String name) {
        super( mediator, name );
    }

    @Override
    public void SendMessage(int stateChange) {
        //System.out.println( "咖啡机发送信息：" + stateChange );
    }

    public void StartCoffee() {
        System.out.println( "It's time to startcoffee!" );
    }

    public void FinishCoffee() {
        System.out.println( "After 5 minutes!" );
        System.out.println( "Coffee is ok!" );
        SendMessage( 0 );
    }
}

Curtains

package com.zrj.design.intermediary;


public class Curtains extends Colleague {

    public Curtains(Mediator mediator, String name) {
        super( mediator, name );
    }

    @Override
    public void SendMessage(int stateChange) {
        //System.out.println( "窗帘发送信息：" + stateChange );
    }

    public void UpCurtains() {
        System.out.println( "I am holding Up Curtains!" );
    }

}

TV

package com.zrj.design.intermediary;


public class TV extends Colleague {

    public TV(Mediator mediator, String name) {
        super( mediator, name );
        mediator.Register( name, this );

    }

    @Override
    public void SendMessage(int stateChange) {
        //System.out.println( "TV发送信息：" + stateChange );
    }

    public void StartTv() {
    }

    public void StopTv() {
    }
}

Client

package com.zrj.design.intermediary;


public class Client {
    public static void main(String[] args) {
        //创建一个中介者对象
        Mediator mediator = new ConcreteMediator();

        //创建 Alarm  并且加入到    ConcreteMediator 对象的 HashMap
        Alarm alarm = new Alarm( mediator, "alarm" );

        //创建了 CoffeeMachine 对象，并    且加入到    ConcreteMediator 对象的 HashMap
        CoffeeMachine coffeeMachine = new CoffeeMachine( mediator, "coffeeMachine" );

        //创建  Curtains , 并    且加入到    ConcreteMediator 对象的 HashMap
        Curtains curtains = new Curtains( mediator, "curtains" );
        TV tV = new TV( mediator, "TV" );

        //让闹钟发出消息
        alarm.SendAlarm( 0 );
        coffeeMachine.FinishCoffee();
        alarm.SendAlarm( 1 );
    }
}