O padrão Facade (lê-se “Façade”) é um padrão que visa abstrair uma interface mais complexa de um objeto através de uma fachada mais simples para o usuário. Desta

Este padrão vem para resolver um problema que é inerente à criação de softwares: A complexidade com o tempo. Assim como uma máquina que se desgasta com o tempo, um software vai ficando cada vez mais complexo conforme o tempo passa, esta complexidade pode se acumular em grandes sistemas integrados que fazem com que a manutenção e integração entre eles seja quase impossível.

Por isto, padrões como o Facade podem ser muito úteis para quebrar esta complexidade e integrar serviços que antes seriam muito complexos para serem chamadas individualmente.

Funcionamento

1. Iniciamos com um cliente que tenta acessar um método dentro de uma estrutura complexa

2. Uma Facade é criada para capturar a ordem de chamada e o instanciamento de todas as entidades complexas
dentro do emaranhado do sistema.

3. O Client pode chamar a Facade para simplificar a funcionalidade do sistema

4. Podemos também criar uma Facade adicional que implementa a Facade original para evitar poluir uma única
entidade com métodos não relacionados

Código

class Facade {
  protected system1: System1
  protected system2: System2
  
  constructor (system1: System1 = null, system2: System2 = null) {
    this.system1 = system1 || new System1()
    this.system2 = system2 || new System2()
  }
  
  /**
   * Os métodos em uma Facade são só atalhos para vários métodos dentro de vários sistemas
  */
  public operation (): string{
    let result = 'Facade inicializa os sistemas:\n'
    result += this.system1.operation1()
    result += this.system2.operation2()
    result += 'Facade realiza as ações nos sistemas\n'
    result += this.system1.operationX()
    result += this.system2.operationY()
  }
}
  
class System1 {
  public operation1 (): string {
    return 'System1: Pronto!\n'
  }
  
  public operationX (): string {
    return 'System1: Executando ação X\n'
  }
}
  
class System2 {
  public operation2 (): string {
    return 'System2: Pronto!\n'
  }
  
  public operationY (): string {
    return 'System2: Executando ação X\n'
  }
}
  
function client (facade: Facade) => console.log(facade.operation())
  
const system1 = new System1()
const system2 = new System2()
const facade = new Facade(system1, system2)
client(facade)

Veja mais aqui

Proxy

O proxy é um padrão que permite que você substitua um objeto por outro. O proxy tem acesso ao objeto original, permitindo que você execute uma ação antes ou depois de a solicitação passar para o objeto original novamente.

Este padrão é muito utilizado quando temos que lidar com classes ou objetos externos que exigem algum tipo de modificador antes ou depois de ser utilizado. Um grande exemplo de proxy são os próprios proxies do JavaScript ou até mesmo os proxies das Azure Functions que permitem que você execute uma função antes ou depois de o objeto original receber a operação.

Funcionamento

1. A interface do Service é a responsável por declarar tudo que o Service pode fazer. O proxy precisa seguir essa
mesma interface para que ele possa se passar por aquele objeto.

2. O Service é o que queremos imitar

3. A classe do Proxy tem uma referência ao Service original, para que ele possa realizar as ações necessárias e depois
enviar para o objeto original. Em geral, os proxies gerenciam todo o ciclo de vida de seus objetos internos.

Código

// Interface do objeto que vamos copiar
interface Service {
  request(): void
}
  
// O serviço real que o proxy vai substituir
class RealService implements Service {
  public request(): void {
    console.log('RealService: Executando request')

  }
}
  
// O Proxy tem uma interface idêntica ao serviço
class Proxy implements Service {
  private realService: RealService
  
  constructor (realService: RealService) {
    this.realService = realService
  }
  
  public request (): void {
    this.logAccess()
    this.realService.request()
  }
  
  private logAccess (): void {
    console.log('Proxy: Logando a request')
  }
}
  
/**
 * O client deve ser capaz de trabalhar com ambos os objetos
*/
function clientCode (service: Service) => service.request()
  
// Executando com o objeto real
const realService = new RealService()
clientCode(realService) // Não tem o log
  
const proxy = new Proxy(realService)
clientCode(proxy) // Com o log

Perceba que estamos enviando o objeto real como um parâmetro para o proxy, os usos mais comuns de um proxy são lazy loading, controle de acesso, logging e etc. Dessa forma, podemos reescrever o proxy assim:

import { RealService } from './RealService'
  
class Proxy implements Service {
  private realService: RealService
  
  constructor () {
    // Lógica de inicialização direta no construtor
    this.realService = new RealService()
  }
  
  public request (): void {
    this.logAccess()
    this.realService.request()
  }

  
  private logAccess (): void {
    console.log('Proxy: Logando a request')
  }
}

Para que o proxy tenha total controle do objeto envelopado, ou então até mesmo executar o instanciamento somente na chamada da função:

import { RealService } from './RealService'
  
class Proxy implements Service {
  
  public request (): void {
    realService = new RealService()
    this.logAccess()
    realService.request()
  }
  
  private logAccess (): void {
    console.log('Proxy: Logando a request')
  }
}

O contra destas duas abordagens é que perdemos a capacidade de um teste direto, precisando realizar uma injeção de memória para que possamos mockar o objeto e testá-lo.

Veja mais aqui

Flyweight

/**
 * Classe que guarda o estado interno e realiza operações de comportamento
 * recebendo o estado externo, ou o contexto.
*/
class Flyweight {

  private sharedState: any;
  
  constructor(sharedState: any) {
      this.sharedState = sharedState;
  }
  
  public operation(uniqueState): void {
      const s = JSON.stringify(this.sharedState);
      const u = JSON.stringify(uniqueState);
      console.log(`Flyweight: Mostrando estados compartilhado (${s}) e único (${u}).`);
  }
}
  
/**
 * Temos que ter uma factory para gerenciar os objetos a fim de que
 * eles não tenham instanciamentos múltiplos e também gerencie todo o fluxo
 * de vida de uma classe compartilhada
*/
class FlyweightFactory {
  private flyweights: {[key: string]: Flyweight} = <any>{};
  
  constructor(initialFlyweights: string[][]) {
      for (const state of initialFlyweights) {
          this.flyweights[this.getKey(state)] = new Flyweight(state);
      }
  }
  
  /**
   * Cria um hash de string para cada um dos flyweights
   */
  private getKey(state: string[]): string {
    return Buffer.from(state.join('_')).toString('base64')
  }
  
  /**
   * Retorna um flyweight existente para aquele estado ou cria outro.
   */
  public getFlyweight(sharedState: string[]): Flyweight {
    const key = this.getKey(sharedState);
  
    if (!(key in this.flyweights)) {
      console.log('FlyweightFactory: Criando um novo.');
      this.flyweights[key] = new Flyweight(sharedState);
    } else {
      console.log('FlyweightFactory: Reusando flyweight existente.');
    }
  
    return this.flyweights[key];
  }

  
  public listFlyweights(): void {
    const count = Object.keys(this.flyweights).length;
    console.log(`\nFlyweightFactory: Contém ${count} flyweights`);
    for (const key in this.flyweights) {
      console.log(key);
    }
  }
}
  
/**
 * O client geralmente cria uma série de flyweights no início da aplicação
 */
const factory = new FlyweightFactory([
    ['Chevrolet', 'Camaro2018', 'pink'],
    ['Mercedes Benz', 'C300', 'black'],
    ['Mercedes Benz', 'C500', 'red'],
    ['BMW', 'M5', 'red'],
    ['BMW', 'X6', 'white']
]);
factory.listFlyweights();
  
function addCarToPoliceDatabase(
    ff: FlyweightFactory,
    plates: string,
    owner: string,
    brand: string,
    model: string,
    color: string,
) {
  console.log('\nClient: Adicionando ao banco.');
  const flyweight = ff.getFlyweight([brand, model, color]);
  
  // O client calcula ou armazena o estado externo e passa para o método
  flyweight.operation([plates, owner]);
}
  
addCarToPoliceDatabase(factory, 'CL234IR', 'James Doe', 'BMW', 'M5', 'red');
addCarToPoliceDatabase(factory, 'CL234IR', 'James Doe', 'BMW', 'X1', 'red');
  
factory.listFlyweights();