漫说中介者模式--创业公司成长记

1. 中介者进化

一个公司，开始时大家都是平等关系的，例如ABC三人。

开始，公司很小，他们都是多面手，每个人既做生产，也做销售，也做运输。

如下图所示：

随着生意越来越好，公司规模变大，然后他们就发现这样工作的话，要么生产跟不上，要么销售跟不上，要么运输跟不上。

他们发现了问题，因此他们决定改变现状，每个人专攻一个，要么生成，要么销售，要么运输，那么他们就变成了如下图所示的状态：

市场越来越大，公司也越来越大，在公司要抢占尽可能多的市场份额时发现他们要频繁的相互协调沟通，这耗费了他们大量的时间和精力，于是他们引入了外援。

此时，他们可以放心的各司其职，剩下的工作就交给M来处理。M就是中介者模式的中介。

上面的例子也许我们觉得理清楚他们之间的关系是件很简单的事情，不需要请外援。那么如果人数不仅限于3个人的情况，又如何呢？

你是否还有足够的自信能理清楚各自的职责呢？如果还可以的话，超过个位数达到几十上百的时候又如何呢？

请看这样是否更简单呢？

当然，如果对象数量达到一定级别时，更适合层状树组织就不在我们的考虑内了。

2. 中介者模式结构图：

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

实例代码：

/**
*Mediator Interface
*/
package com.journaldev.design.mediator;
 
public interface ChatMediator {
 
    public void sendMessage(String msg, User user);
 
    void addUser(User user);
}

/**
*Colleague Interface
*/
package com.journaldev.design.mediator;
 
public abstract class User {
    protected ChatMediator mediator;
    protected String name;
     
    public User(ChatMediator med, String name){
        this.mediator=med;
        this.name=name;
    }
     
    public abstract void send(String msg);
     
    public abstract void receive(String msg);
}

/**
*Concrete Mediator
*/
package com.journaldev.design.mediator;
 
import java.util.ArrayList;
import java.util.List;
 
public class ChatMediatorImpl implements ChatMediator {
 
    private List<User> users;
     
    public ChatMediatorImpl(){
        this.users=new ArrayList<>();
    }
     
    @Override
    public void addUser(User user){
        this.users.add(user);
    }
     
    @Override
    public void sendMessage(String msg, User user) {
        for(User u : this.users){
            //message should not be received by the user sending it
            if(u != user){
                u.receive(msg);
            }
        }
    }
 
}

/**
*Concrete Colleague
*/
package com.journaldev.design.mediator;
 
public class UserImpl extends User {
 
    public UserImpl(ChatMediator med, String name) {
        super(med, name);
    }
 
    @Override
    public void send(String msg){
        System.out.println(this.name+": Sending Message="+msg);
        mediator.sendMessage(msg, this);
    }
    @Override
    public void receive(String msg) {
        System.out.println(this.name+": Received Message:"+msg);
    }
 
}

/**
*Mediator Pattern Client
*/
package com.journaldev.design.mediator;
 
public class ChatClient {
 
    public static void main(String[] args) {
        ChatMediator mediator = new ChatMediatorImpl();
        User user1 = new UserImpl(mediator, "Pankaj");
        User user2 = new UserImpl(mediator, "Lisa");
        User user3 = new UserImpl(mediator, "Saurabh");
        User user4 = new UserImpl(mediator, "David");
        mediator.addUser(user1);
        mediator.addUser(user2);
        mediator.addUser(user3);
        mediator.addUser(user4);
         
        user1.send("Hi All");
         
    }
 
}

3.优缺点和使用场景

中介者模式的优点

• 适当地使用中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。
• 使用中介者模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。
• 使用中介者模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。

适用场景

       在面向对象编程中，一个类必然会与其他的类发生依赖关系，完全独立的类是没有意义的。一个类同时依赖多个类的情况也相当普遍，既然存在这样的情况，说明，一对多的依赖关系有它的合理性，适当的使用中介者模式可以使原本凌乱的对象关系清晰，但是如果滥用，则可能会带来反的效果。一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用中介者模式。可以将网状结构变为星状结构，使同事类之间的关系变的清晰一些。

       中介者模式是一种比较常用的模式，也是一种比较容易被滥用的模式。对于大多数的情况，同事类之间的关系不会复杂到混乱不堪的网状结构，因此，大多数情况下，将对象间的依赖关系封装的同事类内部就可以的，没有必要非引入中介者模式。滥用中介者模式，只会让事情变的更复杂。

参考：1. http://www.cnblogs.com/hzcxy/archive/2013/03/08/2949533.html

        2.http://hi.baidu.com/quakeii/item/c8b6b2e9c7d6ca236dabb8c4

        3. http://www.journaldev.com/1730/mediator-design-pattern-in-java-example-tutorial