设计模式（9）- 中介者模式

中介者模式

1.定义

       用一个中介对象来封装一系列对象交互。中介者使得各个对象不需要显示的相互引用，从而使其松散耦合，而且可以独立的改变他们直接的交互。

2.示例代码

      

/*所有需要交互的对象都被视为同事类，同事类持有中介者对象*/
pubic abstract class Colleague{
    //持有中介者对象的接口
    private Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
    public Mediator getMediator(){
        return mediator;
    }
}

/*光驱类，一个同事类,读取光驱数据传递给主板*/
public class CDDriver extends Colleague{
   public CDDriver(Mediator mediator){
       super(mediator);
   }
   /*光驱读取出来的数据*/
   private String data = "";
   /*获取读取的数据*/
   public String getData(){
      return this.data;
   }
   /*读取光盘数据*/
   public void readCD(){
      //逗号前的是视频显示数据，逗号后面的是声音
      this.data = "设计模式，值得好好研究";
      //通知主板，自己的状态发生了改变
      this.getMediator().change(this);
   }
}

/*CPU类，一个同事类，解析数据，传递给主板*/
public class CPU extends Colleague{
    public CPU(Mediator mediator){
       super(mediator);
    }
    //分解出来的视频数据和声音数据
    private String videoData = "";
    private String soundData = "";
    public String getVideoData(){
        return videoData;
    }
    public String getSoundData(){
        return soundData;
    }
    /*处理数据，把视频音频数据解析出来*/
    public void executeData(String data){
        String[] ss = data.split(",");
        this.videoData = ss[0];
        this.soundData = ss[1];
        //通知主板，cpu的工作完成
        this.getMediator().change(this);
    }
}

/*显卡同事类，负责显示数据*/
pubic class VideoCard extends Colleague{
    public VideoCard(Mediator mediator){
       super(mediator);
    }
    /*显示视频数据*/
    pubilc void showData(String data){
       System.out.println("您正在观看的是：" + data);
    }
}

/*声卡同事类，负责播放数据*/
pubic class SoundCard extends Colleague{
    public SoundCard(Mediator mediator){
       super(mediator);
    }
    /*显示视频数据*/
    pubilc void soundData(String data){
       System.out.println("画外音：" + data);
    }
}

   

/*中介者对象接口*/
pubic interface Mediator{
    /*同事对象在自身状态改变的时候通知中介者的方法*/
    public void changed(Colleague colleague); 
}

/*主板类，实现中介者对象*/
public class MotherBoard implements Mediator{
    /*需要知道交互的同事类-光驱类*/
    private CDDirver cdDriver = null ;
    /*需要知道交互的同事类-cpu类*/
    private CPU cpu = null ;
    /*需要知道交互的同事类-显卡类*/
    private VideoCard videoCard = null ;
    /*需要知道交互的同事类-声卡类*/
    private SoundCard soundCard = null ;
    public void setCdDriver(CDDriver cdDriver){
        this.cdDriver = cdDriver;
    }
    public void setCpu(CPU cpu){
        this.cpu= cpu;
    }
    public void setVideoCard(VideoCard videoCard){
        this.videoCard= videoCard;
    }
    public void setSoundCard(SoundCard soundCard){
        this.soundCard= soundCard;
    }
    public void changed(Colleague colleague){
         if(colleague == cdDriver){
            //光驱已经读取了数据
            this.openCDDriverReadData((CDDriver)colleague);
         }else if(colleague == cpu){
            //cpu已经解析了数据
            this.openCPU((CPU)colleague);
         }
    }
    /*处理光驱读取完的数据与其他对象交互*/
    private void openCDDriverReadData(CDDriver cd){
         //读取光驱数据
         String data = cd.getData();
         //把数据交给cpu处理
         this.cpu.executeData(data);
    }
    /*处理cpu解析完的数据与其他对象交互*/
    private void openCPU(CPU cpu){
         //读取cpu处理的数据
         String videoData = cd.getVedioData();
         String soundData = cd.getSoundData();
         //把数据交给显卡和声卡处理
         this.videoCard.showData(videoData);
         this.soundData.soundData(soundData);
    }
}

   

/*播放电影示意操作*/
public class Client{
    public static void main(String args[]){
        //1.创建中介者对象
        MotherBoard mediator = new MotherBoard();
        //2.创建同事类
        CDDriver cd = new CDDriver(mediator);
        CPU cpu = new CPU(mediator);
        VideoCard vc = new VideoCard(mediator);
        SoundCard sc = new SoundCard(mediator);
        //3.让中介者知道所有的同事
        mediator.setCdDriver(cd);
        mediator.setCpu(cpu);
        mediator.setVideoCard(vc);
        mediator.setSoundCard(sc);
        //4.打开光驱看电影
        cd.readCD();
    }
}

 

3.实际应用

       中介者模式通过把多个同事对象之间的交互封装到中介者对象里边，从而使的同事对象之间松散耦合。多个同事对象的交互，被封装到中介者里边集中管理。缺点是过度集中化。

 

中介者模式的本质：封装交互