java设计模式（行为型）之中介者模式

第0章：简介

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

中介者模式本质：封装交互

参考：http://chjavach.iteye.com/blog/1626265，研磨设计模式（书籍），大话设计模式（书籍）

模式图：

待补充

第1章：实践

第0节：中介者模式

（1）交互对象的父类（Abstractor.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 交互对象的父类
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:38
 */
public abstract class Abstractor {

    //持有中介者对象
    private Mediator mediator;

    /**
     * 构造器，传入中介者对象
     * @param mediator
     */
    public Abstractor(Mediator mediator){
        this.mediator = mediator;
    }

    /**
     * 获取中介者对象
     * @return
     */
    public Mediator getMediator(){
        return mediator;
    }
}

（2）交互类实现A（AbstractorExtendsA.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 交互类实现A
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:43
 */
public class AbstractorExtendsA extends Abstractor {
    /**
     * 构造器，传入中介者对象
     *
     * @param mediator
     */
    public AbstractorExtendsA(Mediator mediator) {
        super(mediator);
    }

    public void someMethodA(){
        System.out.println("实现类A的方法操作");
        //交给中介者处理接下来的工作,打算交给B处理
        this.getMediator().handle(this);
    }
}

（3）交互类实现B（AbstractorExtendsB.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 交互类实现B
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:49
 */
public class AbstractorExtendsB extends Abstractor {
    /**
     * 构造器，传入中介者对象
     *
     * @param mediator
     */
    public AbstractorExtendsB(Mediator mediator) {
        super(mediator);
    }

    public void someMethodB(){
        System.out.println("实现类B的方法操作");
        //交给中介者处理接下来的工作，打算交给C工作
        this.getMediator().handle(this);
    }
}

（4）交互类实现C（AbstractorExtendsC.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 交互类实现C
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:51
 */
public class AbstractorExtendsC extends Abstractor {
    /**
     * 构造器，传入中介者对象
     *
     * @param mediator
     */
    public AbstractorExtendsC(Mediator mediator) {
        super(mediator);
    }

    public void someMethodC(){
        System.out.println("实现类C的方法操作");
        //交给中介者处理接下来的工作，打算交给C工作
        System.out.println("交互工作完成，移交处理");
    }
}

（5）中介者接口（Mediator.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 中介者接口
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:34
 */
public interface Mediator {

    /**
     * 处理交互的方法
     * @param abstractor 交互类父类
     */
    public void handle(Abstractor abstractor);
}

（6）中介者（MediatorImpl.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 中介者，主要实现交互类间的交互工作
 *
 * 中介者模式的定义：用一个中介对象来封装一系列的对象交互。中介者使得各对象不需要显式地相互引用，
 *                   从而使其耦合松散，而且可以独立地改变它们之间的交互。
 * 中介者模式的本质：封装交互
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:55
 */
public class MediatorImpl implements Mediator {

    //中介者知道交互类
    private AbstractorExtendsA abstractorExtendsA;

    private AbstractorExtendsB abstractorExtendsB;

    private AbstractorExtendsC abstractorExtendsC;

    public void setAbstractorExtendsA(AbstractorExtendsA abstractorExtendsA) {
        this.abstractorExtendsA = abstractorExtendsA;
    }

    public void setAbstractorExtendsB(AbstractorExtendsB abstractorExtendsB) {
        this.abstractorExtendsB = abstractorExtendsB;
    }

    public void setAbstractorExtendsC(AbstractorExtendsC abstractorExtendsC) {
        this.abstractorExtendsC = abstractorExtendsC;
    }

    /**
     * 处理交互工作
     * @param abstractor 交互类父类
     */
    @Override
    public void handle(Abstractor abstractor) {
        //处理交互，这里可以任意组合交互，可结合其它设计模式，可加入其它操作
        if(abstractor == abstractorExtendsA){
            abstractorExtendsB.someMethodB();
        }else if(abstractor == abstractorExtendsB){
            abstractorExtendsC.someMethodC();
        }
    }
}

（7）客户端测试（Client.java）

package com.mcc.core.designPattern.behavior.mediator.simpleMediator;

/**
 * 客户端测试
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午2:09
 */
public class Client {

    public static void main(String args[]){

        //创建中介者
        MediatorImpl mediatorImpl = new MediatorImpl();

        //创建交互类
        AbstractorExtendsA abstractorA = new AbstractorExtendsA(mediatorImpl);
        AbstractorExtendsB abstractorB = new AbstractorExtendsB(mediatorImpl);
        AbstractorExtendsC abstractorC = new AbstractorExtendsC(mediatorImpl);

        //让中介者知道交互类
        mediatorImpl.setAbstractorExtendsA(abstractorA);
        mediatorImpl.setAbstractorExtendsB(abstractorB);
        mediatorImpl.setAbstractorExtendsC(abstractorC);

        //测试交互
        System.out.println("\n开始处理，从交互类A发起：\n");
        abstractorA.someMethodA();

        //测试交互
        System.out.println("\n开始处理，从交互类B发起：\n");
        abstractorB.someMethodB();

        //测试交互
        System.out.println("\n开始处理，从交互类C发起：\n");
        abstractorC.someMethodC();
    }
}

第1节：广义中介者模式

（1）交互类实现A（AbstractorExtendsA.java）

package com.mcc.core.designPattern.behavior.mediator.extendMediator;


/**
 * 交互类实现A
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:43
 */
public class AbstractorExtendsA{


    public void handle(){
        someMethodA();
        //获取单一实例
        MediatorImpl mediatorImpl = MediatorImpl.getMediator();
        //交给中介者处理接下来的工作,打算交给B处理
        mediatorImpl.handleAtoB();
    }

    public void someMethodA(){
        System.out.println("实现类A的方法操作");
    }
}

（2）交互类实现B（AbstractorExtendsB.java）

package com.mcc.core.designPattern.behavior.mediator.extendMediator;


/**
 * 交互类实现B
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午1:49
 */
public class AbstractorExtendsB {

    public void handle(){
        someMethodB();
        //获取单一实例
        MediatorImpl mediatorImpl = MediatorImpl.getMediator();
        //交给中介者处理接下来的工作，打算交给A工作
        mediatorImpl.handleBtoA();
    }

    public void someMethodB(){
        System.out.println("实现类B的方法操作");

    }
}

（3）中介者类（MediatorImpl.java）

package com.mcc.core.designPattern.behavior.mediator.extendMediator;


/**
 * 中介者类，广义中介者模式，主要实现交互类间的交互工作
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午2:27
 */
public class MediatorImpl{
    ////单例模式

    private static MediatorImpl mediator = new MediatorImpl();
    //私有构造器
    private MediatorImpl(){

    }
    //获得唯一实例
    public static MediatorImpl getMediator(){
        return mediator;
    }


    //中介者知道交互类
    private AbstractorExtendsA abstractorExtendsA;

    private AbstractorExtendsB abstractorExtendsB;

    public void setAbstractorExtendsA(AbstractorExtendsA abstractorExtendsA) {
        this.abstractorExtendsA = abstractorExtendsA;
    }

    public void setAbstractorExtendsB(AbstractorExtendsB abstractorExtendsB) {
        this.abstractorExtendsB = abstractorExtendsB;
    }

    /**
     * 处理A到B交互
     */
    public void handleAtoB() {
        abstractorExtendsB.someMethodB();
    }

    /**
     * 处理B到A交互
     */
    public void handleBtoA() {
        abstractorExtendsA.someMethodA();
    }
}

（4）客户端测试（Client.java）

package com.mcc.core.designPattern.behavior.mediator.extendMediator;

/**
 * 客户端测试
 *
 * @author <a href="mailto:[e-mail]">menergy</a>
 *         DateTime: 14-3-15  下午2:41
 */
public class Client {

    public static void main(String args[]){
        //创建中介者
        MediatorImpl mediatorImpl = MediatorImpl.getMediator();

        //创建交互类
        AbstractorExtendsA abstractorA = new AbstractorExtendsA();
        AbstractorExtendsB abstractorB = new AbstractorExtendsB();

        //让中介者知道交互类
        mediatorImpl.setAbstractorExtendsA(abstractorA);
        mediatorImpl.setAbstractorExtendsB(abstractorB);

        //测试交互
        System.out.println("\n开始处理，从交互类A发起,交给B：\n");
        abstractorA.handle();

        //测试交互
        System.out.println("\n开始处理，从交互类B发起,交给A：\n");
        abstractorB.handle();
    }
}