18、中介者模式

1、简介

中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。

定义其实也好理解。这里拿一个例子做比较，我们现在使用的QQ、微信等平台，就是中介者，用户可以登录这些平台同其他用户进行交流，平台来维持不同用户之间的关系，而不是每一个用户主动去维持同其他用户的关系，这差不多就是中介者模式的意思。

• Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。
• ConcreteMediator：具体的中介者角色，继承自抽象中介者，实现了抽象中介者中定义的方法，从具体同事对象中接收消息，向具体的同事对象发出命令。
• Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。
• ConcreteColleagueA/B：具体同事类角色，继承自抽象同事类。

2、具体实现

这里我们使用一个邮箱的例子，邮箱服务器就是一个具体的中介者角色，而使用邮箱的那些用户就是具体同事类角色，用户先是发送消息到邮箱服务器，通过邮箱服务器来转发给使用这个邮箱的所有用户，这里只是一个简单的例子，代码如下：

//中介者模式

//邮箱抽象类（中介者抽象类）
abstract class   MailboxServer{
    //维护对具体用户的引用
    List<MailUser> list = new ArrayList<MailUser>();


    public void regirstUser(MailUser mailUser){
        list.add(mailUser);
    }

    public abstract void resiveMessage(String message) throws InterruptedException;

    public abstract void sendMessage();

}


//具体邮箱(具体中介者)  负责发送消息到每一个用户
class  WYMail extends  MailboxServer{
    //消息队列
    LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(10);


    @Override
    public void resiveMessage(String message) throws InterruptedException {
        queue.put(message);
    }

    @Override
    public void sendMessage() {
        String message;
        while (true){
            message = queue.poll();
            if(message == null){
                break;
            }
            for (MailUser user : list){
                user.resiveMessage(message);
            }
        }

    }
}


//抽象邮箱用户
abstract class MailUser{
    //有一个对邮箱的引用
    public MailboxServer mailboxServer;

    public MailUser(MailboxServer mailboxServer){
        this.mailboxServer = mailboxServer;
    }

    public abstract void resiveMessage(String message);
    public abstract void sendMessage(String messages) throws InterruptedException;

}

//具体邮箱用户
class User1 extends MailUser{

    public User1(MailboxServer mailboxServer) {
        super(mailboxServer);
    }

    @Override
    public void resiveMessage(String message) {
        System.out.println("user1 收到消息：" + message);
    }

    @Override
    public void sendMessage(String messages) throws InterruptedException {
        mailboxServer.resiveMessage(messages);
        System.out.println("user1发送消息 ：" + messages);
    }

}

class User2 extends MailUser{

    public User2(MailboxServer mailboxServer) {
        super(mailboxServer);
    }

    @Override
    public void resiveMessage(String message) {
        System.out.println("user2 收到消息：" + message);
    }

    @Override
    public void sendMessage(String messages) throws InterruptedException {
        mailboxServer.resiveMessage(messages);
        System.out.println("user2发送消息 ：" + messages);
    }
}

//中介者模式
public class MediatorStudy {

    public static void main(String[] args) throws InterruptedException {

        WYMail wyMail = new WYMail();
        User1 user1 = new User1(wyMail);
        User2 user2 = new User2(wyMail);

        wyMail.regirstUser(user1);
        wyMail.regirstUser(user2);
        user1.sendMessage("哈哈");
        user2.sendMessage("嘿嘿");

        wyMail.sendMessage();

    }

}

例子中，用户是通过邮箱来发送消息给其他人，而不用维护自身对其他用户的引用，松散耦合。

3、总结

中介者模式：
优点：
1、松散耦合、将多个对象之间的联系紧耦合封装到中介对象中，做到松耦合。不会导致一动牵全身。

2、将多个对象之间的交互联系集中在中介对象中。发送变化仅需修改中介对象即可、提供系统的灵活性、使同事对象独立而易于复用。

3、符合迪米特原则。就是说一个对象应当对其他对象有尽可能少的了解。减少各个对象之间的了解。

缺点：
1、如果各个同事间的交互非常多并且复杂情况下，都交给中介者会导致中介者变得十分复杂，不易维护和管理。

应用场景：

1、系统中对象间存在较为复杂引用，导致依赖关系和结构混乱而无法复用的情况。

2、想通过一个中间类来封装多个类的行为，但是又不想要太多的子类。