Mediatorパターンの調査ドキュメント

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

┌──────────────────┐
│   Colleague A    │───┐
└──────────────────┘   │
                       ▼
                 ┌──────────┐
                 │ Mediator │
                 └──────────┘
                       ▲
┌──────────────────┐   │
│   Colleague B    │───┘
└──────────────────┘

 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

# Mediator Interface
class ChatRoomMediator:
    def show_message(self, user, message):
        pass

# Concrete Mediator
class ChatRoom(ChatRoomMediator):
    def show_message(self, user, message):
        from datetime import datetime
        time = datetime.now().strftime("%H:%M:%S")
        sender = user.get_name()
        print(f"[{time}] {sender}: {message}")

# Colleague
class User:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator
    
    def get_name(self):
        return self.name
    
    def send_message(self, message):
        self.mediator.show_message(self, message)

# 使用例
if __name__ == "__main__":
    chat_room = ChatRoom()
    
    alice = User("Alice", chat_room)
    bob = User("Bob", chat_room)
    
    alice.send_message("こんにちは、Bob!")
    bob.send_message("やあ、Alice!")

 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

// Mediator
class ChatRoom {
    public static void showMessage(User user, String message) {
        System.out.println(new java.util.Date() 
            + " [" + user.getName() + "] : " + message);
    }
}

// Colleague
class User {
    private String name;
    
    public User(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void sendMessage(String message) {
        ChatRoom.showMessage(this, message);
    }
}

// 使用例
public class MediatorPatternDemo {
    public static void main(String[] args) {
        User robert = new User("Robert");
        User john = new User("John");
        
        robert.sendMessage("Hi! John!");
        john.sendMessage("Hello! Robert!");
    }
}

 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

#include <iostream>
#include <string>
#include <vector>

class Mediator; // 前方宣言

class Colleague {
public:
    Colleague(Mediator* m, std::string n) 
        : mediator(m), name(n) {}
    
    void send(const std::string& msg);
    void receive(const std::string& msg);
    std::string getName() { return name; }

private:
    Mediator* mediator;
    std::string name;
};

class Mediator {
public:
    void addUser(Colleague* user) {
        users.push_back(user);
    }
    
    void relay(std::string from, std::string msg) {
        for (auto user : users) {
            if (user->getName() != from) {
                user->receive(msg);
            }
        }
    }

private:
    std::vector<Colleague*> users;
};

void Colleague::send(const std::string& msg) {
    mediator->relay(name, msg);
}

void Colleague::receive(const std::string& msg) {
    std::cout << name << " received: " << msg << std::endl;
}

// 使用例
int main() {
    Mediator mediator;
    Colleague alice(&mediator, "Alice");
    Colleague bob(&mediator, "Bob");
    
    mediator.addUser(&alice);
    mediator.addUser(&bob);
    
    alice.send("Hello Bob");
    bob.send("Hi Alice");
    
    return 0;
}