总则

• 设计原则：遵循迪米特，破坏单一职责
• 常用场景：一个系列的对象交互关系十分复杂
• 使用概率：10%
• 复杂度：中
• 变化点：对象之间的交互
• 选择关键点：复杂的交互关系是否有共性可被中介者承担
• 逆鳞：中介者无法工作
• 中介者模式针对的问题是，解决一系列对象之间复杂的耦合关系，这一系列对象往往是“多对多”的耦合关系，《中介者模式》采用一个中介者对象将这一系列对象集中管理，而各个对象也将自己与其它对象的交互行为委托给中介者处理，从而减少这一系列对象之间的耦合。 它的优点倒是非常明显，清除了一系列对象之间复杂的耦合关系，并且中介者可以控制这一系列对象的行为，统一管理。

中介者模式

uml类图

中介者模式

//模式联盟，中介者接口
    public interface IPatternAlliance {

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

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

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

    }

    //模式联盟，中介者
    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();
            }
        }

    }

    //门派抽象类
    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();

    }

    public class CommandSchool extends School{

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

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

    }

    public class MediatorSchool extends School{

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

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

    }

    public class SingletonSchool extends School{

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

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

    }

    public class StrategySchool extends School{

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

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

    }

    //大陆格局
    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("------------------------------------------------------");
        }

    }