美文网首页
中介者模式(Mediator)

中介者模式(Mediator)

作者: shenlong77 | 来源:发表于2019-05-07 14:17 被阅读0次

    本文参考自:《JAVA设计模式》之中介者模式(Mediator)

    1. 作用

    中介者模式也称为调停者模式,调停者模式是对象的行为模式。调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时,不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

    2. 需要中介者模式的原因

    如下图所示,这个示意图中有大量的对象,这些对象既会影响别的对象,又会被别的对象所影响,因此常常叫做同事(Colleague)对象。这些同事对象通过彼此的相互作用形成系统的行为。从图中可以看出,几乎每一个对象都需要与其他的对象发生相互作用,而这种相互作用表现为一个对象与另一个对象的直接耦合。这就是过度耦合的系统。


    未引入中介者模式的系统

    通过引入调停者对象(Mediator),可以将系统的网状结构变成以中介者为中心的星形结构,如下图所示。在这个星形结构中,同事对象不再通过直接的联系与另一个对象发生相互作用;相反的,它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定,也就是说,系统的结构不会因为新对象的引入造成大量的修改工作。


    引入中介者模式的系统
    3. 结构
    中介者模式结构

    中介者模式的四个角色

    • 抽象的中介者(Mediator)
      定义出同事对象到调停者对象的接口,其中主要方法是一个(或多个)事件方法。
    • 具体的中介者(ConcreteMediator)
      实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类,并负责具体的协调各同事对象的交互关系。
    • 抽象的同事类(Colleague)
      定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。
    • 具体的同事类(ConcreteColleague)
      所有的具体同事类均从抽象同事类继承而来。实现自己的业务,在需要与其他同事通信的时候,就与持有的调停者通信,调停者会负责与其他的同事交互。
    4. 实现

    抽象的中介者

    public interface Mediator {
        void change(Colleague c);
    }
    

    具体的中介者

    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 change(Colleague c) {
            if(c instanceof ConcreteColleagueA) {
                System.out.println(((ConcreteColleagueA) c).getName());
            }else if(c instanceof ConcreteColleagueB) {
                System.out.println(((ConcreteColleagueB) c).getName());
            }
            
        }
        
    }
    

    抽象的同事类

    public abstract class Colleague {
        
        private Mediator mediator;
        
        public Colleague(Mediator mediator) {
            this.mediator = mediator;
        }
        
        public Mediator getMediator() {
            return this.mediator;
        }
        
        public abstract void operate();
    }
    
    

    具体的同事类

    public class ConcreteColleagueA extends Colleague{
    
        private String name;
        public ConcreteColleagueA(Mediator mediator) {
            super(mediator);
        }
        
        public String getName() {
            return this.name;
        }
        
        @Override
        public void operate() {
            this.name = "colleagueA";
            getMediator().change(this);
        }
    }
    
    public class ConcreteColleagueB extends Colleague{
    
        private String name;
        public ConcreteColleagueB(Mediator mediator) {
            super(mediator);
        }
        
        public String getName() {
            return this.name;
        }
        @Override
        public void operate() {
            this.name = "colleagueB";
            getMediator().change(this);
        }
    }
    
    

    客户端调用

    public class MediatorPatternMain {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ConcreteMediator mediator = new ConcreteMediator();
            ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
            ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
            
            mediator.setColleagueA(colleagueA);
            mediator.setColleagueB(colleagueB);
            
            colleagueA.operate();
            colleagueB.operate();
        }
    
    }
    
    5. 具体实例

    在日常生活中,我们经常使用电脑来看电影,把这个过程描述出来,简化后假定会有如下的交互过程:

    (1)首先是光驱要读取光盘上的数据,然后告诉主板,它的状态改变了。

    (2)主板去得到光驱的数据,把这些数据交给CPU进行分析处理。

    (3)CPU处理完后,把数据分成了视频数据和音频数据,通知主板,它处理完了。

    (4)主板去得到CPU处理过后的数据,分别把数据交给显卡和声卡,去显示出视频和发出声音。

    要使用调停者模式来实现示例,那就要区分出同事对象和调停者对象。很明显,主板是调停者,而光驱、声卡、CPU、显卡等配件,都是作为同事对象。


    框架图

    抽象的中介者

    public interface Mediator {
        void change(Colleague colleague);
    }
    
    

    具体的中介者-主板类

    public class MainBoard implements Mediator{
        private CDReader cdReader;
        private CPU cpu;
        private SoundPlayer soundPlayer;
        private VideoPlayer videoPlayer;
        
        public void setCDReader(CDReader cdReader) {
            this.cdReader = cdReader;
        }
        
        public void setCPU(CPU cpu) {
            this.cpu = cpu;
        }
        
        public void setSoundPlayer(SoundPlayer soundPlayer) {
            this.soundPlayer = soundPlayer;
        }
        
        public void setVideoPlayer(VideoPlayer videoPlayer) {
            this.videoPlayer = videoPlayer;
        }
        
        @Override
        public void change(Colleague colleague) {
            if(colleague instanceof CDReader) {
                String cdReaderData = ((CDReader)colleague).getData();
                operateCPU(cdReaderData);
            }else if(colleague instanceof CPU) {
                List<String> cpuDataList = ((CPU)colleague).getDataList();
                operateSoundPlayer(cpuDataList.get(0));
                operateVideoPlayer(cpuDataList.get(1));
            }
        }
        
        private void operateCPU(String data) {
            cpu.operate(data);
        }
        
        private void operateSoundPlayer(String data) {
            soundPlayer.playSound(data);
        }
        
        private void operateVideoPlayer(String data) {
            videoPlayer.playVideo(data);
        }
    }
    
    

    抽象的同事类

    public class Colleague {
        private Mediator mediator;
        
        public Colleague(Mediator mediator) {
            this.mediator = mediator;
        }
        
        public Mediator getMediator() {
            return this.mediator;
        }
        
    }
    

    具体的同事类-光驱类

    public class CDReader extends Colleague{
    
        private String data;
        public CDReader(Mediator mediator) {
            super(mediator);
        }
        
        public String getData() {
            return this.data;
        }
        
        public void read() {
            this.data = "sound,video";
            getMediator().change(this);
        }
    }
    

    具体的同事类-CPU类

    public class CPU extends Colleague{
    
        private List<String> dataList;
        
        public CPU(Mediator mediator) {
            super(mediator);
            dataList = new ArrayList<>();
        }
        
        public List<String> getDataList(){
            return dataList;
        }
        public void operate(String data) {
            String[] liStrings = data.split(",");
            dataList.add(liStrings[0]);
            dataList.add(liStrings[1]);
            getMediator().change(this);
        }
    }
    

    具体的同事类-声卡类

    public class SoundPlayer extends Colleague{
        
        public SoundPlayer(Mediator mediator) {
            super(mediator);
        }
        
        public void playSound(String sound) {
            System.out.println(sound);
        }
    }
    

    具体的同事类-显卡类

    public class VideoPlayer extends Colleague{
        
        public VideoPlayer(Mediator mediator) {
            super(mediator);
        }
        
        public void playVideo(String video) {
            System.out.println(video);
        }
    }
    

    客户端调用

    public class MediatorPatternDemoMain {
    
        public static void main(String[] args) {
            MainBoard mainBoard = new MainBoard();
            
            CDReader cdReader = new CDReader(mainBoard);
            CPU cpu = new CPU(mainBoard);
            SoundPlayer soundPlayer = new SoundPlayer(mainBoard);
            VideoPlayer videoPlayer = new VideoPlayer(mainBoard);
            
            mainBoard.setCDReader(cdReader);
            mainBoard.setCPU(cpu);
            mainBoard.setSoundPlayer(soundPlayer);
            mainBoard.setVideoPlayer(videoPlayer);
            
            cdReader.read();
            
        }
    
    }
    
    
    6. 中介者模式的优缺点

    优点

    • 松散耦合
      调停者模式通过把多个同事对象之间的交互封装到调停者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。
    • 集中控制交互
      多个同事对象的交互,被封装在调停者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改调停者对象就可以了,当然如果是已经做好的系统,那么就扩展调停者对象,而各个同事类不需要做修改。
    • 多对多变成一对多
      没有使用调停者模式的时候,同事对象之间的关系通常是多对多的,引入调停者对象以后,调停者对象和同事对象的关系通常变成双向的一对多,这会让对象的关系更容易理解和实现。

    缺点

    调停者模式的一个潜在缺点是,过度集中化。如果同事对象的交互非常多,而且比较复杂,当这些复杂性全部集中到调停者的时候,会导致调停者对象变得十分复杂,而且难于管理和维护。

    相关文章

      网友评论

          本文标题:中介者模式(Mediator)

          本文链接:https://www.haomeiwen.com/subject/dxnroqtx.html