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

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