디자인 패턴 (행위 패턴) - 미디에이터 패턴 (Mediator Pattern)

미디에이터 패턴이란?

- 객체 간의 직접적인 상호 작용을 줄이고, 중앙에서 통신을 중재하는 객체(미디에이터)를 도입하는 패턴

- 객체 간의 의존성을 줄여 유지보수성을 높이고, 결합도를 낮출 수 있음

- 여러 객체가 서로 직접 통신하지 않고 미디에이터를 통해 간접적으로 소통

 

구성 요소

1. Mediator (추상 미디에이터)

객체 간의 통신을 중재하는 인터페이스 제공

객체들이 직접 통신하는 대신, 미디에이터를 통해 소통하도록 유도

 

2. Concrete Mediator(구체적인 미디에이터)

Mediator를 구현하여, 실제 객체 간의 통신을 관리

객체 간의 관계를 관리하며 메시지를 중재

 

3. Colleague (참여 객체)

미디에이터를 통해 다른 객체와 통신하는 구성 요소

직접 다른 객체와 통신하지 않고, 미디에이터를 통해 메시지를 전달받음

 

패턴 흐름

1. 참여 객체(Colleague)는 미디에이터(Mediator)를 통해서만 소통

2. 각 참여 객체가 상태를 변경하면, 미디에이터가 다른 객체에 변경 사항 전달

3. 참여 객체들은 서로를 몰라도 되므로, 결합도가 낮아짐

 

  

미디에이터 패턴 예제 (C++)

 1. #include <iostream>

 2. #include <string>

 3. #include <vector>

 4. #include <memory>

 5.  

 6. using namespace std;

 7.  

 8. // 1. Mediator (추상 미디에이터)

 9. class ChatMediator {

10. public:

11.     virtual void sendMessage(const string& message, class User* user) = 0;

12.     virtual void addUser(shared_ptr<class User> user) = 0;

13. };

14.  

15. // 2. Colleague (참여 객체) - 사용자

16. class User {

17. protected:

18.     string name;

19.     ChatMediator* mediator;  // 미디에이터를 통한 통신

20.  

21. public:

22.     User(string name, ChatMediator* mediator) : name(name), mediator(mediator) {}

23.     virtual void send(const string& message) = 0;

24.     virtual void receive(const string& message) = 0;

25. };

26.  

27. // 3. ConcreteColleague (구체적인 참여 객체)

28. class ConcreteUser : public User {

29. public:

30.     ConcreteUser(string name, ChatMediator* mediator) : User(name, mediator) {}

31.  

32.     void send(const string& message) override {

33.         cout << name << " ▶ " << message << endl;

34.         mediator->sendMessage(message, this);

35.     }

36.  

37.     void receive(const string& message) override {

38.         cout << name << " (받음) ⬅ " << message << endl;

39.     }

40. };

41.  

42. // 4. ConcreteMediator (구체적인 미디에이터) - 채팅방

43. class ChatRoom : public ChatMediator {

44. private:

45.     vector<shared_ptr<User>> users;  // 참여한 사용자 목록

46.  

47. public:

48.     void addUser(shared_ptr<User> user) override {

49.         users.push_back(user);

50.     }

51.  

52.     void sendMessage(const string& message, User* sender) override {

53.         for (auto& user : users) {

54.             if (user.get() != sender) {  // 메시지 보낸 사람 제외

55.                 user->receive(message);

56.             }

57.         }

58.     }

59. };

60.  

61. // 5. Client (클라이언트)

62. int main() {

63.     ChatRoom chatRoom;

64.  

65.     auto user1 = make_shared<ConcreteUser>("Alice", &chatRoom);

66.     auto user2 = make_shared<ConcreteUser>("Bob", &chatRoom);

67.     auto user3 = make_shared<ConcreteUser>("Charlie", &chatRoom);

68.  

69.     chatRoom.addUser(user1);

70.     chatRoom.addUser(user2);

71.     chatRoom.addUser(user3);

72.  

73.     user1->send("안녕하세요!");

74.     user2->send("반갑습니다!");

75.     user3->send("좋은 하루 되세요!");

76.  

77.     return 0;

78. }

79.  

 

미디에이터 패턴 장점

1. 객체들이 직접 서로 참조하지 않고, 미디에이터를 통해 간접적으로 소통하므로 객체 간의 결합도 낮아짐

2. 객체 간의 복잡한 의존 관계를 단순화 : 복잡한 N:N 관계를 1:N 관계로 단순화

3. 새로운 객체 추가해도 미디에이터만 수정하면 되므로 확장성이 뛰어남

 

미디에이터 패턴 단점

1. 미디에이터의 복잡도가 증가할 수 있음

2. 모든 통신을 미디에이터가 담당하므로 로직이 커지면 유지보수 어려움

3. 미디에이터가 너무 많은 역할을 맡으면 단일 책임 원칙(SRP) 위반 가능