[Design Pattern] Mediator Pattern

[Design Pattern] Mediator Pattern

 

mediator(중재자) 패턴에 대하여 알아보고

예시를  java로 작성한 예와  kotlin으로 작성한 예를 보도록 하겠습니다.

 

 

Mediator Pattern 이란?

• mediator pattern은 클래스 간의 상호작용을 하나의 클래스에 위임하여 처리하는 패턴입니다.
• M:N의 관계에서 M:1의 관계로 복잡도를 떨어뜨려 유지보수 및 확장성에 유리합니다.(의존성이 적어집니다.)
• 다른 객체의 존재를 모르는 상태에서도 메시지를 주고받을 수 있습니다.

 

 

특징

ConcreteColleague클래스는 Colleague(동료) interface를 구현하고 있는  N개의 객체입니다.

 ConcreteCollegue 클래스 간 데이터 전달을  위하여  Mediator를 이용합니다. 

 

 

Mediator Pattern with Java

public class ChatUser {
    private ChatMediator mediator;
    private String name;

    public ChatUser(ChatMediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    public void send(String msg) {
        System.out.println(name + " Sending Message = " + msg);
        mediator.sendMessage(msg, this);
    }

    public void receive(String msg) {
        System.out.println(name + " Message received : " + msg);
    }
}

public class ChatMediator {
    private List<ChatUser> users = new ArrayList<>();

    public void sendMessage(String msg, ChatUser user) {
        users.stream()
                .filter(u -> u != user)
                .forEach(u -> u.receive(msg));
    }

    public ChatMediator addUser(ChatUser user) {
        users.add(user);
        return this;
    }
}

public class MediatorTest {
    public static void main(String[] args) {
        ChatMediator mediator = new ChatMediator();

        ChatUser john = new ChatUser(mediator,"John");

        mediator.addUser(new ChatUser(mediator,"Alice"))
                .addUser(new ChatUser(mediator,"Bob"))
                .addUser(john);

        john.send("Hi every one!");
    }
}

//result

John: Sending Message= Hi everyone!
Alice: Message received: Hi everyone!
Bob: Message received: Hi everyone!

ChatUser는 ConcreteColleage입니다.  ChatUser끼리 채팅을 주고받기 위하여 

Mediator를 이용합니다.

 

Mediator에  ConcreteColleage를 등록하고 연결다리로 사용합니다.

 

Mediator Pattern with Kotlin

class ChatUser(private val mediator: ChatMediator, private val name: String) {
    fun send(msg: String) {
        println("$name: Sending Message= $msg")
        mediator.sendMessage(msg, this)
    }

    fun receive(msg: String) {
        println("$name: Message received: $msg")
    }
}

class ChatMediator {

    private val users: MutableList<ChatUser> = ArrayList()

    fun sendMessage(msg: String, user: ChatUser) {
        users
            .filter { it != user }
            .forEach { it.receive(msg) }
    }

    fun addUser(user: ChatUser): ChatMediator =
        apply { users.add(user) }
}

class MediatorTest {

    @Test
    fun `Mediator`() {
        val mediator = ChatMediator()

        val john = ChatUser(mediator, "John")

        mediator
            .addUser(ChatUser(mediator, "Alice"))
            .addUser(ChatUser(mediator, "Bob"))
            .addUser(john)

        john.send("Hi everyone!")
    }
}

//result

John: Sending Message= Hi everyone!
Alice: Message received: Hi everyone!
Bob: Message received: Hi everyone!

 

 

 

정리

단단히 결합되어 유지하기 어려운 일련의 객체를 처리해야 하는 경우 중재자 패턴이 적합합니다. 이러한 방식으로 객체 간의 종속성을 줄이고 전체적인 복잡성을 줄일 수 있습니다.

또한 중개자 개체를 사용하여 단일 구성 요소에 대한 통신 논리를 추출하므로 단일 책임 원칙을 따릅니다. 또한 시스템의 나머지 부분을 변경할 필요 없이 새로운 중재자를 도입할 수 있습니다. 따라서 공개 원칙을 따릅니다.

그러나 때때로 시스템의 잘못된 설계로 인해 단단히 결합된 물체가 너무 많을 수 있습니다. 이 경우 중재자 패턴을 적용해서는 안됩니다. 대신 한 걸음 물러서서 우리가 수업을 모델링 한 방식을 다시 생각해야 합니다.

다른 모든 패턴과 마찬가지로 , 중재자 패턴을 맹목적으로 구현하기 전에 특정 사용 사례를 고려해야 합니다.

 

 

샘플 보러 가기

https://github.com/qjatjr1108/DesignPattern

qjatjr1108/DesignPattern