(十九)中介者模式-代码实现

介绍

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

应用场景：不同功能的模块之间调用关系复杂，耦合度高，不利于修改时使用。

好处：降低耦合，模块独立。

坏处：中介者业务复杂，不易维护。

代码：

//定义模块抽象类

package note.com.mediator;

public abstract class Element {
    public Mediator mediator = null;

    public abstract void good();

    public abstract void bad();

    public Mediator getMediator() {
        return mediator;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void changeGood();

    public abstract void changeBad();

}

//模块具体实现

package note.com.mediator;

/**
 * 元素-部队
 * @author lxz
 *
 */
public class Army extends Element{

    @Override
    public void good() {
        System.out.println("部队强大");

    }

    @Override
    public void bad() {
        System.out.println("部队弱小");
    }

    @Override
    public void changeGood() {
        getMediator().change(Mediator.ARMY, Mediator.GOOD);
    }

    @Override
    public void changeBad() {
        getMediator().change(Mediator.ARMY, Mediator.BAD);
    }

}

package note.com.mediator;

/**
 * 元素-政府
 * @author lxz
 *
 */

public class Goverment extends Element{

    @Override
    public void good() {
        System.out.println("政府有钱");
    }

    @Override
    public void bad() {
        System.out.println("政府没钱");
    }

    @Override
    public void changeGood() {
        good();
        getMediator().change(Mediator.GOVERMENT, Mediator.GOOD);
    }

    @Override
    public void changeBad() {
        bad();
        getMediator().change(Mediator.GOVERMENT, Mediator.BAD);
    }

}

package note.com.mediator;

/**
 * 元素-人民
 * @author lxz
 *
 */
public class People  extends Element{

    @Override
    public void good() {
        System.out.println("人民幸福");
    }

    @Override
    public void bad() {
        System.out.println("人民不幸福");
    }

    @Override
    public void changeGood() {
        good();
        getMediator().change(Mediator.PEOPLE, Mediator.GOOD);
    }

    @Override
    public void changeBad() {
        bad();
        getMediator().change(Mediator.PEOPLE, Mediator.BAD);
    }

}

//中介者，定义模块之间的调用

package note.com.mediator;

/**
 * 协调者
 * @author lxz
 *
 */
public class Mediator{
    public static final String ARMY = "Army";
    public static final String GOVERMENT = "Goverment";
    public static final String PEOPLE = "People";
    public static final String GOOD = "good";
    public static final String BAD = "bad";

    public Element a = null;
    public Element g = null;
    public Element p = null;

    public Mediator(Army a,Goverment g,People p){
        this.a = a;
        this.g = g;
        this.p = p;
    }

    public void change(String label,String state){

        if(ARMY.equals(label)){
            if(GOOD.equals(state)){
                g.good();
                p.good();
            }else if(BAD.equals(state)){
                g.bad();
                p.bad();
            }
        }else if(GOVERMENT.equals(label)){
            if(GOOD.equals(state)){
                a.good();
                p.good();
            }else if(BAD.equals(state)){
                a.bad();
                p.bad();
            }

        }else if(PEOPLE.equals(label)){
            if(GOOD.equals(state)){
                a.good();
                g.good();
            }else if(BAD.equals(state)){
                a.bad();
                g.bad();
            }
        }
    }

    public Element getA() {
        return a;
    }

    public void setA(Element a) {
        this.a = a;
    }

    public Element getG() {
        return g;
    }

    public void setG(Element g) {
        this.g = g;
    }

    public Element getP() {
        return p;
    }

    public void setP(Element p) {
        this.p = p;
    }

}

//测试类

package note.com.mediator;

public class MediatorTest {
    public static void main(String[] args) {
        //三个元素，分别有不同的功能，但又相互有影响
        Army a = new Army();
        Goverment g = new Goverment();
        People p = new People();
        //中间调解者
        Mediator mediator = new Mediator(a,g,p);
        a.setMediator(mediator);
        g.setMediator(mediator);
        p.setMediator(mediator);
        a.changeBad();//军队变化
        System.out.println("====");
        g.changeBad();//政府变化
        System.out.println("====");
        p.changeGood();//人民变化
    }
}

//结果

政府没钱
人民不幸福
====
政府没钱
部队弱小
人民不幸福
====
人民幸福
部队强大
政府有钱

由此可以看出例子中的三个模块之间的调用关系由Mediator来控制，使三个模块更专心于自己的功能。

注意：小心设计成死循环。