设计模式--中介者模式

中介者模式（Mediator Pattern）

中介者模式是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

介绍

意图：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
角色划分：
1. 抽象中介者角色：抽象中介者角色定义了统一的接口与各个同事角色之间进行通信。
2. 具体中介者角色：具体中介者角色实现了抽象中介者接口，具体协调各个同事类之间的协作。
3. 抽象同事角色：定义与中介者之间沟通的接口。
4. 具体同事角色：实现抽象同事角色接口，具体处理与中介者的通信行为。
应用场景：
1. 一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。注意是多个对象之间相互依赖。
2. 想定制一个分布在多个类中的行为，而不想生成太多的子类的场合。
3. 产品架构的研发，更需要易于扩展的场合。
优点：
1. 降低了类的复杂度，将一对多转化成了一对一。
2. 各个类之间的解耦。
3. 符合迪米特原则。
缺点：中介者会庞大，变得复杂难以维护。
注意事项：不应当在职责混乱的时候使用。

实现

本例我们使用一个多人聊天室的模拟场景。有很多个User，每个User即可以发送消息，也可以收到其他User发送消息。

步骤 1

创建抽象对象接口，包括中介者接口和User接口。
中介者接口
IMediator.java

package com.mrcsj.test.study.mediator;


/**
 * 中介者接口
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:07
 */
public interface IMediator {

    /**
     * 
     * @param user
     */
    public void notifyAllMessage(IUser user);

    /**
     * 
     * @param user
     */
    public void register(IUser user);

}

User接口
IUser.java

package com.mrcsj.test.study.mediator;


/**
 * 用户接口
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:08
 */
public interface IUser {

    /**
     * 获取消息
     */
    public String getMessage();

    /**
     * 接收消息
     * 
     * @param message
     */
    public void receiveMessage(String message);

    /**
     * 
     * @param message
     */
    public void sendMessage(String message);

}

步骤 2

创建中介者实现类，抽象用户类以及IUser的实现类。
ConcreteMediator.java

package com.mrcsj.test.study.mediator;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:05
 */
public class ConcreteMediator implements IMediator {

    private final ArrayList<IUser> list = new ArrayList<IUser>();

    public ConcreteMediator(){
    }

    public void finalize() throws Throwable {

    }
    /**
     * 
     * @param user
     */
    public void notifyAllMessage(IUser user){
        Iterator<IUser> iterator = list.iterator();
        IUser tmp = null;
        while(iterator.hasNext()) {
            tmp = iterator.next();
            if(tmp != null && tmp!= user) {
                tmp.receiveMessage(user.getMessage());
            }
        }
    }

    /**
     * 
     * @param user
     */
    public void register(IUser user){
        if(user != null && !list.contains(user)) {
            list.add(user);
        }
    }
}//end ConcreteMediator

抽象用户类，AbstractUser.java

package com.mrcsj.test.study.mediator;


/**
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:01
 */
public abstract class AbstractUser implements IUser {

    private IMediator mediator;
    private String message;
    private String name;

    public AbstractUser(){

    }

    /**
     * 
     * @param mediator
     * @param name
     */
    public AbstractUser(IMediator mediator, String name){
        this.mediator = mediator;
        this.name = name;
    }

    public String getMessage(){
        return message;
    }

    /**
     * 
     * @param message
     */
    public void sendMessage(String message){
        this.message = message;
        System.out.println(this.name + " speak : " + message);
        mediator.notifyAllMessage(this);
    }

    /**
     * 接收消息
     * 
     * @param message
     */
    public void receiveMessage(String message){

    }
}//end AbstractUser

IUser接口的实现。
UserA.java

package com.mrcsj.test.study.mediator;


/**
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:09
 */
public class UserA extends AbstractUser {

    public UserA(){

    }

    public void finalize() throws Throwable {

    }
    /**
     * 
     * @param mediator
     * @param name
     */
    public UserA(IMediator mediator, String name){
        super(mediator, name);
        mediator.register(this);
    }

    /**
     * 
     * @param message
     */
    public void receiveMessage(String message){
        System.out.println("A received : " + message);
    }
}//end UserA

UserB.java

package com.mrcsj.test.study.mediator;


/**
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:10
 */
public class UserB extends AbstractUser {

    public UserB(){

    }

    public void finalize() throws Throwable {

    }
    /**
     * 
     * @param mediator
     * @param name
     */
    public UserB(IMediator mediator, String name){
        super(mediator, name);
        mediator.register(this);
    }

    /**
     * 
     * @param message
     */
    public void receiveMessage(String message){
        System.out.println("B received : " + message);
    }
}//end UserB

UserC.java

package com.mrcsj.test.study.mediator;


/**
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:12
 */
public class UserC extends AbstractUser {

    public UserC(){

    }

    public void finalize() throws Throwable {

    }
    /**
     * 
     * @param mediator
     * @param name
     */
    public UserC(IMediator mediator, String name){
        super(mediator, name);
        mediator.register(this);
    }

    /**
     * 
     * @param message
     */
    public void receiveMessage(String message){
        System.out.println("C received : " + message);
    }
}//end UserC

步骤 3

创建客户端，进行测试。
Client.java

package com.mrcsj.test.study.mediator;


/**
 * 客户端
 * @author admin
 * @version 1.0
 * @created 17-十一月-2016 10:53:04
 */
public class Client {

    public static void main(String[] args) {
        IMediator mediator = new ConcreteMediator();
        IUser a = new UserA(mediator, "A");
        IUser b = new UserB(mediator, "B");
        IUser c = new UserC(mediator, "C");
        a.sendMessage("hello friend");
        b.sendMessage("yeah");
        c.sendMessage("hh");
    }
}//end Client

步骤 4

验证输出。

A speak : hello friend
B received : hello friend
C received : hello friend
B speak : yeah
A received : yeah
C received : yeah
C speak : hh
A received : hh
B received : hh