Padrões de projeto em Python

Padrão de projeto Mediator em Python

Nesta lição, você vai usar o padrão Mediator para que os objetos se comuniquem por meio de um objeto intermediário.

  • Avançado
  • 2 min de leitura
  • 1 exemplo executável

Introdução

O problema

Quando muitos objetos falam diretamente uns com os outros, como usuários de chat, campos de formulário ou aviões, cada objeto precisa conhecer todos os outros. As ligações se multiplicam e mudar um objeto afeta muitos outros.

Pense assim

Um mediator é como um grupo num aplicativo de mensagens. A Ada nunca manda mensagem direto para o celular da Lin: ela manda para o grupo, e o grupo entrega para a Lin com o nome da Ada. Um membro novo só precisa entrar no grupo, sem precisar conhecer todo mundo.

Do grupo de mensagens para o código
ChatRoom💬 O grupo no meio de todos
User("Ada", room)📱 Um membro que só conhece o grupo
self.room.send(...)📤 Mande para o grupo, não para outro membro
recipient.receive(...)📥 O grupo entrega para o membro certo
Os objetos se comunicam por um coordenador.
Em uma frase

O padrão Mediator faz a comunicação entre objetos passar por um objeto coordenador, assim os objetos não se referem uns aos outros diretamente.

Pontos-chave

  1. Cada User conhece só room, o ChatRoom compartilhado.
  2. ada.send(lin, "Hello") pede à sala que entregue a mensagem.
  3. ChatRoom.send chama recipient.receive(...) no usuário certo.
  4. Adicionar mais usuários não muda a classe User.

Quando usar?

  • Salas de chat e centrais de mensagens.
  • Formulários em que os campos dependem uns dos outros.
  • Coordenar vários componentes que, de outro modo, se referenciariam.

Quando não é preciso

  • Dois objetos que só falam entre si: uma chamada direta é mais simples.
  • O mediator cresce até virar uma classe que sabe tudo e faz tudo.

Código de exemplo

Executar código →
main.py
class ChatRoom:
    # Mediator: route colleague communication through a coordinator.
    def send(self, sender, recipient, message):
        # Coordinate communication between colleague objects.
        recipient.receive(sender.name, message)


class User:
    def __init__(self, name, room): self.name, self.room = name, room
    def send(self, recipient, message): self.room.send(self, recipient, message)
    def receive(self, sender, message): print(f"{self.name} from {sender}: {message}")


room = ChatRoom()
ada, lin = User("Ada", room), User("Lin", room)
ada.send(lin, "Hello")
Gerar um botão Run para este exemplo

Resultado da execução

Lin from Ada: Hello

Explicação do código

ChatRoom faz o papel de intermediário. Quando Ada envia uma mensagem para Lin, o método send() de User passa a mensagem para ChatRoom, que a repassa ao destinatário. Os objetos User não precisam saber como enviar mensagens uns aos outros, então o resultado é Lin from Ada: Hello.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Tente modificar o código seguindo as sugestões abaixo. Mudar o código e observar o resultado ajuda você a entender muito mais do que só ler.

  1. Substitua o domínio do exemplo preservando a estrutura do padrão.
  2. Compare o padrão com uma implementação mais simples e explique as diferenças.
  3. Escreva testes para cada participante antes de adicionar outra implementação.
Executar no compilador Python →

Erros comuns

Usuários chamando uns aos outros diretamente

Cada usuário passa a precisar de referências para todos os outros.

Problema
def send(self, recipient, message):
    recipient.receive(self.name, message)
Correção
def send(self, recipient, message):
    self.room.send(self, recipient, message)

Terminou esta lição?

Marque como aprendida para acompanhar seu progresso.