设计模式之中介者模式(Mediator Pattern)

灰太狼 2022-04-12 13:00 183阅读 0赞

*  中介者模式定义  
    Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. 用一个中介对象封装一系列的对象交互，中介者使各个对象不需要显示地相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。
 *  中介者模式通用类图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]  
    从以上类图可以看到，中介者模式主要有三个角色：
    
     *  抽象中介者：抽象中介者角色定义统一的接口，用于各个同事之间的通信。
     *  中介者实现类：从抽象中介者继承而来，实现抽象中介者中定义的事件方法。从一个同事类接收消息，然后通过消息影响其他同时类。
     *  同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有一个，这其实是现实的省略，在实际应用中，同事类一般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同一个抽象类的一组实现组成。在中介者模式中，同事类之间必须通过中介者才能进行消息传递。
 *  中介者模式通用代码  
    抽象中介者Mediator

public abstract class Mediator {
    
    	protected ConcreteColleague1 c1;
    	protected ConcreteColleague2 c2;
    	
    	public ConcreteColleague1 getC1() {
    		return c1;
    	}
    	public void setC1(ConcreteColleague1 c1) {
    		this.c1 = c1;
    	}
    	public ConcreteColleague2 getC2() {
    		return c2;
    	}
    	public void setC2(ConcreteColleague2 c2) {
    		this.c2 = c2;
    	}
    	
    	public abstract void doSth1();
    	public abstract void doSth2();
    }

抽象同事类Colleague

public abstract class Colleague {
    
    	protected Mediator mediator;
    
    	public Colleague(Mediator _mediator) {
    		this.mediator = _mediator;
    	}
    }

具体中介者

public class ConcreteMediator extends Mediator{
    
    	@Override
    	public void doSth1() {
    		super.c1.selfMethod1();
    		super.c2.selfMethod2();
    	}
    
    	@Override
    	public void doSth2() {
    		super.c1.selfMethod1();
    		super.c2.selfMethod2();
    	}
    }

具体同事类

public class ConcreteColleague1 extends Colleague {
    
    	public ConcreteColleague1(Mediator _mediator) {
    		super(_mediator);
    	}
    
    	public void selfMethod1() {
    		//TODO
    	}
    
    	public void depMethod1() {
    		super.mediator.doSth1();
    	}
    }

public class ConcreteColleague2 extends Colleague {
    
    	public ConcreteColleague2(Mediator _mediator) {
    		super(_mediator);
    	}
    
    	public void selfMethod2() {
    		// TODO
    	}
    
    	public void depMethod2() {
    		super.mediator.doSth2();
    	}
    }

*  中介者模式实例类图  
    相比有很多男生都喜欢金庸的武侠小说吧，笔者也不例外。江湖中门派众多，总会有一些小喽啰偷学少林绝学去做一些见不得人的勾当。前段时间武当派和峨眉派的的弟子被大力金刚指所杀，大力金刚指是少林派的绝学，自古有天下武功出少林的没说，大家自然也不敢轻举妄动。这个时候大家推举出了德高望重的武林盟主，作为江湖的中间人，一旦有什么不和谐的地方，由武林盟主出面进行沟通，其实这个例子就符合中介者模式。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 1]

*  中介者模式实例代码  
    抽象中介者类

public abstract class WulinAlliance {
    
    	abstract void notice(String message, United united);
    }

抽象同事类

public abstract class United {
    
    	protected WulinAlliance wulinAlliance;
    
    	public United(WulinAlliance wulinAlliance) {
    		this.wulinAlliance = wulinAlliance;
    	}
    }

具体同事类

public class Wudang extends United {
    	public Wudang(WulinAlliance wulinAlliance) {
    		super(wulinAlliance);
    	}
    
    	public void sendAlliance(String message) {
    		wulinAlliance.notice(message, this);
    	}
    
    	public void getNotice(String message) {
    		System.out.println("武当收到消息：" + message);
    	}
    }

public class Shaolin extends United {
    	public Shaolin(WulinAlliance wulinAlliance) {
    		super(wulinAlliance);
    	}
    
    	public void sendAlliance(String message) {
    		wulinAlliance.notice(message, Shaolin.this);
    	}
    
    	public void getNotice(String message) {
    		System.out.println("少林收到消息：" + message);
    	}
    }

public class Emei extends United {
        public Emei(WulinAlliance wulinAlliance) {
            super(wulinAlliance);
        }
        public void sendAlliance(String message) {
            wulinAlliance.notice(message, Emei.this);
        }
        public void getNotice(String message) {
            System.out.println("峨眉收到消息：" + message);
        }
    }

具体中介者类

public class Champions extends WulinAlliance {
    	private Wudang wudang;
    	private Shaolin shaolin;
    	private Emei emei;
    
    	public void setWudang(Wudang wudang) {
    		this.wudang = wudang;
    	}
    
    	public void setEmei(Emei emei) {
    		this.emei = emei;
    	}
    
    	public void setShaolin(Shaolin shaolin) {
    		this.shaolin = shaolin;
    	}
    
    	@Override
    	public void notice(String message, United united) {
    		if (united == wudang) {
    			shaolin.getNotice(message);
    		} else if (united == emei) {
    			shaolin.getNotice(message);
    		} else if (united == shaolin) {
    			wudang.getNotice(message);
    			emei.getNotice(message);
    		}
    	}
    }

客户端调用

public class Client {
    	public static void main(String[] args) {
    		Champions champions = new Champions();
    		Wudang wudang = new Wudang(champions);
    		Shaolin shaolin = new Shaolin(champions);
    		Emei emei = new Emei(champions);
    		champions.setWudang(wudang);
    		champions.setShaolin(shaolin);
    		champions.setEmei(emei);
    		wudang.sendAlliance("武当弟子被少林大力金刚指所杀");
    		emei.sendAlliance("峨眉弟子被少林大力金刚指所杀");
    		shaolin.sendAlliance("少林弟子绝不会做出这种事情");
    	}
    }

输出结果：

少林收到消息：武当弟子被少林大力金刚指所杀
    少林收到消息：峨眉弟子被少林大力金刚指所杀
    武当收到消息：少林弟子绝不会做出这种事情
    峨眉收到消息：少林弟子绝不会做出这种事情

*  中介者模式的优点
    
     *  符合迪米特原则，将原有的一对多的依赖变成了一对一的依赖，降低类间的耦合。
     *  使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。
 *  中介者模式的适用场景
    
     *  系统中对象之间存在比较复杂的引用关系，导致他们之间的依赖关系结构混乱而且难以复用该对象。
     *  想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

参考书籍：`设计模式之禅`  
实例代码放在[这里][Link 1]。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70]: /images/20220412/43c731650d024dc4855057adb28021fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdjaGVuZ21pbmcx_size_16_color_FFFFFF_t_70 1]: /images/20220412/a8e66c1e40e842dbb7888ab31175001f.png
[Link 1]: https://github.com/BazookaW/DesignPattern