设计模式-中介者模式(Mediator)

设计模式-中介者模式(Mediator)

    • 一、中介者模式概述
      • 1.1 什么是中介者模式
      • 1.2 简单实现中介者模式
      • 1.3 使用中介者模式的注意事项
    • 二、中介者模式的用途
    • 三、中介者模式实现方式
      • 3.1 使用接口和类的方式
      • 3.2 使用抽象工厂模式的方式
      • 3.3 使用单例模式的方式

一、中介者模式概述

1.1 什么是中介者模式

中介者模式,又被称为调停者模式,是一种行为型设计模式,其核心思想是通过引入一个中介对象来封装一系列对象之间的交互。这种模式使得各对象不需要显式地相互引用,从而降低了它们之间的耦合度和依赖性,使得系统更易于维护和扩展。

中介者模式的主要角色包括:

抽象中介者(Mediator):定义中介者接口,声明各种业务方法。
具体中介者(Concrete Mediator):实现抽象中介者接口,负责与各个同事对象之间的通信和协调。
抽象同事类(Colleague):定义同事类接口,声明一些抽象方法,用于与中介者进行通信。
当系统中的对象之间的关系变得复杂,例如形成网状结构时,中介者模式尤为有用。通过引入中介者,可以将原本复杂的网状结构转化为更为清晰的星型结构,使得各个对象之间的交互更加明确和简单。

举个例子,考虑一个团队协作的场景,团队成员之间可能存在大量的沟通和协作。如果不使用中介者模式,那么每个成员都可能需要知道与其他所有成员的联系方式,这样当有新的成员加入或某个成员离开时,整个系统的复杂度都会增加。而使用中介者模式后,团队成员只需要与中介者通信,由中介者负责调度和协调各个成员之间的交互。

1.2 简单实现中介者模式

中介者模式是一种行为型设计模式,它通过引入一个中介者对象来协调多个对象之间的交互。以下是一个简单的Java实现:

首先,创建一个抽象的中介者类(Mediator):

public abstract class Mediator {
    protected List<Colleague> colleagues = new ArrayList<>();

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void removeColleague(Colleague colleague) {
        colleagues.remove(colleague);
    }

    public abstract void sendMessage(String message, Colleague sender);
}

然后,创建一个具体的中介者类(ConcreteMediator):

public class ConcreteMediator extends Mediator {
    @Override
    public void sendMessage(String message, Colleague sender) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receiveMessage(message, sender);
            }
        }
    }
}

接下来,创建抽象的同事类(Colleague):

public abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void sendMessage(String message);

    public abstract void receiveMessage(String message, Colleague sender);
}

最后,创建具体的同事类(ConcreteColleagueA和ConcreteColleagueB)

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("同事A发送消息:" + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message, Colleague sender) {
        System.out.println("同事A收到来自" + sender + "的消息:" + message);
    }
}

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println("同事B发送消息:" + message);
        mediator.sendMessage(message, this);
    }

    @Override
    public void receiveMessage(String message, Colleague sender) {
        System.out.println("同事B收到来自" + sender + "的消息:" + message);
    }
}

现在,你可以创建中介者和同事对象,并测试它们之间的交互:

public class Main {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Colleague colleagueA = new ConcreteColleagueA(mediator);
        Colleague colleagueB = new ConcreteColleagueB(mediator);

        colleagueA.sendMessage("你好,同事B!");
        colleagueB.sendMessage("你好,同事A!");
    }
}

运行上述代码,你将看到以下输出:

同事A发送消息:你好,同事B!
同事B收到来自同事A的消息:你好,同事B!
同事B发送消息:你好,同事A!
同事A收到来自同事B的消息:你好,同事A

1.3 使用中介者模式的注意事项

  • 1、中介者模式适用于多个对象之间存在复杂的交互关系,需要协调和统一管理的情况。

  • 2、中介者模式会增加系统的复杂性和维护成本,因此应该谨慎使用。

  • 3、中介者模式可能会导致性能问题,因为所有的消息都需要通过中介者传递。

  • 4、中介者模式应该尽量避免过多的中介者对象,否则会导致系统更加复杂。

  • 5、在设计中介者模式时,应该考虑到系统的可扩展性和灵活性,以便在未来可以方便地添加或删除对象。

  • 6、中介者模式应该避免过度依赖中介者对象,否则会导致系统变得脆弱和不可维护

二、中介者模式的用途

  • 1、简化对象之间的关系:中介者模式能够简化系统内各个对象之间的相互关系,将原本复杂的网状结构转变为相对简单的线性结构。

  • 2、降低系统的复杂性:通过引入中介者对象,可以减少子类生成,降低了系统的复杂性和维护成本。

  • 3、提高系统的灵活性和可扩展性:当需要增加新的功能或者删除某个对象时,只需要对中介者进行修改,而不需要修改其他对象,从而提高了系统的灵活性和可扩展性。

  • 4、封装转换规则:中介者模式能够将对象间的交互规则进行封装,使得对象间的交互更加清晰。

三、中介者模式实现方式

3.1 使用接口和类的方式

通过定义一个中介者接口,然后创建具体的中介者类来实现中介者模式。

// 中介者接口
interface Mediator {
    void send(String message, Colleague colleague);
}

// 具体中介者类
class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receive(message);
            }
        }
    }
}

// 同事类
abstract class Colleague {
    protected Mediator mediator;

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

    public abstract void send(String message);

    public abstract void receive(String message);
}

3.2 使用抽象工厂模式的方式

通过定义一个抽象工厂类来创建具体的中介者对象,然后在具体的工厂类中实现中介者对象的创建。

// 抽象工厂类
abstract class AbstractFactory {
    public abstract Mediator createMediator();
}

// 具体工厂类
class ConcreteFactory extends AbstractFactory {
    @Override
    public Mediator createMediator() {
        return new ConcreteMediator();
    }
}

3.3 使用单例模式的方式

通过定义一个中介者类,并使用单例模式来确保整个系统中只有一个中介者对象。

// 中介者类
class Mediator {
    private static Mediator instance;
    private List<Colleague> colleagues = new ArrayList<>();

    private Mediator() {}

    public static Mediator getInstance() {
        if (instance == null) {
            instance = new Mediator();
        }
        return instance;
    }

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }

    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receive(message);
            }
        }
    }
}

你可能感兴趣的:(#,设计模式,设计模式,中介者模式,microsoft)