image

Acesse bootcamps ilimitados e +650 cursos

50
%OFF
Article image
Giovanni Rozza
Giovanni Rozza03/05/2023 22:15
Compartilhe

[sw design pattern] Mediator (Mediador)

    Os padrões de design GoF são classificados em três categorias: Criacionais, Comportamentais e Estruturais. Os padrões criacionais tratam da criação de objetos, enquanto os padrões estruturais lidam com a estrutura das classes, como herança e composição. Por fim, os padrões comportamentais lidam com a comunicação entre objetos e suas interações. Estes padrões de projeto se encontram no livro “Padrões de Projetos: Soluções Reutilizáveis de Software Orientado a Objetos” escrito por 4 autores denominados GoF (Gang of Four).

    O padrão Mediator é um padrão de projeto comportamental que permite a redução das dependências entre objetos, promovendo o baixo acoplamento e facilitando a reutilização de código. Ele é especialmente útil quando você tem um conjunto de objetos que interagem uns com os outros de maneira complexa, e você deseja simplificar essas interações.

    No padrão Mediator, um objeto chamado "mediador" é responsável por coordenar a comunicação entre os objetos participantes, conhecidos como "colaboradores". Os colaboradores não se comunicam diretamente entre si, mas sim através do mediador. Isso permite que você altere a interação entre os colaboradores sem precisar modificar os próprios colaboradores.

    Abaixo está um exemplo em Java do padrão Mediator:

    public interface Mediator {
      public void send(String message, Colleague colleague);
    }
    
    
    public class ConcreteMediator implements Mediator {
      private Colleague1 colleague1;
      private Colleague2 colleague2;
      private Colleague3 colleague3;
    
    
      public void setColleague1(Colleague1 colleague1) {
          this.colleague1 = colleague1;
      }
    
    
      public void setColleague2(Colleague2 colleague2) {
          this.colleague2 = colleague2;
      }
    
    
      public void setColleague3(Colleague3 colleague3) {
          this.colleague3 = colleague3;
      }
    
    
      public void send(String message, Colleague colleague) {
          if (colleague == colleague1) {
              colleague2.notify(message);
              colleague3.notify(message);
          } else if (colleague == colleague2) {
              colleague1.notify(message);
              colleague3.notify(message);
          } else if (colleague == colleague3) {
              colleague1.notify(message);
              colleague2.notify(message);
          }
      }
    }
    
    
    public abstract class Colleague {
      protected Mediator mediator;
      public Colleague(Mediator mediator) {
          this.mediator = mediator;
      }
    }
    
    
    public class Colleague1 extends Colleague {
      public Colleague1(Mediator mediator) {
          super(mediator);
      }
    
    
      public void send(String message) {
          mediator.send(message, this);
      }
    
    
      public void notify(String message) {
          System.out.println("Colleague1 gets message: " + message);
      }
    }
    
    
    public class Colleague2 extends Colleague {
      public Colleague2(Mediator mediator) {
          super(mediator);
      }
    
    
      public void send(String message) {
          mediator.send(message, this);
      }
    
    
      public void notify(String message) {
          System.out.println("Colleague2 gets message: " + message);
      }
    }
    
    
    public class Colleague3 extends Colleague {
      public Colleague3(Mediator mediator) {
          super(mediator);
      }
    
    
      public void send(String message) {
          mediator.send(message, this);
      }
    
    
      public void notify(String message) {
          System.out.println("Colleague3 gets message: " + message);
      }
    }
    
    
    public class MediatorDemo {
      public static void main(String[] args) {
          ConcreteMediator mediator = new ConcreteMediator();
          Colleague1 colleague1 = new Colleague1(mediator);
          Colleague2 colleague2 = new Colleague2(mediator);
          Colleague3 colleague3 = new Colleague3(mediator);
    
    
          mediator.setColleague1(colleague1);
          mediator.setColleague2(colleague2);
          mediator.setColleague3(colleague3);
    
    
          colleague1.send("How are you?");
          colleague2.send("Fine, thank you");
      }
    }
    

    Este exemplo consiste em um mediador que ajuda a manter três colegas em contato. O mediador fornece um método send() que envia uma mensagem para todos os colegas, exceto para aquele que envia a mensagem. Cada colega tem um método notify() que recebe a mensagem do mediador. O cliente que usa os colegas e o mediador cria os colegas e define o mediador para cada um deles, então os colegas podem se comunicar por meio do mediador.

    O padrão de design Mediator tem relação com outros padrões de design, tanto de criação como de comportamento. Um exemplo de padrão de criação relacionado é o Abstract Factory, pois o Mediator pode ser utilizado para encapsular a criação de objetos em um sistema. Além disso, o padrão de design Command pode ser utilizado em conjunto com o Mediator para implementar a comunicação entre objetos através de comandos. Outro padrão de comportamento relacionado é o Observer, pois o Mediator pode ser utilizado para implementar a comunicação entre objetos em um sistema distribuído, em que os objetos podem ser notificados sobre as mudanças em outros objetos por meio do mediador.

    Adicionalmente o padrão de comportamento que pode ser relacionado com o Mediator é o Chain of Responsibility. O Mediator pode ser utilizado como um tipo especial de Chain of Responsibility, onde o objeto mediador é responsável por encaminhar as solicitações dos clientes para os objetos apropriados e garantir que apenas um objeto responda a cada solicitação. Além disso, o Mediator também pode ser utilizado em conjunto com o padrão de design Decorator para adicionar funcionalidades adicionais ao objeto mediador, como log, tratamento de exceções, entre outras. Em resumo, o padrão de design Mediator pode ser utilizado em conjunto com outros padrões de design, tanto de criação como de comportamento, para melhorar a modularidade e a flexibilidade de sistemas orientados a objetos.

    links externos com mais exemplos do padrão Mediator:

    —> O código no link abaixo apresenta três classes: PowerSupplier, Button e Fan. A classe PowerSupplier tem dois métodos, turnOn() e turnOff(), que implementam ações que podem ser realizadas por um fornecedor de energia. A classe Button tem uma referência ao Mediator e um método press() que chama o método press() da classe Mediator. A classe Fan tem uma referência ao Mediator e um booleano que indica se o ventilador está ligado ou não. Ela também tem os métodos turnOn() e turnOff() que chamam os métodos start() e stop(), respectivamente, do Mediator.

    O teste unitário apresentado verifica se o ventilador está desligado inicialmente. Em seguida, ele pressiona o botão, verifica se o ventilador está ligado e, em seguida, pressiona o botão novamente e verifica se o ventilador está desligado. Este teste verifica se o padrão Mediator foi implementado corretamente e se o ventilador e o botão estão se comunicando

    https://www.baeldung.com/java-mediator-pattern

    —> No código descrito no link abaixo, a interface Mediator define o contrato para a comunicação entre colegas e a classe abstrata Colleague define o contrato para eventos de notificação do Mediador. A classe ComputerColleague é um exemplo de implementação concreta de Colleague e NetworkMediator é o objeto mediador central que gerencia a comunicação entre diferentes colegas.

    O método register do Mediador adiciona um novo colega à lista de colegas e notifica a todos os outros colegas sobre o novo registro. O método unregister remove um colega da lista e notifica todos os outros colegas sobre a exclusão. A classe ComputerColleague implementa os métodos receiveRegisterNotification e receiveUnRegisterNotification para processar eventos de notificação recebidos do Mediador

    No método main, o objeto mediator é criado como uma instância de NetworkMediator. Em seguida, três instâncias de ComputerColleague são criadas e registradas no Mediador. Por fim, o primeiro colega é removido do Mediador.

    Em resumo, o padrão de projeto Mediator ajuda a desacoplar objetos ao introduzir uma camada intermediária para gerenciar suas interações. O código acima é um exemplo simples deste padrão em ação.

    https://riptutorial.com/design-patterns/example/21456/mediator-pattern-example-in-java

    REFERÊNCIAS:

    https://www.geeksforgeeks.org/mediator-design-pattern/

    https://en.wikipedia.org/wiki/Mediator_pattern

    https://www.scaler.com/topics/design-patterns/mediator-design-pattern/

    https://refactoring.guru/design-patterns/mediator

    https://www.geeksforgeeks.org/mediator-design-pattern-2/

    Compartilhe
    Comentários (0)