行为型模式之中介者模式

GitHub地址：https://github.com/zhangboqing/design-mode/tree/master/src/main/java/com/zbq

 

一.定义

　　中介者模式(Mediator Pattern)定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

二、模式结构成员构成

• Mediator: 抽象中介者

• ConcreteMediator: 具体中介者

• Colleague: 抽象同事类

• ConcreteColleague: 具体同事类

三.代码示例

/**
 * Colleague
 * 抽象同事类
 */
public abstract class AbstractColleague {
    protected int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    //注意这里的参数不再是同事类，而是一个中介者
    public abstract void setNumber(int number, AbstractMediator am);
}

/**
 * ConcreteColleague
 * 具体同事类
 */
public class ColleagueA extends AbstractColleague {

    @Override
    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.AaffectB();
    }

}

/**
 * ConcreteColleague
 * 具体同事类
 */
public class ColleagueB extends AbstractColleague{
 
    @Override
    public void setNumber(int number, AbstractMediator am) {
        this.number = number;
        am.BaffectA();
    }
}

/**
 * Mediator
 * 抽象中介者
 */
public abstract class AbstractMediator {
    protected AbstractColleague A;
    protected AbstractColleague B;
    
    public AbstractMediator(AbstractColleague a, AbstractColleague b) {
        A = a;
        B = b;
    }
 
    public abstract void AaffectB();
    
    public abstract void BaffectA();
 
}

/**
 * ConcreteMediator
 * 具体中介者
 */
class Mediator extends AbstractMediator {

    public Mediator(AbstractColleague a, AbstractColleague b) {
        super(a, b);
    }

    //处理A对B的影响
    @Override
    public void AaffectB() {
        int number = A.getNumber();
        B.setNumber(number * 100);
    }

    //处理B对A的影响
    @Override
    public void BaffectA() {
        int number = B.getNumber();
        A.setNumber(number / 100);
    }
}

/**
 * client
 */
public class Client {
    public static void main(String[] args){
        AbstractColleague collA = new ColleagueA();
        AbstractColleague collB = new ColleagueB();
        
        AbstractMediator am = new Mediator(collA, collB);
        
        System.out.println("==========通过设置A影响B==========");
        collA.setNumber(1000, am);
        System.out.println("collA的number值为："+collA.getNumber());
        System.out.println("collB的number值为A的10倍："+collB.getNumber());
 
        System.out.println("==========通过设置B影响A==========");
        collB.setNumber(1000, am);
        System.out.println("collB的number值为："+collB.getNumber());
        System.out.println("collA的number值为B的0.1倍："+collA.getNumber());
        
    }
}

四.优点和缺点分析

优点：

>简化了对象之间的交互

>将各同事解耦

缺点：

>可能会导致中介者对象非常复杂，使得系统难以维护。

 

五.应用场景

>想通过一个中间类来封装多个类中的行为

>系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。

>一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。