十三：中介者模式（联盟与派系）

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

               “按照当年六道天人所说，这秘籍当中所说的一系列的对象，应该就是指的各个门派了吧。现在各个门派之间相互单独交往，关系复杂，很难让大陆安静。”左阁主说着说着，虚空之中便出现一幅当前大陆格局的地图。

                “虽然有了抽象的父类门派，但是各个具体门派之间的关系，看起来实在是有点混乱，如果要用秘籍暗语来诠释的话，我神阁和命令门以及单例宗的关系应该是这样的。”左阁主说着，双手则开始在虚空之中画出了一个个奇异的符号。

                “首先是一个抽象的门派父类，它代表了我们各个门派的共性。这个好像有点模板宗秘籍《模板方法模式》的味道，像是一个模板类。”

package com.mediator;
//门派抽象类
public abstract class School {

    public void defense() {
        System.out.println(getName() + "防御");
    }

    public void attack(School school) {
        System.out.println(getName() + "攻击" + school.getName());
    }
    
    public abstract String getName();
    
}

               “下面就是我神阁以及命令门还有单例宗具体的门派了。”左阁主说着，一个个奇异的符号不断的从其手中涌出，飘散在前方的虚空之中。

package com.mediator;

public class MediatorSchool extends School{

    public String getName() {
        return "中介者神阁";
    }

}

package com.mediator;

public class CommandSchool extends School{

    public String getName() {
        return "命令门";
    }

}

package com.mediator;

public class SingletonSchool extends School{

    public String getName() {
        return "单例宗";
    }

}

                “有了这些的话，现在大陆的格局就好描述了，应该就是现在这样了。”

package com.mediator;
//大陆格局
public class ContinentalPattern {

    public static void main(String[] args) {
        School singletonSchool = new SingletonSchool();
        School commandSchool = new CommandSchool();
        School mediatorSchool = new MediatorSchool();
        
        singletonSchool.attack(mediatorSchool);
        commandSchool.attack(mediatorSchool);
        
        mediatorSchool.defense();
    }
    
}

              “这样果然是不行啊，各个门派可以随意进攻，混乱不堪，没有任何节制力量，而且各个门派交往起来非常繁琐，每一个门派都要应付与其余二十二个门派的关系，怪不得现在模式大陆逐渐开始混乱呢。况且我神阁都已经被单例宗和命令门攻击一段时间了，最后才迟迟反应过来，慌忙的采取防御策略，难免损失惨重。”看着虚空之中漂浮的文字结果，左阁主暗暗的摇头道。
               顿了一下，左阁主继续自言自语道：“按照我神阁秘籍所述，大陆之中应该出现一个中介者对象，它可以负责各个门派之间的交往以及控制各个门派的动作。这样的话，确实可以解决大陆的动荡，去除掉各个门派之间复杂的关系，让所有的门派都听命于这个中介者。看来六道天人果然料事如神啊。”

               双眼紧闭思考片刻之后，左阁主便猛地睁开双眼，随即一字一顿的说出了中介者的名称，“模式联盟”。

               随后，左阁主的双手在虚空中一阵虚画，一个个秘籍暗语在虚空之中散发着夺目的光芒，这些光芒赫然组成了模式联盟接口。

package com.mediator;
//模式联盟，中介者接口
public interface IPatternAlliance {

    //加入联盟
    public abstract void add(School school);

    //联盟攻击
    public abstract void resolveAttack(School activeSide, School passiveSide);

    //联盟防御
    public abstract void resolveDefense(School passiveSide);

}

                “这便是模式联盟接口了，它算是模式联盟的联盟宗旨，指导着联盟所要做的事情。”左阁主点头道。

                “下面便是模式联盟的真正面目了。”

package com.mediator;

import java.util.ArrayList;
import java.util.List;
//模式联盟，中介者
public class PatternAlliance implements IPatternAlliance {

    private List<School> schoolList;

    public PatternAlliance() {
        super();
        schoolList = new ArrayList<School>();
    }
    
    public void add(School school){
        schoolList.add(school);
    }
    
    public void resolveAttack(School activeSide,School passiveSide){
        if (schoolList.contains(activeSide) && schoolList.contains(passiveSide)) {
            System.out.println("主攻方" + activeSide.getName() + "以及被攻方" + passiveSide.getName() + "都已加入联盟，不允许内讧！");
        }else if (schoolList.contains(activeSide) && !schoolList.contains(passiveSide)) {
            System.out.println("主攻方" + activeSide.getName() + "已加入联盟，被攻方" + passiveSide.getName() + "不在联盟之中，将集体攻打该门派！");
            for (School school : schoolList) {
                school.attack(passiveSide);
            }
        }else {
            System.out.println("主攻方" + activeSide.getName() + "未加入联盟，联盟无权干预此事！");
            activeSide.attack(passiveSide);
        }
    }

    public void resolveDefense(School passiveSide){
        if (schoolList.contains(passiveSide)) {
            System.out.println("被攻方" + passiveSide.getName() + "已加入联盟，联盟将齐力防御！");
            for (School school : schoolList) {
                school.defense();
            }
        }else {
            System.out.println("被攻方" + passiveSide.getName() + "未加入联盟，联盟不给予防御帮助！");
            passiveSide.defense();
        }
    }
    
}

               “这应该便是联盟的大致蓝图了，它可以负责各个门派之间的交往，去除掉门派之间直接的关联，并且这样做的话，还可以控制联盟中的门派。剩下的就是各个门派的布局需要稍微改变一下。”左阁主看着自己一手策划的联盟，轻声说道。

                “首先应该就是抽象父类需要变化一下了，因为现在每一个门派的动作都需要委托给联盟去做。”

package com.mediator;
//门派抽象类
public abstract class School {

    protected IPatternAlliance patternAlliance;

    public School(IPatternAlliance patternAlliance) {
        super();
        this.patternAlliance = patternAlliance;
    }
    
    public void defense() {
        System.out.println(getName() + "防御");
    }

    public void attack(School school) {
        System.out.println(getName() + "攻击" + school.getName());
    }
    
    //有了中介者，将由中介者处理
    public void attackByPatternAlliance(School school){
        patternAlliance.resolveAttack(this, school);
    }
    
    public void defenseByPatternAlliance(){
        patternAlliance.resolveDefense(this);
    }
    
    public abstract String getName();
    
}

                “这一下各个门派的布局只需要稍微变化一下就好，因为每一个门派都要认识这个中介者，也就是模式联盟。那么策略宫，这个众矢之的，也是要认识的了，只是联盟要不要收留这个家伙，那就另说了，嘿嘿！”左阁主阴笑着说道。

package com.mediator;

public class CommandSchool extends School{

    public CommandSchool(IPatternAlliance patternAlliance) {
        super(patternAlliance);
    }

    public String getName() {
        return "命令门";
    }

}

package com.mediator;

public class MediatorSchool extends School{

    public MediatorSchool(IPatternAlliance patternAlliance) {
        super(patternAlliance);
    }

    public String getName() {
        return "中介者神阁";
    }

}

package com.mediator;

public class SingletonSchool extends School{

    public SingletonSchool(IPatternAlliance patternAlliance) {
        super(patternAlliance);
    }

    public String getName() {
        return "单例宗";
    }

}

package com.mediator;

public class StrategySchool extends School{

    public StrategySchool(IPatternAlliance patternAlliance) {
        super(patternAlliance);
    }

    public String getName() {
        return "策略宫";
    }
    
}

                “这下大陆的格局就要变化一下了，本阁主就先来模拟一个吧。不过策略宫的下场好像不怎么好啊。嘿嘿。”阴笑一声，左阁主便开始在虚空中画起秘籍暗语。

package com.mediator;
//大陆格局
public class ContinentalPattern {

    public static void main(String[] args) {
        IPatternAlliance patternAlliance = new PatternAlliance();
        
        School singletonSchool = new SingletonSchool(patternAlliance);
        School commandSchool = new CommandSchool(patternAlliance);
        School mediatorSchool = new MediatorSchool(patternAlliance);
        
        School strategySchool = new StrategySchool(patternAlliance);
        
        //策略宫没有被联盟收留
        patternAlliance.add(mediatorSchool);
        patternAlliance.add(commandSchool);
        patternAlliance.add(singletonSchool);
        
        singletonSchool.attackByPatternAlliance(mediatorSchool);
        commandSchool.attackByPatternAlliance(mediatorSchool);
        System.out.println("------------------------------------------------------");
        mediatorSchool.attackByPatternAlliance(strategySchool);
        System.out.println("------------------------------------------------------");
        strategySchool.attackByPatternAlliance(mediatorSchool);
        mediatorSchool.defenseByPatternAlliance();
        System.out.println("------------------------------------------------------");
    }
    
}

《中介者模式》针对的问题是，解决一系列对象之间复杂的耦合关系，这一系列对象往往是“多对多”的耦合关系，《中介者模式》采用一个中介者对象将这一系列对象集中管理，而各个对象也将自己与其它对象的交互行为委托给中介者处理，从而减少这一系列对象之间的耦合。

它的优点倒是非常明显，清除了一系列对象之间复杂的耦合关系，并且中介者可以控制这一系列对象的行为，统一管理。

《中介者模式》的缺点是，由于中介者负责着一系列对象的交互与控制，所以中介者的类会非常复杂，而且一旦中介者类无法正常工作，那么所有将行为委托给中介者的类都将会出现问题，所以在使用的时候还是要特别小心。

“下面，本阁主就要看下现在大陆的格局地图了。”说完，左阁主便开始在虚空中勾画格局地图。