2021年9月29日-设计模式之中介者模式

随着系统越做越大，我们的类也越来越多。每个类或多或少会调用另外几个类中的方法。如下图：

可以说是相当杂乱的，尤其是这些调用关系是分散在各个类中

所以为了是各个类解耦，我们将这些逻辑调用独立出来放到一个叫中介者的类中。中介者这个类就规定了这些同事类的调用关系。所以一旦一个同事类需要调用另一个同事类的方法，只需发消息给中介者类，由中介者类来调用另一个同事类的方法。

所以现在的关系就像下图：

所以中介者这个类会很复杂，不好写

让我们看一个猫和铲屎官的例子，猫和人都有自己的功能，其中有些功能依赖与对方

Colleague 顶层父类

public abstract class Colleague {
    private Mediator mediator;

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

    void sendMessage(int state, Colleague colleague) {
        this.mediator.getMessage(state, colleague);
    }
}

具体同事类

public class Cat extends Colleague {

    public Cat(Mediator mediator) {
        super(mediator);
    }

    public void needCleanShit() {
        System.out.println("宠物猫: 好多屎啊...");
        sendMessage(ColleagueState.ClEANSHIT, this);
    }

    public void hungry() {
        System.out.println("宠物猫: 又饿了, 需要猫粮喵");
        sendMessage(ColleagueState.HUNGRY, this);
    }

    public void work() {
        System.out.printf("宠物猫: 该工作了...");
    }
}

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

    public void cleanShit() {
        System.out.println("铲屎官: 该铲屎了╮(╯-╰)╭");
    }

    public void pourCatFood() {
        System.out.println("铲屎官: 猫粮又没了!去倒猫粮");
    }

    public void strokeCat() {
        System.out.println("铲屎官: 该休息一会了, 我的猫呢...");
        sendMessage(ColleagueState.STROKECAT, this);
    }
}

中介者顶层父类 Mediator

public interface Mediator {
    void register(Colleague colleague);
    void getMessage(int state, Colleague colleague);
}

中介者类的具体实现

public class ConcreteMediator implements Mediator {
    Cat cat;
    Master master;

    @Override
    public void register(Colleague colleague) {
        if (colleague instanceof Cat) {
            cat = (Cat) colleague;
        } else {
            master = (Master) colleague;
        }
    }

    @Override
    public void getMessage(int state, Colleague colleague) {
        switch (state) {
            case ColleagueState.STROKECAT:
                cat.work();
                break;
            case ColleagueState.ClEANSHIT:
                master.cleanShit();
                break;
            case ColleagueState.HUNGRY:
                master.pourCatFood();
                break;
        }
    }
}

状态类

public class ColleagueState {
    public static final int STROKECAT = 0;
    public static final int ClEANSHIT = 1;
    public static final int HUNGRY = 2;
}

测试类

public class MediatorTest {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        Cat cat = new Cat(mediator);
        Master master = new Master(mediator);
        cat.hungry();
        cat.needCleanShit();
        master.strokeCat();
    }
}

优点：

• 将各个同事类解耦，符合迪米特法则

缺点：

• 中介者承担太多逻辑调用，所以中介者一旦出现问题，整个系统就会收到影响
• 如果设计不当，中介者对象会变得过于复杂