1.定义

中介者模式Mediator属于⾏为模式， 能让你减少对象之间混乱⽆序的依赖关系。 该模式会限制对 象之间的直接交互， 迫使它们通过⼀个中介者对象进⾏合作。

1.1.原始设计

1.2.改进后引入中介者

2.中介者模式结构

中介者模式⼜称为调停者模式，从类图中看，共分为3部分：

抽象中介者：定义好同事类对象到中介者对象的接⼝，⽤于各个同事类之间的通信。⼀般包括⼀个或⼏个抽象的事件⽅法，并由⼦类去实现。

中介者实现类：从抽象中介者继承⽽来，实现抽象中介者中定义的事件⽅法。从⼀个同事类接收消息，然后通过消息影响其他同时类。

同事类：如果⼀个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。在类图中，同事类只有⼀个，这其实是现实的省略，在实际应⽤中，同事类⼀般由多个组成，他们之间相互影响，相互依赖。同事类越多，关系越复杂。并且，同事类也可以表现为继承了同⼀个抽象类的⼀组实现组成。在中介者模式中，同事类之间必须通过中介者才能进⾏消息传递。

3.代码

案例：使用中介者模拟一个聊天室功能

抽象用户类（同事父类）：

public abstract class User {
    // 用户名称
    protected String name;
    // 定义中介者，类型为中介者父类
    protected ChatMediator mediator;

    public String getName(){
        return name;
    }

    public User(ChatMediator mediator){
        this.mediator = mediator;
    }
    // 发视消息方法
    public abstract void sendMessage(String message);
    // 接收消息方法
    public abstract void receiveMessage(String message);
}

中介者父类：

public abstract class ChatMediator {
    // 注册方法
    public abstract void register(User user);
    /**
     * @param：发送消息的用户
     * @param：消息内容
     * @describe：消息通知方法
     */
    public abstract void notice(User user, String message);
}

中介者子类：在中介者中持有所有同事对象，等待进行通知

public class ChatServer extends ChatMediator {

    // 定义个list存储聊天室所有用户
    private List<User> userList = new ArrayList<>();

    @Override
    public void notice(User user, String message) {
        // 遍历当前聊天室所有用户，给除了自己以外的所有用户发送消息
        for (User c : userList) {
            if (!user.equals(c)) {
                c.receiveMessage("<<<" + c.getName() + "收到来自" + user.getName() + "的消息：" + message);
            }
        }
    }

    @Override
    public void register(User user) {
        // 判断用户是否注册，如果没有则添加到list中
        if (user != null && !userList.contains(user)) {
            userList.add(user);
        }
    }
}

同事类A：

// 免费用户
public class Member extends User {
    // 每一个具体的用户类在实例化的时候，要持有中介者的对象，在中介者的具体子类中也要持有用户类，两边是相互的
    public Member(String name ,ChatMediator mediator) {
        super(mediator);
        this.name = name;
        // 把当前对象增加到聊天室用户列表中
        mediator.register(this);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println(">>>" + name + ":" + message);
        mediator.notice(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(message);
    }
}

同事类B：不同的同事行为不同，但都面向中介者方法通知其他同事

// VIP用户
public class VIP extends User {
    public VIP(String name , ChatMediator mediator) {
        super(mediator);
        this.name = name;
        mediator.register(this);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println(">>>[VIP]" + name + ":" + message);
        mediator.notice(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(message);
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        //实例化中介者：聊天室服务器
        ChatServer chatServer = new ChatServer();

        //实例化：三个小伙伴，传入用户名和中介者
        User andy = new Member("Andy",chatServer);
        User ben = new VIP("Ben",chatServer);
        User lily = new VIP("Lily",chatServer);


        andy.sendMessage("Hi！Everybody~");
        System.out.println("---------------");
        ben.sendMessage("who likes lol?");
        System.out.println("---------------");
    }
}

输出：

>>>Andy:Hi！Everybody~
<<<Ben收到来自Andy的消息：Hi！Everybody~
<<<Lily收到来自Andy的消息：Hi！Everybody~ --------------- >>>[VIP]Ben:who likes lol?
<<<Andy收到来自Ben的消息：who likes lol?
<<<Lily收到来自Ben的消息：who likes lol?

4.中介者模式的优点

适当地使⽤中介者模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独⽴地使⽤。

使⽤中介者模式可以将对象间⼀对多的关联转变为⼀对⼀的关联，使对象间的关系易于理解和维护。

使⽤中介者模式可以将对象的⾏为和协作进⾏抽象，能够⽐较灵活的处理对象间的相互作⽤。

5.中介者模式的缺点

中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响

6.使用场景

系统中对象之间存在⽐较复杂的引⽤关系，导致它们之间的依赖关系结构混乱⽽且难以复⽤该对象。

转载请注明：西门飞冰的博客 » 设计模式—中介者模式