一起来学设计模式之中介者模式

程序员皮卡秋
535 阅读6分钟

前言

目前正在出一个设计模式专题系列教程, 篇幅会较多, 喜欢的话，给个关注❤️ ~

本节给大家讲一下设计模式中的中介者模式,并结合实际业务场景给大家讲解如何使用~

本专题的所有案例代码主要以Java语言为主, 好了, 废话不多说直接开整吧~

中介者模式

中介者模式是一种行为型设计模式，其目的是将对象间的相互作用解耦，使得各个对象间的通信只通过中介者进行，从而避免对象之间直接相互依赖，提高代码的可维护性和扩展性。

在中介者模式中，中介者负责协调各个对象间的通信和行为，同时它也包含了这些对象的引用，这些对象则通过中介者进行通信。这种模式通常应用于一个系统中对象之间的相互作用非常复杂，难以维护和扩展的情况。

interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

// 定义抽象同事类
abstract class Colleague {
    private Mediator mediator;

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

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

    public Mediator getMediator() {
        return mediator;
    }

    public abstract void receiveMessage(String message);
}

// 实现具体同事类
class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

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

// 实现具体同事类
class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

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

// 实现具体中介者类
class ConcreteMediator implements Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.receiveMessage(message);
        } else if (colleague == colleague2) {
            colleague1.receiveMessage(message);
        }
    }
}

// 测试代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);

        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("Hello, colleague2!");
        colleague2.sendMessage("Hello, colleague1!");
    }
}

输出

ConcreteColleague2 接收到消息：Hello, colleague2!
ConcreteColleague1 接收到消息：Hello, colleague1!

通过中介者模式，所有同事类都通过中介者对象来发送和接收消息，而不需要直接相互联系，从而实现松耦合的效果。

最佳实践

在电商平台业务中，可以使用中介者模式来实现订单处理功能。中介者模式可以帮助不同对象之间进行通信，而不需要它们直接相互引用

public interface Mediator {
    void placeOrder(Order order);
    void cancelOrder(Order order);
}
 // 定义具体中介者
public class OrderMediator implements Mediator {
     private List<Order> orders = new ArrayList<>();
     @Override
    public void placeOrder(Order order) {
        orders.add(order);
        System.out.println("New order placed: " + order.getOrderId());
    }
     @Override
    public void cancelOrder(Order order) {
        orders.remove(order);
        System.out.println("Cancelled order: " + order.getOrderId());
    }
}
 // 定义抽象同事类
public abstract class Order {
    protected Mediator mediator;
    protected String orderId;
     public Order(Mediator mediator, String orderId) {
        this.mediator = mediator;
        this.orderId = orderId;
    }
     public String getOrderId() {
        return orderId;
    }
     public abstract void place();
    public abstract void cancel();
}
 // 定义具体同事类
public class PurchaseOrder extends Order {
     public PurchaseOrder(Mediator mediator, String orderId) {
        super(mediator, orderId);
    }
     @Override
    public void place() {
        mediator.placeOrder(this);
    }
     @Override
    public void cancel() {
        mediator.cancelOrder(this);
    }
}
 // 使用中介者模式
public class Main {
    public static void main(String[] args) {
        Mediator mediator = new OrderMediator();
        Order order = new PurchaseOrder(mediator, "PO12345");
         order.place();
        order.cancel();
    }
}

在上面的示例中，中介者模式代表了订单处理系统。PurchaseOrder和CancelOrder是它的具体子类。

在Main类中，我们创建了一个OrderMediator实例，并将其传递给PurchaseOrder实例。当我们调用place（）和cancel（）方法时，实际发生的是与中介者对象的通信，而不是直接与其他订单对象通信。

这种设计可以使订单处理系统更加灵活，易于扩展和维护。

结束语

设计模式其实并不难，大家在学习的时候一定要在理解的基础上去写代码，不要去背代码。下节给大家讲备忘录模式~

本着把自己知道的都告诉大家，如果本文对您有所帮助，点赞+关注鼓励一下呗~

相关文章

项目源码(源码已更新 欢迎star⭐️)

Kafka 专题学习

项目源码(源码已更新 欢迎star⭐️)

ElasticSearch 专题学习

项目源码(源码已更新 欢迎star⭐️)

往期并发编程内容推荐

推荐 SpringBoot & SpringCloud (源码已更新 欢迎star⭐️)

博客(阅读体验较佳)

avatar
文章
阅读
粉丝