java设计模式-中介者模式

中介者模式：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。
世界上各个国家的关系错综复杂，国|家间的战|争也是不可避免的。没有永恒的敌人，只有永恒的利益。
这种情况下，每个国家都去应付其他所有国家的各种关系，很难兼顾和维系。所以冷|战时期出现的地方性的区域联|盟去保证自身的安全和地位，对应的关系以联|盟的身份去统一的维系。
因为尽管将一个系统（世界）分割成许多对象（各个国|家）可以增加复用性（国|家共同属性可以复用）。但是对象相互的连接的动作和方法（国与国之间的关系）使得一个对象（国|家）很难单独存在并正常工作，使得系统表现为一个不可分割的整体，降低了复用性，任何一个小的改动都变得十分困难，牵一发而动全身。
根据迪米特(最小知道)原则，如果两个对象批次不需要直接通信，那么这两个类就不应当发生直接的作用。如果这个对象需要调用另一个对象的方法，可以通过第三方转发这个调用。
通过第三方（联盟）的作用来进行彼此之间的联系与通信，即使一个对象发生改变或者引入一个新对象，也不会造成大量的修改工作。

Colleague叫做抽象同事类，而ConcreteColleague是具体的同事类，每个具体的同事只知道自己的行为，而不了解其他同事的情况，但他们都认识中介者对象。Mediator是抽象中介者，定义了同事对象到中介者对象的接口，ConcreteMediator是具体的中介者对象，实现抽象类的方法，他需要知道所有的具体同事类。并从具体同事类接收消息，向具体同事类发送消息。
以假象的世界格局为例：
首先是各个国家组成的联盟的抽象接口：

package com.hy.mediator;

public interface IAssociation {

    //加入联盟
    public abstract void add(Country country);

    //攻击
    public abstract void attack(Country attSide, Country defSide);

    //防御
    public abstract void defence(Country attSide,Country defSide);

}

具体的联盟类：

package com.hy.mediator;

import java.util.ArrayList;
import java.util.List;

public class Association implements IAssociation {

    private List<Country> countryList;

    public Association(){
        super();
        countryList = new ArrayList<Country>();
    }

    @Override
    public void add(Country country) {
        countryList.add(country);
    }

    @Override
    public void attack(Country attSide, Country defSide) {
        System.out.println(attSide.getName()+"准备攻击"+defSide.getName());
        if(countryList.contains(attSide)&&countryList.contains(defSide)){
            System.out.println("因为隶属同一联|盟，禁止互相攻击");
        }else if(countryList.contains(attSide)&&!countryList.contains(defSide)){
            System.out.println("因为隶属同一联|盟，盟|国协同攻击");
            for(Country coun:countryList){
                coun.attack(defSide);
            }
        }
    }

    @Override
    public void defence(Country defSide,Country attSide) {
        System.out.println(defSide.getName()+"准备防御"+attSide.getName()+"的攻击");
        if(countryList.size()>0){
            System.out.println("因为隶属同一联|盟，盟|国协同防御");
            for(Country coun:countryList){
                coun.defence(attSide);
            }
        }
    }

}

然后是各个国家的抽象类：

package com.hy.mediator;

public abstract class Country {

    protected IAssociation iAssociation;

    public Country(IAssociation iAssociation){
        this.iAssociation = iAssociation;
    }

    public abstract void attack(Country country);

    public abstract void defence(Country country);

    public abstract void attackByAssociation(IAssociation iAssociation,Country defSide);

    public abstract void defenceByAssociation(IAssociation iAssociation,Country country);

    public abstract String getName();
}

定义四个国家对象，一并给出：

package com.hy.mediator;

public class China extends Country {

    public China(IAssociation iAssociation) {
        super(iAssociation);
    }

    public String getName(){
        return "中|国";
    }

    @Override
    public void attack(Country country) {
        System.out.println(this.getName()+"攻击了"+country.getName());
    }

    @Override
    public void defence(Country country) {
        System.out.println(this.getName()+"抵御了"+country.getName()+"的攻击");
    }

    @Override
    public void attackByAssociation(IAssociation iAssociation, Country defSide) {
        iAssociation.attack(this, defSide);
    }

    @Override
    public void defenceByAssociation(IAssociation iAssociation, Country country) {
        iAssociation.defence(this, country);
    }

}

package com.hy.mediator;

public class Japan extends Country {

    public Japan(IAssociation iAssociation) {
        super(iAssociation);
    }

    public String getName(){
        return "日|本";
    }

    @Override
    public void attack(Country country) {
        System.out.println(this.getName()+"攻击了"+country.getName());
    }

    @Override
    public void defence(Country country) {
        System.out.println(this.getName()+"抵御了"+country.getName()+"的攻击");
    }

    @Override
    public void attackByAssociation(IAssociation iAssociation, Country defSide) {
        iAssociation.attack(this, defSide);
    }

    @Override
    public void defenceByAssociation(IAssociation iAssociation, Country country) {
        iAssociation.defence(this, country);
    }

}

package com.hy.mediator;

public class Russia extends Country {

    public Russia(IAssociation iAssociation) {
        super(iAssociation);
    }

    public String getName(){
        return "俄|罗斯";
    }

    @Override
    public void attack(Country country) {
        System.out.println(this.getName()+"攻击了"+country.getName());
    }

    @Override
    public void defence(Country country) {
        System.out.println(this.getName()+"抵御了"+country.getName()+"的攻击");
    }

    @Override
    public void attackByAssociation(IAssociation iAssociation , Country defSide) {
        iAssociation.attack(this, defSide);
    }

    @Override
    public void defenceByAssociation(IAssociation iAssociation, Country country) {
        iAssociation.defence(this, country);
    }

}

package com.hy.mediator;

public class America extends Country {

    public America(IAssociation iAssociation) {
        super(iAssociation);
    }

    public String getName(){
        return "美|国";
    }

    @Override
    public void attack(Country country) {
        System.out.println(this.getName()+"攻击了"+country.getName());
    }

    @Override
    public void defence(Country country) {
        System.out.println(this.getName()+"抵御了"+country.getName()+"的攻击");
    }

    @Override
    public void attackByAssociation(IAssociation iAssociation, Country defSide) {
        iAssociation.attack(this, defSide);
    }

    @Override
    public void defenceByAssociation(IAssociation iAssociation, Country country) {
        iAssociation.defence(this, country);
    }
}

最后给出测试类：

package com.hy.mediator;

public class WorldThree {
    public static void main(String[] args) {
        Association ameriAndJapan = new  Association();
        Association russiAndChina = new  Association();
        Country america = new America(ameriAndJapan);
        Country japan = new Japan(ameriAndJapan);
        Country china = new China(russiAndChina);
        Country russia = new Russia(russiAndChina);
        ameriAndJapan.add(america);
        ameriAndJapan.add(japan);
        russiAndChina.add(china);
        russiAndChina.add(russia);

        america.attackByAssociation(ameriAndJapan, japan);
        System.out.println("-------------------------");
        america.attackByAssociation(ameriAndJapan, russia);
        System.out.println("-------------------------");
        russia.defenceByAssociation(russiAndChina, america);
    }
}

最后结果显示如下：

中介模式针对的问题是，解决一系列对象之间复杂的耦合关系，这一系列对象往往是“多对多”的耦合关系，中介者模式采用一个中介者对象将这一系列对象集中管理，而各个对象也将自己与其它对象的交互行为委托给中介者处理，从而减少这一系列对象之间的耦合。
一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，或者想要定义一个分布在多个类中的行为但是又不想增加太多子类的场合。
中介模式的优缺点----
优点：
Mediator类的出现减少了各个Colleague的之间的耦合，使得可以单独的修改和复用。并且中介者可以控制这一系列对象的行为，统一管理。
由于把对象的协作进行了抽象，中介作为独立的概念并封装在一个对象中，这样关注的对象从对象各自本身的行为转移到他们之间的交互上，站在一个更高的层面上去看待系统。
缺点是：由于ConcreteMediator控制集中化，于是把交互的复杂性变成了终结者的复杂性，使得一个中介者比任何一个ConcreteColleague都要复杂。就像一个皇帝，事无巨细都要亲自过问无疑是最头疼的。一旦中介者类无法正常工作，那么所有将行为委托给中介者的类都将会出现问题，所以在使用的时候还是要特别小心。
PS：慕课审核敏感字，所以加了一些分隔符，下次做一些别的方面的例子...