Java中的中介器设计模式

在本教程中，我们将学习一种行为模式，该行为模式将促进彼此通信的多个对象之间的松散耦合。 Mediator设计模式背后的想法是拥有一个中心对象，该对象封装了一组对象之间的交互方式。

在调解器模式中，我们在称为调解器的单独类中提取不同类之间的所有关系。 这使我们能够在不影响整个系统的情况下对一个组件进行更改。

因此，我们拥有一个松散耦合的系统，它更易于扩展和维护。

UML表示形式：

我们可以借助以下UML图来表示调解器模式：

在这里，我们有：

• 介体：定义同事之间进行交流的契约的接口或抽象类
• ConcreteMediator：实现调解员合同的类； 它了解所有同事及其相互交流。 同事之间的任何交流都只能通过调解员进行
• 同事：代表我们系统组件的接口或抽象类
• ConcreteColleague：实现Colleague界面并愿意彼此交互的类

实施中介者模式：

让我们以一个航空交通控制系统为例。

每个航班都需要知道其着陆的可用跑道。 如果我们允许飞机之间相互通信以使他们找到可用的跑道，则会导致混乱。 相反， 最好有一个飞机交通控制室，该室可以跟踪所有可用跑道并将其分配给飞机。

让我们从定义AircraftMediator和AircraftTrafficControlRoom开始 ：

public interface AircraftMediator {
 
    public void registerRunway(Runway runway);
    public String allotRunwayTo(Aircraft aircraft);    
    public void releaseRunwayOccupiedBy(Aircraft aircraft); 
}
 
public class AicraftTrafficControlRoom implements AircraftMediator {
    
    private LinkedList<Runway> availableRunways = new LinkedList<>(); 
    private Map<Aircraft, Runway> aircraftRunwayMap = new HashMap<>();
 
    @Override
    public void registerRunway(Runway runway) {
        this.availableRunways.add(runway);
    }
 
    @Override
    public String allotRunwayTo(Aircraft aircraft) {
        Runway nextAvailbleRunway = null;
        if(!this.availableRunways.isEmpty()) {
            nextAvailbleRunway = this.availableRunways.removeFirst();
            this.aircraftRunwayMap.put(aircraft, runway);
        }
        return nextAvailbleRunway == null ? 
          null : nextAvailbleRunway.getName();
    }
 
    @Override
    public void releaseRunwayOccupiedBy(Aircraft aircraft) {
        if(this.aircraftRunwayMap.containsKey(aircraft)) {
            Runway runway = this.aircraftRunwayMap.remove(aircraft);
            this.availableRunways.add(runway); 
        }
    }
}

空中交通管制室充当调解员，并跟踪所有可用跑道。 它负责分配和释放跑道。

定义同事：

现在，让我们定义我们的飞机 ，其实例将是同事：

public interface AircraftColleague {
    void startLanding();
    void finishLanding();
}
 
public class Aircraft implements AircraftColleague {
 
    private AircraftMediator mediator;
    private String flightName;
 
    public Aircraft(AircraftMediator mediator, String flightName) {
        this.mediator = mediator;
        this.flightName = flightName;
    }
 
    @Override
    public void startLanding() {
        String runway = this.mediator.allotRunwayTo(this);
        if(runway == null) {
            //informing passengers
            System.out.println("Due to traffic, there's a delay in landing of " + this.flightName );  
        } else {
            System.out.println("Currently landing " + this.flightName + " on " + runway);  
        }  
    }
 
    @Override
    public void finishLanding() {
       System.out.println(this.flightName + "landed successfully");
       this.mediator.releaseRunwayOccupiedBy(this);
    }
}

测试我们的实施：

让我们看看它们如何一起工作：

// In our main method
Runway runwayA = new Runway("Runway A");
 
AircraftMediator mediator = new AircraftTrafficControlRoom();
mediator.registerRunway(runwayA);
 
AircraftColleague wrightFlight = new Aircraft(mediator, "Wright Flight"); 
AircraftColleague airbusA380 = new Aircraft(mediator, "Airbus A380"); 
 
wrightFlight.startLanding(); 
airbusA380.startLanding();
wrightFlight.finishLanding();

执行上述代码后，我们将得到以下输出：

Currently landing Wright Flight on Runway A
Due to traffic, there's a delay in landing of Airbus A380
Wright Flight landed successfully

如果我们再次尝试降落空中客车，则由于跑道现已可用，我们将能够继续进行降落。

结论：

在本教程中，我们学习了如何实现中介模式。 当我们具有多个对象相互通信的系统时，将使用中介者模式。 这种模式促进了松散的耦合，从而使系统更加灵活。

这种模式的常见应用是聊天或消息传递系统。 而且， Java Concurrency Executor的execute（）方法利用了这种模式。

翻译自: https://www.javacodegeeks.com/2019/09/mediator-design-pattern-java.html