中介者模式的学习与使用

1、中介者模式的学习

  中介者模式是一种行为型设计模式，它通过引入一个中介者对象来解耦一组对象之间的交互。中介者模式促进了对象之间的松耦合，使得它们可以独立地进行通信，而不需要直接相互引用。
  在中介者模式中，有以下几个角色：

• Mediator（中介者）：定义了对象之间的通信接口，提供了注册、转发和通知等方法，可以协调不同对象之间的交互。
• ConcreteMediator（具体中介者）：实现了中介者接口，负责协调具体的对象之间的交互。它通常会维护一个对象的集合，用于管理对象之间的通信。
• Colleague（同事）：定义了对象之间的通信接口，通常包含一个send()方法用于发送消息，以及一个receive()方法用于接收消息。
• ConcreteColleague（具体同事）：实现了同事接口，负责向中介者发送和接收消息。

  中介者模式的核心思想是将对象之间的交互逻辑集中在中介者中，而不是让每个对象都直接与其他对象通信。当一个对象需要与其他对象进行通信时，它只需要通过中介者发送消息，而无需知道具体的目标对象。中介者负责将消息转发给合适的目标对象。

2、中介者模式的使用

  假设有一个聊天室程序，其中包含多个用户（User）和一个中介者（Mediator）。用户可以发送消息给其他用户，并接收其他用户发送的消息。中介者负责将用户发送的消息广播给所有其他用户。
抽象中介者

public interface Mediator {

    /**
     * 消息广播
     *
     * @param user
     * @param message
     */
    void messageBroadCasting(User user, String message);
}

具体中介者

public class MediatorImpl implements Mediator {

    private List<User> userList = Lists.newArrayList();

    public void registerUser(User user) {
        userList.add(user);
    }

    @Override
    public void messageBroadCasting(User user, String message) {
        userList.stream().filter(x -> x != user).forEach(m -> m.receiveMessage(message));
    }
}

抽象同事

public interface User {

    /**
     * 发送消息
     *
     * @param message
     */
    void sendMessage(String message);

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

具体同事

public class FirstUserImpl implements User {

    private Mediator mediator;

    public FirstUserImpl(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String message) {
        mediator.messageBroadCasting(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(this.getClass().getSimpleName() + "接收到:" + message);
    }
}

public class SecondUserImpl implements User {

    private Mediator mediator;

    public SecondUserImpl(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String message) {
        mediator.messageBroadCasting(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(this.getClass().getSimpleName() + "接收到:" + message);
    }
}

public class ThirdUserImpl implements User {
    private Mediator mediator;

    public ThirdUserImpl(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void sendMessage(String message) {
        mediator.messageBroadCasting(this, message);
    }

    @Override
    public void receiveMessage(String message) {
        System.out.println(this.getClass().getSimpleName() + "接收到:" + message);
    }
}

客户端

public class UserClient {

    public static void main(String[] args) {
        MediatorImpl mediator = new MediatorImpl();

        User firstUser = new FirstUserImpl(mediator);
        mediator.registerUser(firstUser);

        User secondUser = new SecondUserImpl(mediator);
        mediator.registerUser(secondUser);

        User thirdUser = new ThirdUserImpl(mediator);
        mediator.registerUser(thirdUser);

        firstUser.sendMessage("我是第一个用户,这是我发的消息");
        secondUser.sendMessage("我是第二个用户,我收到了一条新消息");
        thirdUser.sendMessage("我是第三个用户,我收到了一条新消息");
    }

}

SecondUserImpl接收到:我是第一个用户,这是我发的消息
ThirdUserImpl接收到:我是第一个用户,这是我发的消息
FirstUserImpl接收到:我是第二个用户,我收到了一条新消息
ThirdUserImpl接收到:我是第二个用户,我收到了一条新消息
FirstUserImpl接收到:我是第三个用户,我收到了一条新消息
SecondUserImpl接收到:我是第三个用户,我收到了一条新消息

3、总结

  中介者模式的优点包括：

• 解耦了对象之间的交互关系，使得对象之间的通信更加灵活和可扩展。
• 降低了对象之间的复杂性，每个对象只需要关注自身的业务逻辑。
• 可以简化对象的维护和调试，由于对象之间的交互逻辑集中在中介者中，可以更方便地追踪和调试问题。

然而，中介者模式也有一些限制和注意事项：

• 中介者对象会变得复杂，因为它需要管理多个对象之间的交互。
• 过度使用中介者模式可能会导致系统的复杂性增加，使得代码难以理解和维护。
• 中介者模式的实现可能会导致性能问题，特别是当对象之间的交互非常频繁时。

总体而言，中介者模式适用于一组对象之间存在复杂的交互关系，或者对象之间的耦合度过高的情况。通过引入中介者对象，可以将对象之间的通信逻辑抽离出来，提高系统的灵活性和可维护性。