设计模式之中介者模式

淩亂°似流年 2022-08-22 00:14 167阅读 0赞

**中介者模式**定义：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

优点：

中介者模式的优点就是减少类间的依赖，把原来的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。

缺点：

中介者模式的缺点就是中介者会膨胀的很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

**类图**如下：

![20160508155200367][]

**实现代码**如下：

抽象的中介者类：

package com.designpatterns.mediator;
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:33:09
     * 类说明：Alljava
     */
    public abstract class IMediator {
    protected ConcreteColleague1 C1;
    	protected ConcreteColleague2 C2;
    
    	public ConcreteColleague1 getC1() {
    		return C1;
    	}
    
    	public void setC1(ConcreteColleague1 c1) {
    		C1 = c1;
    	}
    
    	public ConcreteColleague2 getC2() {
    		return C2;
    	}
    
    	public void setC2(ConcreteColleague2 c2) {
    		C2 = c2;
    	}
    
    	public abstract void doSomething1();
    	public abstract void doSomething2();
    }

中介者的实现类：

package com.designpatterns.mediator;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:48:04 类说明：Alljava
     */
    public class ConcreteMediator extends IMediator {
    
    	public ConcreteMediator() {
    	}
    
    	@Override
    	public void doSomething1() {
    		super.C1.selfMethod1();
    		super.C2.selfMethod2();
    	}
    
    	@Override
    	public void doSomething2() {
    		super.C1.selfMethod1();
    		super.C2.selfMethod2();
    	}
    
    }

抽象的同事类：

package com.designpatterns.mediator;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:40:28 类说明：Alljava
     */
    public abstract class Colleague {
    	protected IMediator mediator;
    
    	public Colleague(IMediator mediator) {
    		this.mediator = mediator;
    	}
    }

实现的同事类1：

package com.designpatterns.mediator;
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:42:44
     * 类说明：Alljava
     */
    public class ConcreteColleague1 extends Colleague {
    
    	public ConcreteColleague1(IMediator mediator) {
    		super(mediator);
    	}
    	public void selfMethod1(){
    		System.out.println("this is selfMethod1!");
    	}
    
    	public void depMethod1(){
    		super.mediator.doSomething1();
    	}
    }

实现的同事类2：

package com.designpatterns.mediator;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:45:41 类说明：Alljava
     */
    public class ConcreteColleague2 extends Colleague {
    
    	public ConcreteColleague2(IMediator mediator) {
    		super(mediator);
    	}
    
    	public void selfMethod2() {
    		System.out.println("this is selfMethod2!");
    	}
    
    	public void depMethod2() {
    		super.mediator.doSomething2();
    	}
    }

测试类：

package com.designpatterns.mediator;
    
    /**
     * @author WSYW126
     * @version 创建时间：2016年5月8日 下午3:51:22 类说明：Alljava
     */
    public class Client {
    
    	public static void main(String[] args) {
    		ConcreteMediator cm = new ConcreteMediator();
    		ConcreteColleague1 c1 = new ConcreteColleague1(cm);
    		ConcreteColleague2 c2 = new ConcreteColleague2(cm);
    
    		cm.setC1(c1);
    		cm.setC2(c2);
    
    		c2.depMethod2();
    	}
    
    }

这就是中介者模式。

在这里解释一点：同事类使用构造器注入中介者，而中介者使用getter和setter方式注入同事类。因为同事类必须有中介者，而中介者却可以只有部分同事类。

**参考资料**：  
[设计模式之禅][Link 1]  
  
**备注**：  
转载请注明出处：http://blog.csdn.net/wsyw126/article/details/51345997  
作者：WSYW126

[20160508155200367]: /images/20220724/84c4ba8f1166495caf995b8541d4fcf8.png
[Link 1]: http://download.csdn.net/detail/wsyw126/9508137