设计模式之简单化_Mediator中介者模式_只有一个仲裁者

忘是亡心i 2024-04-17 06:08 42阅读 0赞

## 前言 ##

#### [博主github][github] ####

#### [博主个人博客http://blog.healerjean.com][http_blog.healerjean.com] ####

## 1、解释 ##

想象一个乱糟糟的开发小组的工作状态，组员之间虽然在一起协同工作，但是意见难以统一，总是相互指挥，导致工作进度滞后。这时候，就需要一个仲裁者。**所有的组员将自己的情况汇报给仲裁者，仲裁者会从团队的整体考虑，然后下达指令。仲裁者负责统一大家的意见**。这样，团队的交流过程就变成了组员向仲裁者报告，仲裁者向组员下达指令的形式，而组员之间不再询问和沟通，**这就是Mediator模式。**

## 2、实例代码 ##

有3个设备，A设备操作要关闭B和C，通过仲裁者来进行操作，而不是他们之间互相调用，其他的大家也可以自己写

### 2.1、设备接口 `Device` ###

public abstract class Device { 
    
    
        public abstract void openDevice(String instruction, AbstractMediator abstractMediator);
    
    
        public abstract void closeDevice(String instruction);
    
    }

### 2.2、`ADevice` ###

public class ADevice extends Device{ 
    
    
        @Override
        public void openDevice(String instruction, AbstractMediator mediator) { 
            System.out.println("A设备正在"+instruction);
            mediator.openA(instruction);
        }
    
        @Override
        public void closeDevice(String instruction) { 
            System.out.println("A设备关闭");
        }
    
    }

### 2.3、`BDevice` ###

public class BDevice extends Device { 
    
    
        /** * 操作该设备 */
        @Override
        public void openDevice(String instruction, AbstractMediator abstractMediator) { 
            abstractMediator.openB(instruction);
        }
    
        @Override
        public void closeDevice(String instruction) { 
            System.out.println("B设备关闭");
        }
    
    
    }

### 2.4、`CDevice` ###

public class CDevice extends Device { 
    
    
        @Override
        public void openDevice(String instruction, AbstractMediator abstractMediator) { 
            abstractMediator.openC(instruction);
        }
    
        @Override
        public void closeDevice(String instruction) { 
            System.out.println("C设备关闭");
        }
    
    
    
    }

### 2.5、仲裁者、中介者 ###

public abstract class AbstractMediator {
    
        /**
         *保留所有设备的引用是为了当接收指令时可以唤醒其他设备的操作
         */
        Device a , b , c;
    
        public AbstractMediator(Device a, Device b, Device c) {
            super();
            this.a = a;
            this.b = b;
            this.c = c;
        }
    
     /**
         * 定义操作属性
         */
        public abstract void openA(String instruction);
        public abstract void openB(String instruction);
        public abstract void openC(String instruction);
    
    }

### 2.6、仲裁者真正实现类 ###

public class ConcreteAbstractMediator extends AbstractMediator { 
    
        public ConcreteAbstractMediator(Device a, Device b, Device c) { 
            super(a, b, c);
        }
    
        /** * 开启A要关闭B和C * @param instruction */
        @Override
        public void openA(String instruction) { 
             b.closeDevice(instruction);
             c.closeDevice(instruction);
        }
    
    
        @Override
        public void openB(String instruction) { 
    
        }
    
        @Override
        public void openC(String instruction) { 
    
        }
    }

### 2.6、测试 ###

public class Main { 
    
        public static void main(String[] args) { 
            Device a = new ADevice();
            Device b = new BDevice();
            Device c = new CDevice();
    
            //把设备引用都保存在调停者中
            AbstractMediator mediator=new ConcreteAbstractMediator(a , b ,c );
    
            a.openDevice("开启",mediator);
        }
    }
    
    
    A设备正在开启
    B设备关闭
    C设备关闭

### 3、总结 ###

使用的时候，我可以在一些互相调用的场景中使用，有一些先后顺序执行的类可以使用该中介者模式，他们之间互相频繁的调用

### 3.1、缺点 ###

1.  如果涉及不好，引入中介者会使程序变的复杂
2.  中介者承担过多责任，维护不好会出大事，合理使用回调（如果我们将closeDevice中传入仲裁者，这样又可以回调了）

![ContactAuthor][]

[github]: https://github.com/HealerJean
[http_blog.healerjean.com]: http://HealerJean.github.io
[ContactAuthor]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/9f379e0f95e347c3b9bc658c522da47f.png