描述

• 同事类之间的关系很是复杂。可以在同事者类间加一个中间类，让中间类与同事类交互。降低耦合。
• 比如：租房的时候，可以直接找中介说明需求，而不用自己去找各个房主交谈需求。
• 具体耦合，处理对象都在中介者里面处理，同事类只负责接收发送消息。

角色

• 抽象中介者角色：提供同事对象注册和转发信息的抽象方法。
• 具体中介者角色：实现抽象中介者角色，定义一个集合来管理同事对象，执行与同事对象的交互。
• 抽象同事者角色：定义同事类接口，保存中介者对象，提供交互同事类的接口。
• 具体同事者角色：实现抽象同事者角色，把交互交由中介者。

实现

public class Test {
    public static void main(String[] args) {
        Middleman middleman = new Middleman();
        Landlord landlord = new Landlord("阿祖", middleman);
        middleman.setLandlord(landlord);
        Tenant tenant = new Tenant("阿伟", middleman);
        middleman.setTenant(tenant);

        // 房东依赖中介者 由中介者去传递消息给房东
        landlord.communicate("我要出租房子");
        // 租客依赖中介者 由中介者去传递消息给房东
        tenant.communicate("我要找房子");
    }
}

// 抽象中介者角色，与抽象同事者角色交互
abstract class AbstractMediator {

    abstract void interactive(String message, AbstractPerson person);
}

// 抽象同事者类角色，聚合抽象中介者，留有交互方法
abstract class AbstractPerson {
    protected String name;
    protected AbstractMediator abstractMediator;

    AbstractPerson(String name, AbstractMediator abstractMediator) {
        this.abstractMediator = abstractMediator;
        this.name = name;
    }

    // 与中介者沟通的方法
    abstract void communicate(String message);
}

// 具体同事类角色 租客
class Tenant extends AbstractPerson {

    Tenant(String name, AbstractMediator abstractMediator) {
        super(name, abstractMediator);
    }

    @Override
    void communicate(String message) {
        // 告诉中介者我要干嘛（租房），由中介者去处理
        abstractMediator.interactive(message, this);
    }

    void receive(String message) {
        System.out.println("租客" + name + "获取到信息：" + message);
    }
}

// 具体同事类 房东
class Landlord extends AbstractPerson {

    Landlord(String name, AbstractMediator abstractMediator) {
        super(name, abstractMediator);
    }

    @Override
    void communicate(String message) {
    	// 告诉中介者我要干嘛（出租），由中介者去处理
        abstractMediator.interactive(message, this);
    }

    void receive(String message) {
        System.out.println("房东" + name + "获取到信息：" + message);
    }
}


// 具体中介者
class Middleman extends AbstractMediator {

    // 聚合具体同事类（根据业务，可以改成Map等）
    private Tenant tenant;
    private Landlord landlord;

    // 让同事类进行交谈的地方（中介者交由同事类的具体业务代码出）
    @Override
    void interactive(String message, AbstractPerson person) {
        if (tenant == person) {
            landlord.receive(message);
        } else if (landlord == person) {
            tenant.receive(message);
        }
    }

    public void setLandlord(Landlord landlord) {
        this.landlord = landlord;
    }

    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

优点

• 同事类之间的关联交由中介者，同事类之间互不依赖，同事类之间松耦合。
• 同事类发送变化，只需要修改中介者对象，不需要修改其它同事类，可扩展中介者类。
• 一对多的关系转变为一对一的关系。对象之间的关系变得简单一些。

缺点

• 同事类太多时，中介者将变的庞大而复杂，难以维护。

使用场景

• 对象之间存在复杂的引用关系，结构混乱难以维护时可以使用中介者模式。
• 想创建一个可以运行在多个类之间的对象，又不想生成新的子类时，可以创建中介者角色。