<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Guilherme Woelke on Medium]]></title>
        <description><![CDATA[Stories by Guilherme Woelke on Medium]]></description>
        <link>https://medium.com/@guilherme_wolke?source=rss-7f8342a15dfc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ImaLAkfRWjhxu4SwULmJ4Q.jpeg</url>
            <title>Stories by Guilherme Woelke on Medium</title>
            <link>https://medium.com/@guilherme_wolke?source=rss-7f8342a15dfc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:42:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@guilherme_wolke/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Padrão Criacional Factory Method (Série Design patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-criacional-factory-method-s%C3%A9rie-design-patterns-0df909575b3a?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/0df909575b3a</guid>
            <category><![CDATA[creational-design-pattern]]></category>
            <category><![CDATA[object-oriented-design]]></category>
            <category><![CDATA[factory-method-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sun, 08 Oct 2023 20:42:08 GMT</pubDate>
            <atom:updated>2023-10-08T20:46:26.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*y-Vm5CxhYS9GKZmP_600jQ.png" /><figcaption>Imagem retirada em <a href="https://refactoring.guru/design-patterns/factory-method">https://refactoring.guru/design-patterns/factory-method</a></figcaption></figure><p>Olá caro seguidor!</p><p>Este artigo tem como objetivo apresentar a você o padrão “<strong>Factory Method</strong>”.</p><p>É uma forma de centralizar a criação de objetos, que implementam uma interface comum, mas que possuam divergências entre si, quanto à formas de interação no sistema.</p><p>Este artigo, como todos desta série, está organizado pelos seguintes tópicos:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações do desenvolvimento cru desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>Dando continuidade ao nosso sistema, onde à partir de um orçamento, um pedido pode ser gerado, eu tomei a liberdade de especializar um pouco mais os itens do orçamento.</p><p>Todo orçamento pode ter uma relação de itens deste orçamento, e cada item é composto por um produto, e quantidade deste produto.</p><p>Para ilustrar melhor o contexto, eu estou deixando ele menos genérico e transformando-o em um sistema de gestão de lojas de material de construção, onde um cliente faz um orçamento de uma relação de materiais de construção, e deste um novo pedido é extraído.</p><h3>O desenvolvimento da solução sem o padrão</h3><p>Para recapitular o que fizemos até o momento, segue o nosso código, já com esta preparação:</p><p>Classe Orcamento.java</p><pre>package factoryMethod.raw;<br><br>import factoryMethod.raw.statuses.EmAnalise;<br>import factoryMethod.raw.statuses.Status;<br><br>import java.math.BigDecimal;<br>import java.time.LocalDateTime;<br>import java.time.format.DateTimeFormatter;<br>import java.util.List;<br><br>public class Orcamento {<br><br>    protected BigDecimal valor;<br>    private List&lt;ItemOrcamento&gt; itens;<br>    private Status status;<br><br>    public Orcamento() {<br>    }<br><br>    public Orcamento(BigDecimal valor, List&lt;ItemOrcamento&gt; itens) {<br>        this.valor = valor;<br>        this.itens = itens;<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.itens.stream().mapToInt(i -&gt; +i.getQuantidade()).sum();<br>    }<br><br>}</pre><p>A classe de orçamentos que estamos atuando desde (quase) sempre.</p><p>A única alteração que eu fiz, foi no método “getQuantidadeItens”. Se vamos somar as quantidades dos itens de orçamento, eu preciso somar as quantidades de todos os itens. Por este motivo, preciso iterar sobre esta lista.</p><p>Classe <em>ItemOrcamento.java</em></p><pre>package factoryMethod.raw;<br><br>public class ItemOrcamento {<br><br>    private Produto produto;<br>    private Integer quantidade;<br><br>    public ItemOrcamento(Produto produto, Integer quantidade) {<br>        this.produto = produto;<br>        this.quantidade = quantidade;<br>    }<br><br>    public Produto getProduto() {<br>        return this.produto;<br>    }<br><br>    public Integer getQuantidade() {<br>        return this.quantidade;<br>    }<br>}</pre><p>O “ItemOrcamento” como explicado, é composto pelo dado já existente da quantidade deste item, e agora de um objeto do tipo “Produto”, que será detalhado logo abaixo.</p><p>Classe <em>Produto.java</em></p><pre>package factoryMethod.raw;<br><br>import java.math.BigDecimal;<br><br>public class Produto {<br>    private Long id;<br><br>    private String nome;<br><br>    private String categoria;<br><br>    private BigDecimal preco;<br><br>    // String descricao, String foto etc...<br><br>    public Produto(Long id, String nome, String categoria, BigDecimal preco) {<br>        this.id = id;<br>        this.nome = nome;<br>        this.categoria = categoria;<br>        this.preco = preco;<br>    }<br><br>    public Long getId() {<br>        return id;<br>    }<br><br>    public String getNome() {<br>        return nome;<br>    }<br><br>    public String getCategoria() {<br>        return categoria;<br>    }<br><br>    public BigDecimal getPreco() {<br>        return preco;<br>    }<br>}</pre><p>Uma classe mais adequada para detalhar os dados de um Produto.</p><p>Nela eu tenho descrito o ID, nome, a categoria onde ela se encontra em meu sistema, preço, e também poderia conter aqui uma descrição, uma (ou uma coleção de) foto, SKU, marca, centro de distribuição onde ele fica armazenado etc…</p><p>Classe <em>Main.java</em></p><pre>package factoryMethod.raw;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.List;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        String cliente = &quot;Cliente 1&quot;;<br><br>        Produto p1 = new Produto(1L, &quot;Tinta para parede externa 18L&quot;, &quot;Tintas&quot;, new BigDecimal(&quot;250&quot;));<br>        Produto p2 = new Produto(2L, &quot;Thinner&quot;, &quot;Solventes&quot;, new BigDecimal(&quot;35&quot;));<br>        Produto p3 = new Produto(3L, &quot;Rolo 15cm de pêlo de carneiro&quot;, &quot;Rolos e Pincéis&quot;, new BigDecimal(&quot;15&quot;));<br><br>        List&lt;ItemOrcamento&gt; itens = new ArrayList&lt;&gt;();<br>        itens.add(new ItemOrcamento(p1, 1));<br>        itens.add(new ItemOrcamento(p2, 1));<br>        itens.add(new ItemOrcamento(p3, 1));<br><br>        Orcamento orcamento = new Orcamento(new BigDecimal(&quot;300&quot;), itens);<br><br>        // Continuidade da jornada do orçamento até que ele vire pedido no sistema, seja faturado, entregue etc...<br>    }<br>}</pre><p>A classe “client” que instancia o objeto do orçamento e dá o prosseguimento da jornada prevista no sistema (suprimido aqui pois o fluxo posterior à este momento não é relevante para o objetivo deste artigo).</p><p>Veja que nela estamos criando instâncias para 3 produtos neste exemplo, com ID, nome do produto, categoria e preço. Adicionamos estes produtos em uma lista, junto com suas respectivas quantidades, e criamos um orçamento, de R$300,00, e estes itens.</p><h3>Problemas</h3><p>Neste exemplo, estamos classificando todos os produtos com um mesmo padrão de informações: Todos eles têm um ID, um nome, uma categoria, e um preço (descrição, centro de distribuição, granulidade, fabricante etc). Se os produtos, mesmo sendo de categorias diferentes, podem ser descritos neste padrão em seu sistema, tudo bem…</p><p>Contudo, imaginem vocês que nossa loja de materiais de construção, fez uma parceria com uma marca famosa de tintas, e que agora, ela também comercializa cursos de pintura doméstica, para pedreiros e proprietários de imóveis. Estes cursos são de um tipo de produto novo que serão comercializados no nosso sistema (que pode ser um sistema web, onde o cliente compra pela internet), e não possui como característica, informações como centro de distribuição (pois ele não é um objeto palpável, e sim uma prestação de serviço, muitas vezes até virtual), granulidade (posso comprar 1 litro ou 2m² de um curso?) etc… Mas possui informações como instrutor, como carga horária, modalidade (se é presencial ou online), entre outros.</p><p>Além do mais, existem categorias de produtos cuja natureza é bem específica, e que a forma de comercialização ou disponibilidade dele é diferente de outras categorias (pisos por exemplo, que é comercializado por metragem quadrada, areia que é vendido tanto por peso em quilogramas ou metros cúbicos).</p><p>Poderíamos até criar, no nosso orçamento, listas de itens cujos produtos seguissem padrões pré-definidos (uma lista de produtos comuns, outra lista de produtos do tipo prestação de serviço, outra de alguma natureza que não se encaixa nas descritas acima, enfim), mas todo orçamento terá listas separadas, que podem estar preenchidas ou não, e não parece que seja adequada esta discriminação categórica de produtos, pois novas categorias surgiriam a frente, e isso faria com que novas listas tivessem que ser criadas indeterminadamente.</p><p>Como congregar, então, todos estes produtos, de naturezas bem distintas, em meu orçamento?</p><h3>A solução</h3><p>O padrão “Factory Method” nos oferece um meio para separar a implementação da classe, de quem usaria a instância desta classe, criando uma classe intermediária, que tem o objetivo de criar e retornar um objeto de uma determinada (ou mais) classe (s), bem como definir um tipo padrão para estas classes (seja via herança de classes abstratas ou interfaces).</p><p>Podemos assim criar uma superclasse do tipo “Produto”, onde ela vai conter as informações e comportamentos comuns aos produtos, independente de suas especificidades, e no que for divergente, que cada classe fique responsável por criar meios de se compatibilizar com o ecossistema. Ou podemos criar uma interface “Produto” e estabelecer comportamentos mínimos para que uma classe seja considerada um produto em nosso sistema. Iremos neste exemplo por este último caminho.</p><p>Além disso, precisamos de uma classe que seja responsável por “fabricar” estes objetos para nós.</p><p>Vejamos como este padrão propõe nossa organização de código na prática:</p><p>Interface <em>Produto.java</em></p><pre>package factoryMethod.solution.products;<br><br>import java.math.BigDecimal;<br><br>public interface Produto {<br>    BigDecimal getValorUnitario();<br><br>}</pre><p>No meu exemplo, para um produto ser considerado “produto”, eu exijo apenas que ele me retorne um valor unitário. Fique a vontade para imaginar mais comportamentos necessários.</p><p>Tomei a liberdade de criar um pacote chamado “products”, para que todas as denominações potenciais de produtos, ficassem dentro deste pacote, a fim de organizar melhor o “codebase”.</p><p>Classe <em>Cursos.java</em></p><pre>package factoryMethod.solution.products;<br><br>import java.math.BigDecimal;<br><br>public class Cursos implements Produto {<br><br>    private Long id;<br>    private String titulo;<br>    private String modalidade;<br>    private Integer cargaHoraria;<br>    private String instrutor;<br>    private BigDecimal valor;<br><br>    /**<br>     * .<br>     * .<br>     * .<br>     *<br>     *<br>     * Todos os setters destes atributos<br>     */<br>    @Override<br>    public BigDecimal getValorUnitario() {<br>        return null;<br>    }<br>}</pre><p>A classe “Cursos”, como informado anteriormente, tem suas particularidades, tais como nome do instrutor, carga horária (não falamos em termos de metragem ou peso), modalidade (não falamos em termos de centro de distribuição, pois um curso, seja online ou presencial, é ministrado, e não entregue tampouco armazenável), além de outras informações que o sistema precise porventura controlar.</p><p>Por ser uma classe que implementa a interface Produto, ela obrigatoriamente fica responsável por calcular seu próprio valor unitário, de acordo com suas características.</p><p>Classe <em>Piso.java</em></p><pre>package factoryMethod.solution.products;<br><br>import java.math.BigDecimal;<br><br>public class Piso implements Produto {<br><br>    private Long id;<br>    private String nome;<br>    private String fabricante;<br>    private Double largura;<br>    private Double altura;<br>    private String aplicacao;<br>    private boolean impermeavel;<br>    private BigDecimal preco;<br>    private String centroDeDistribuicao;<br><br>    /**<br>     * .<br>     * .<br>     * .<br>     *<br>     *<br>     * Todos os setters destes atributos<br>     */<br><br>    @Override<br>    public BigDecimal getValorUnitario() {<br>        return null;<br>    }<br>}</pre><p>A classe “Piso” também tem, além de informações compartilháveis com demais produtos, suas características únicas, tais como largura e altura (pois são vendidos em metragem quadrada, e por isso a medida da peça interfere no valor da caixa fechada, por exemplo), aplicação (interna ou externa), se é impermeável ou não, em qual centro logístico da loja está armazenado etc…</p><p>Assim como as demais classes que implementam a interface “Produto”, ela também tem que informar qual seu valor unitário (pode ser que estes pisos sejam vendidos em caixas fechadas, e o cálculo deste valor precise considerar metragem e o preço da peça, por exemplo. Ou seja, uma forma particular de informar seu valor unitário).</p><p>Classe <em>Tinta.java</em></p><pre>package factoryMethod.solution.products;<br><br>import java.math.BigDecimal;<br><br>public class Tinta implements Produto {<br><br>    private Long id;<br>    private String name;<br>    private String marca;<br>    private String tamanho;<br>    private String aplicacao;<br>    private String cor;<br>    private BigDecimal preco;<br>    private String centroDeDistribuicao;<br><br>    /**<br>     * .<br>     * .<br>     * .<br>     *<br>     *<br>     * Todos os setters destes atributos<br>     */<br><br>    @Override<br>    public BigDecimal getValorUnitario() {<br>        return null;<br>    }<br>}</pre><p>A classe Tinta, tem embalagens distintas, tais como lata de 1/4 (900ml), 3.6L ou galão de 18 litros (configurações estas que podem mudar se a cor for pronta ou personalizada). Tem aplicação (interna, externa, banheiro ou dormitório, piso, metais, telha). Tem cor, tipo (latex, acrílica ou à óleo), acabamento (fosco, semi-fosco, semi-brilho ou brilho), se é impermeabilizante ou não… enfim. Perceba a miríade de informações a serem controladas, e que não são compartilhadas com outros tipos de produtos.</p><p>Ela também deve implementar sua própria fórmula para definir o que é “valor unitário”.</p><p>Enum <em>TipoProduto.java</em></p><pre>package factoryMethod.solution.products;<br><br>public enum TipoProduto {<br>    CURSOS,<br>    PISO,<br>    TINTA<br>}</pre><p>Um mapeamento de que tipos de objetos do tipo “Produto” são possíveis de serem gerados.</p><p>Classe <em>ProdutoFactory.java</em></p><pre>package factoryMethod.solution.products;<br><br>public class ProdutoFactory {<br>    public static Produto criarProduto(TipoProduto tipo) {<br>        switch (tipo) {<br>            case PISO -&gt; {return new Piso();}<br>            case TINTA -&gt; {return new Tinta();}<br>            case CURSOS -&gt; {return new Cursos();}<br>        }<br><br>        throw new RuntimeException(&quot;Tipo de instância inválida&quot;);<br>    }<br>}</pre><p>A fábrica de objetos do tipo “Produto” que será responsável por entregar este objeto. Ele precisa apenas que eu informe, via parâmetro qual instância eu preciso, e através de um mecanismo básico de “switch… case”, eu consigo decidir qual tipo concreto eu devo retornar.</p><p>Classe <em>ItemOrcamento.java</em></p><pre>package factoryMethod.solution;<br><br>import factoryMethod.solution.products.Produto;<br><br>public class ItemOrcamento {<br><br>    private Produto produto;<br>    private Integer quantidade;<br><br>    public ItemOrcamento(Produto produto, Integer quantidade) {<br>        this.produto = produto;<br>        this.quantidade = quantidade;<br>    }<br><br>    public Produto getProduto() {<br>        return this.produto;<br>    }<br><br>    public Integer getQuantidade() {<br>        return this.quantidade;<br>    }<br>}</pre><p>A única alteração necessária foi garantir que a propriedade “produto”, que outrora era do tipo concreto “Produto”, agora seja uma implementação da interface Produto.</p><p>Classe <em>Main.java</em></p><pre>package factoryMethod.solution;<br><br>import factoryMethod.solution.products.*;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.List;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        String cliente = &quot;Cliente 1&quot;;<br><br>        Produto p1 = ProdutoFactory.criarProduto(TipoProduto.CURSOS);<br><br>        Produto p2 = ProdutoFactory.criarProduto(TipoProduto.PISO);<br>        Produto p3 = ProdutoFactory.criarProduto(TipoProduto.TINTA);<br><br>        List&lt;ItemOrcamento&gt; itens = new ArrayList&lt;&gt;();<br>        itens.add(new ItemOrcamento(p1, 1));<br>        itens.add(new ItemOrcamento(p2, 1));<br>        itens.add(new ItemOrcamento(p3, 1));<br><br>        Orcamento orcamento = new Orcamento(new BigDecimal(&quot;300&quot;), itens);<br><br>        // Continuidade da jornada do orçamento até que ele vire pedido no sistema, seja faturado, entregue etc...<br>    }<br>}</pre><p>Nosso client tem uma pequena mudança no momento de criar a instância do produto: eu invoco o método estático “criarProduto” da minha fábrica de produtos (ProdutoFactory), e informando o tipo do produto como parâmetro, ela me devolve como retorno um objeto do tipo que escolhi, ao invés de instancia-lo através do operador “new”.</p><p>No nosso exemplo, ele apenas retorna uma instância do objeto. Mas desta forma, é possível garantir que mais ações sejam executadas ao instanciar a classe (uma criação de um objeto de mecanismo de logging, disparo de um ou mais eventos, configurações diversas, injeções de dependências por exemplo), de maneira centralizada (pois é em um único lugar que esta instância será criada), impedindo duplicação de código desnecessária espalhada pelo codebase, ou instanciação sem as devidas configurações para o bom funcionamento deste sistema.</p><h3>Indicações</h3><p>Este padrão atenderá você nas seguintes situações:</p><ul><li><strong>Quando você não sabe de antemão os tipos exatos e dependências dos objetos que seu código precisa lidar: </strong>O padrão “<strong>Factory Method</strong>” separa a o código de construção de objetos, de quem vai usar esta instância. Assim, é possível isolar e padronizar o processo de criação de um objeto de uma classe, criando uma classe que se responsabilizará por isso, além de permitir que futuramente, através de extensão desta mesma classe, eu possa incrementar novas ações de instanciação a objetos, sobrescrevendo a forma de criação atual;</li><li>Quando você gostaria de prover aos códigos que usam suas bibliotecas ou framework, um meio de estender seus componentes internos;</li><li><strong>Quando você deseja economizar recursos do sistema reutilizando objetos já existentes na memória ao invés de criar novos objetos a cada vez que precisar deles:</strong> Se combinarmos este padrão com o padrão Singleton (falarei sobre ele futuramente), podemos garantir que esta fábrica tanto crie objetos quanto reaproveite objetos que já foram criados previamente em outro momento do ciclo de vida da requisição, economizando recursos do hospedeiro;</li></ul><h3>Prós e contras</h3><p>Vantagens desta abordagem:</p><ul><li>Evitar alto acoplamento entre a implementação concreta e quem instancia (através do operador new) a classe;</li><li><strong>Implementação na prática da letra “S” (Single Responsibility Principle) dos princípios SOLID:</strong> Uma classe passa a ser responsabilizada por criar (e/ou retornar) a instância da classe, tornando o código mais fácil de ser mantido;</li><li><strong>Implementação na prática da letra “O” (Open/Closed Principle) dos princípios SOLID:</strong> Caso eu precise de alterações na metodologia de fabricação de instâncias de meus objeto, basta estender esta classe, e implementar as ações necessárias para esta fabricação, sem alterar código já existente e funcionando;</li></ul><p>Mas cuidado: O código pode se tornar mais complicado, uma vez que será necessário introduzir muitas subclasses para implementar o padrão. O melhor cenário para a adoção deste padrão é quando você está introduzindo o padrão em uma hierarquia já existente de classes criadoras.</p><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0df909575b3a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Estrutural Proxy (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-proxy-s%C3%A9rie-design-patterns-c4242f06e69c?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4242f06e69c</guid>
            <category><![CDATA[object-oriented-design]]></category>
            <category><![CDATA[proxy-design-pattern]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[structural-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 23 Sep 2023 20:35:43 GMT</pubDate>
            <atom:updated>2023-09-23T20:35:43.351Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*HbZorKhAbF0M24TsgY2Dew.png" /><figcaption><a href="https://refactoring.guru/design-patterns/proxy">https://refactoring.guru/design-patterns/proxy</a></figcaption></figure><p>Olá caro seguidor!</p><p>Este artigo tem como objetivo apresentar a você o padrão “<strong>Proxy</strong>”.</p><p>Ele funciona como uma espécie de cache, que pode ser muito útil em termos de performance, quando precisamos invocar um método mais de uma vez em nosso sistema, e este método retorna um dado consultado de um serviço externo, por exemplo.</p><p>Este artigo, como todos desta série, é guiado pelos seguintes tópicos:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações do desenvolvimento cru desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>Vamos continuar a trabalhar no código que desenvolvemos na solução do padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-facade-s%C3%A9rie-design-patterns-6edf725ac08d"><strong>Facade</strong></a>”.</p><p>Desta vez, iremos fazer um incremento em nossa ação de envio de emails. Imagine você que precisamos agora retornar o valor do orçamento em nosso email. Contudo, este valor é proveniente de um serviço externo, que outra squad (ou outra empresa), tenha gerência sobre a disponibilidade deste servivço, e que é um serviço que (por inúmeros motivos) sabidamente é lento e/ou sofre regularmente com indisponibilidades.</p><p>Além disso, por alguma necessidade de negócio (não importa qual), precisamos invocar, em nosso código fonte, 2 ou mais vezes o método que retorna o valor deste orçamento (em momentos distintos do ciclo de vida da execução).</p><h3>O desenvolvimento da solução sem o padrão</h3><p>As alterações que realizei para demonstrar a situação, e resolver o problema seguem:</p><p>Classe Orcamento.java</p><pre>package proxy.raw;<br><br>import proxy.raw.statuses.EmAnalise;<br>import proxy.raw.statuses.Status;<br><br>import java.math.BigDecimal;<br>import java.time.LocalDateTime;<br>import java.time.format.DateTimeFormatter;<br><br>public class Orcamento {<br><br>    private BigDecimal valor;<br>    private int quantidadeItens;<br>    private Status status;<br><br>    public Orcamento(BigDecimal valor, int quantidadeItens) {<br>        this.valor = valor;<br>        this.quantidadeItens = quantidadeItens;<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        try {<br>            Thread.sleep(5000);<br>        } catch (InterruptedException e) {<br>            throw new RuntimeException(e);<br>        }<br>        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(&quot;dd/MM/yyyy HH:mm:ss &quot;);<br><br>        System.out.println(&quot;Chamada do método getValor() às &quot; + LocalDateTime.now().format(formatter));<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.quantidadeItens;<br>    }<br><br>}</pre><p>Desta vez eu fiz a alteração no método “getValor” da classe Orcamento. Eu estou apenas simulando uma espera de 5 segundos entre sua invocação e o retorno do dado que preciso (fazendo de conta que este método está consumindo um “endpoint” externo e devolvendo o valor).</p><p>Para ilustrar bem as execuções, tomei a liberdade de colocar um “sysout” no método para imprimir a hora de sua execução (como se fosse um logger), para assim podermos acompanhar a sua execução na linha do tempo.</p><p>Classe <em>EnviarEmailPedido.java</em></p><pre>package proxy.raw;<br><br>import java.time.LocalDateTime;<br>import java.time.format.DateTimeFormatter;<br>import java.time.format.DateTimeFormatterBuilder;<br><br>public class EnviarEmailPedido implements AcaoAposGerarPedido {<br><br>    public void executarAcao (Pedido pedido) {<br><br>        System.out.println(&quot;Enviando email com dados do pedido&quot;);<br><br>        System.out.println(pedido.getOrcamento().getValor());<br>        System.out.println(pedido.getOrcamento().getValor());<br>    }<br><br>}</pre><p>O resultado da execução de nosso client, segue abaixo para analisarmos:</p><pre>Salvar pedido no banco de dados<br>Enviando email com dados do pedido<br>Chamada do método getValor() às 23/09/2023 15:59:27 <br>10<br>Chamada do método getValor() às 23/09/2023 15:59:32 <br>10</pre><p>Analisemos este log:</p><ol><li>A ação “<em>salvar o pedido no banco de dados</em>”, é invocada. Até aí era o esperado mesmo;</li><li>A ação “<em>Enviando email com dados do pedido</em>” é invocada. É a primeira linha do método “executarAcao” da classe EnviarEmailPedido;</li><li>A linha “<em>Chamada do método getValor() às 23/09/2023 15:59:27</em>” se refere ao momento que o método getValor da classe Orcamento é invocada. Ou seja: o método, entre o início de sua execução e recuperação do valor, precisou de 5 segundos para ser concluída, para finalmente imprimir a mensagem com a data e hora de execução, e retornou o valor. Guarde por favor este horário!</li><li>O número “10” logo abaixo se refere ao resultado do “sysout” da primeira invocação do método getValor, do método “executarAcao” da classe EnviarEmailPedido;</li><li>A linha “Chamada do método getValor() às 23/09/2023 15:59:32” se refere ao momento que o método getValor() da classe Orcamento é invocada pela segunda vez. Mais uma vez, o método levou 5 segundos para recuperar o valor, imprimiu a mensagem com a data e hora de execução, e retornou o valor. Compare estes horários e veja a diferença entre estas execuções!</li><li>O número “10” logo abaixo se refere ao resultado do “sysout” da segunda invocação do método getValor, do método “executarAcao” da classe EnviarEmailPedido;</li></ol><h3>Problemas</h3><p>Como estamos simulando duas chamadas em um suposto serviço externo (um microsserviço, por exemplo), para retornar um mesmo dado, veja como ficamos “reféns” da disponibilidade deste serviço, e até estamos “onerando” este serviço externo (quando falamos de microsserviços, o client também é responsável por garantir a saúde “dos servers”, cabendo uma decisão de roteamento de requisições para outras opções de servers ou retenção de requisições ao server se o mesmo apresenta problemas. Falarei sobre isso futuramente em minha série de microsserviços).</p><p>Infelizmente, por uma necessidade de negócios, precisamos do valor do orçamento em mais de um ponto da execução do sistema, e o único meio de obter este dado é acionando o método “getValor” deste objeto.</p><p>Levando em conta que este método obrigatoriamente (pelo menos na atual implementação) aciona este serviço externo, não há meios de evitarmos então, o consumo deste microsserviço?</p><h3>A solução</h3><p>Resposta: sim!</p><p>Não posso evitar que o método “getValor” realize chamadas ao serviço externo, mas posso acionar este serviço externo apenas uma vez para recuperar o valor, e armazenar este valor em memória para que eu não precise mais sobrecarregar este serviço, para recuperar o mesmo dado.</p><p>Para isso, o padrão “proxy” nos apresenta uma abordagem bem simples, respeitando a tipagem e a implementação atual. Vejamos:</p><p>Classe <em>OrcamentoProxy.java</em></p><pre>package proxy.solution;<br><br>import java.math.BigDecimal;<br><br>public class OrcamentoProxy extends Orcamento {<br>    private Orcamento orcamento;<br><br>    public OrcamentoProxy(Orcamento orcamento) {<br>        this.orcamento = orcamento;<br>    }<br><br>    @Override<br>    public BigDecimal getValor() {<br>        if (this.valor == null) {<br>            this.valor = orcamento.getValor();<br>        }<br>        return this.valor;<br>    }<br>}</pre><p>no mesmoCria-se uma classe intermediária (que chamaremos aqui de OrcamentoProxy), que será implementada desta forma:</p><ul><li>Ela herdará a classe que pretendemos interceptar (neste caso, a classe Orcamento);</li><li>Ela terá um objeto privado do tipo da super classe, e seu construtor receberá o objeto do orçamento, por onde este orçamento será injetado;</li><li>Faz-se uma sobrescrita do método que pretendo “cachear” seu retorno (no caso, getValor), e nele eu faço a seguinte verificação: Se o serviço externo ainda não foi invocado (à partir do método getValor do objeto Orcamento, verificando se a propriedade “valor” está nula), eu “forço” aqui esta invocação e atribuo o valor à propriedade “valor” da super classe, e retorno este valor. Caso esta propriedade “valor” já tenha sido preenchido em prévia execução, ele retorna o valor já preenchido, sem invocar o método getValor da classe Orcamento (onde obrigatoriamente o serviço externo seria invocado);</li></ul><p>Classe EnviarEmailPedido.java</p><pre>package proxy.solution;<br><br>public class EnviarEmailPedido implements AcaoAposGerarPedido {<br><br>    public void executarAcao (Pedido pedido) {<br><br>        System.out.println(&quot;Enviando email com dados do pedido&quot;);<br><br>        OrcamentoProxy proxy = new OrcamentoProxy(pedido.getOrcamento());<br><br>        System.out.println(proxy.getValor());<br>        System.out.println(proxy.getValor());<br>    }<br><br>}</pre><p>Aqui é o ponto onde esta interceptação será realizada: Se no desenvolvimento sem a aplicação do padrão, invocávamos apenas o método getValor, do objeto Orcamento do objeto pedido, aqui eu crio uma instância do meu proxy, passando em seu construtor o objeto deste meu Orcamento, e invoco o método sobrescrito getValor, em meu OrcamentoProxy, que cuidará de fazer a verificação do valor (lembra que criamos uma propriedade privada do tipo orcamento na classe OrcamentoProxy, e injetamos ela no construtor?).</p><p>Será que isso reduz a quantidade de requisições ao meu serviço externo? Vejamos o que diz o log de execução:</p><pre>Salvar pedido no banco de dados<br>Enviando email com dados do pedido<br>Chamada do método getValor() às 23/09/2023 16:38:43<br>10<br>10</pre><p>Analisemos, pois, este log:</p><ol><li>A ação “<em>Salvar o pedido no banco de dados</em>”, é invocada. Até aí era o esperado mesmo (não mexemos nisso);</li><li>A ação “<em>Enviando email com dados do pedido</em>” é invocada. É a primeira linha do método “executarAcao” da classe EnviarEmailPedido (também não mexemos nisso);</li><li>A linha “Chamada do método getValor() às 23/09/2023 16:38:43” (eu estou executando estes programas no exato momento em que escrevo sobre ele neste artigo), se refere ao momento que o método “getValor” da classe Orcamento é invocada. Ou seja: o método precisou dos mesmos 5 segundos para recuperar o valor, imprimiu a mensagem com a data e hora de execução, e retornou o valor (até aí, era esperado que isso acontecesse. Pelo menos na primeira execução, ainda estamos dependendo deste serviço externo);</li><li>O número “10” logo abaixo se refere ao resultado do “sysout” da primeira invocação do método getValor, do método “executarAcao” da classe EnviarEmailPedido;</li><li>O número “10” logo abaixo se refere ao resultado do “sysout” da segunda invocação do método getValor, do método “executarAcao” da classe EnviarEmailPedido;</li></ol><p>Mas peraí, onde está o horário de execução da segunda invocação do método getValor?</p><p>Resposta: em lugar nenhum! Como a propriedade “valor” da classe Orcamento já estava preenchida, dispensamos no proxy a chamada do método getValor da super-classe, e o valor na segunda invocação veio instantaneamente (lembra como o getValor foi sobrescrito no proxy?)!</p><h3>Indicações</h3><p>Este padrão atenderá você nas seguintes situações:</p><ul><li><strong>Quando você precisa de uma inicialização sob demanda (Lazy initialization): </strong>Você tem um serviço muito pesado e que consome muito recurso sistêmico e de infra toda vez que precise subir este serviço, muito embora você precise deste serviço de vez em quando (similar ao nosso caso);</li><li><strong>Quando você precisa de um controle de acesso à dados de um serviço: </strong>esta criação desta camada intermediária nos permite filtrar a requisição à este serviço, de acordo com o cliente, por exemplo<strong>;</strong></li><li>Quando estou realizando uma requisição local à um serviço remoto;</li><li>Logging de requisições;</li><li>Cacheamento dos resultados (nosso caso);</li></ul><h3>Prós e contras</h3><p>Vantagens desta abordagem:</p><ul><li>Pode-se controlar o objeto do serviço sem que os “clients” saibam disso;</li><li>Pode-se gerenciar o ciclo de vida do objeto do serviço quando este objeto não é mais relevante para o “client”;</li><li>O proxy trabalha até quando o objeto do serviço não está pronto ou indisponível;</li><li><strong>Implementação na prática da letra “O” (Open/Closed Principle) dos princípios SOLID:</strong> No nosso exemplo, o OrcamentoProxy foi uma especialização da classe Orcamento, onde mudamos um comportamento esperado sem alterar a implementação da classe;</li></ul><p>Contudo, existem pontos de atenção que devem ser levados em conta ao decidir adotar esta abordagem:</p><ul><li>O código pode se tornar mais complicado, uma vez que você irá introduzir uma série de novas classes intermediárias;</li><li><strong>A resposta cacheada do serviço pode estar desatualizada:</strong> No nosso exemplo, lidamos com uma informação que sabíamos que não sofreria alterações durante o envio do email. Se a informação que você está tentando “cachear” é um dado que pode ser manipulado por outro usuário/ator/processo do sistema, como um contador, uma cotação de um ativo na bolsa que muda de valor em questão de segundos, ou um lance de um leilão, onde informações desatualizadas podem induzir o usuário à erro em uma operação que para a ação, a informação deve ser atualizada segundo à segundo, considere abrir mão desta abordagem e escolher outra estratégia para entregar performance;</li></ul><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4242f06e69c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Estrutural Facade (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-facade-s%C3%A9rie-design-patterns-6edf725ac08d?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/6edf725ac08d</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[structural-design-pattern]]></category>
            <category><![CDATA[facade-pattern]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 09 Sep 2023 20:35:09 GMT</pubDate>
            <atom:updated>2023-09-09T20:35:09.866Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*H0czJ2RhrtL-QMOa78GV7w.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/facade">https://refactoring.guru/design-patterns/facade</a></figcaption></figure><p>Olá caro seguidor!</p><p>Falaremos hoje sobre o padrão “<strong>Facade</strong>” (não se pronuncia “facêide”, e sim “Fassáde”), conhecido em português como “Fachada”.</p><p>Este padrão é similar ao padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-command-s%C3%A9rie-design-patterns-2db2367acbd9">Command</a>”, comumente utilizado em arquiteturas como Domain Driven Design e Clean Architecture.</p><p>Este artigo, como todos desta série, é guiado pelos seguintes tópicos:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações do desenvolvimento cru desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>O cenário é o mesmo que implementamos na solução do padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-observer-s%C3%A9rie-design-patterns-44fee3ef30a7">Observer</a>”, que por sua vez era já uma evolução do que implementamos no padrão “<strong>Command</strong>”.</p><p>Recapitulando: Para que um pedido seja gerado à partir de um orçamento, definimos ao menos 2 etapas necessárias que deveriam ser cumpridas para considerar, sistemicamente, que o pedido foi criado com sucesso, que eram:</p><ul><li>Salvar o pedido no banco de dados;</li><li>Enviar email para o cliente confirmando o pedido e com os detalhes do mesmo;</li></ul><p>Além disso, eu deixei comentado no código, propositalmente, mais 3 potenciais eventos que seriam disparados quando este caso de uso fosse ativado:</p><ul><li>Emitir Nota Fiscal;</li><li>Separar os itens no estoque;</li><li>Notificar departamento de compras para verificar a necessidade de encomendar os itens dos pedido;</li></ul><h3>O desenvolvimento da solução sem o padrão</h3><p>Relembrando o código da solução a que chegamos no padrão “<strong>Observer</strong>”, vamos mostrar as implementações que realizamos na época:</p><p>Interface <em>AcaoAposGerarPedido</em></p><pre>package facade.raw;<br><br>public interface AcaoAposGerarPedido {<br>    public void executarAcao(Pedido pedido);<br>}</pre><p>As classes que implementam etapas do processo de criação de pedido exigiriam ao menos um método chamado executarAcao, e que recebesse um pedido como parâmetro.</p><p>Classe <em>SalvarPedidoNoBancoDeDados.java</em></p><pre>package facade.raw;<br><br>public class SalvarPedidoNoBancoDeDados implements AcaoAposGerarPedido {<br>  public void executarAcao (Pedido pedido) {<br>    System.out.println(&quot;Salvar pedido no banco de dados&quot;);<br>  }<br>}</pre><p>A classe que salvará o pedido no banco de dados.</p><p>Classe <em>EnviarEmailPedido.java</em></p><pre>package facade.raw;<br><br>public class EnviarEmailPedido implements AcaoAposGerarPedido {<br>    public void executarAcao (Pedido pedido) {<br>        System.out.println(&quot;Enviando email com dados do pedido&quot;);<br>    }<br>}</pre><p>A classe que enviará o email para o cliente.</p><p>Classe <em>GerarPedidoHandler.java</em></p><pre>package facade.raw;<br><br>import java.time.LocalDateTime;<br>import java.util.List;<br><br>public class GerarPedidoHandler {<br>    private List&lt;AcaoAposGerarPedido&gt; acoes;<br><br>    //construtor com injeção de dependências: repositories, services etc...<br>    public GerarPedidoHandler(List&lt;AcaoAposGerarPedido&gt; acoes) {<br>        this.acoes = acoes;<br>    }<br>    <br>    public void executar(GerarPedidoDados dados) {<br>        Orcamento orcamento = new Orcamento(dados.getValorOrcamento(), dados.getQuantidadeItens());<br>        Pedido pedido = new Pedido(dados.getCliente(), LocalDateTime.now(), orcamento);<br>        acoes.forEach(a -&gt; a.executarAcao(pedido));<br>    }<br>}</pre><p>O caso de uso, que disparava a execução de todas as ações da lista ”acoes”, delegadas pelo “client”.</p><p>Classe <em>Main.java</em></p><pre>package facade.raw;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.Arrays;<br>import java.util.List;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        String cliente = args[0];<br>        BigDecimal valor = new BigDecimal(args[1]);<br>        int quantidade = Integer.parseInt(args[2]);<br><br>        GerarPedidoDados dados = new GerarPedidoDados(cliente, valor, quantidade);<br>        GerarPedidoHandler gerador = new GerarPedidoHandler(Arrays.asList(<br>            new SalvarPedidoNoBancoDeDados(),<br>            new EnviarEmailPedido()<br>            /*<br>                new EmitirNotaFiscal(),<br>                new SepararEstoque(),<br>                new NotificarComprasParaEncomendarProdutosDoFornecedor(),<br>                etc...<br>            */<br>        ));<br>        gerador.executar(dados);<br>    }<br>}</pre><p>O client.</p><h3>Problemas</h3><p>Muito embora isolamos a execução destas etapas em um caso de uso, perceba que a solução foi delegar ao “client” a criação do objeto de geração de pedidos, instanciar todas as classes das etapas que seriam executadas pelo caso de uso, e ainda invocar o método executar deste caso de uso.</p><p>Parece razoável delegar ao “client” todas estas responsabilidades?</p><p>Não podemos nos esquecer que, no nosso sistema, teríamos vários canais (clients) por onde seria possível gerar pedidos (CLI’s, API, interface Web, WebService SOAP, gRPC, GraphQL etc).</p><p>Apesar do avanço que tivemos ao atomizar estas etapas em um caso de uso (GeraPedidoHandler), corremos o risco de, ao implementar o client, errarmos a sequência de instanciações das classes de etapas a serem criadas, ou de esquecer alguma das classes... Ou, se cumprirmos à risca as configurações necessárias, estaremos duplicando código, pois independentemente do client, o trecho abaixo:</p><pre>GerarPedidoDados dados = new GerarPedidoDados(cliente, valor, quantidade);<br>GerarPedidoHandler gerador = new GerarPedidoHandler(Arrays.asList(<br>    new SalvarPedidoNoBancoDeDados(),<br>    new EnviarEmailPedido()<br>    /*<br>        new EmitirNotaFiscal(),<br>        new SepararEstoque(),<br>        new NotificarComprasParaEncomendarProdutosDoFornecedor(),<br>        etc...<br>    */<br>));<br>gerador.executar(dados);</pre><p>Sempre irá se repetir a cada client criado.</p><p>Como podemos então, melhorar esta estrutura?</p><h3>A solução</h3><p>Criando uma “fachada” (uma camada intermediária entre o client e o caso de uso), que ficaria responsável por estas configurações, e invocar o caso de uso, deixando os clients apenas com a responsabilidade de formatar seus próprios dados.</p><p>Vejamos como ficaria o “client” e seu intermediário:</p><p>Classe <em>Main.java</em></p><pre>package facade.solution;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        String cliente = args[0];<br>        BigDecimal valor = new BigDecimal(args[1]);<br>        int quantidade = Integer.parseInt(args[2]);<br><br>        PedidosFacade facade = new PedidosFacade(cliente, valor, quantidade);<br>        facade.executar();<br>    }<br>}</pre><p>A classe “client” agora fica responsável somente por formatar os dados para que ele siga o padrão do handler.</p><p>Além disso, nela apenas cri-se uma instância dessa fachada (classe PedidosFacade), cujo construtor recebe estes dados formatados, e invoca o método “executar”, e nada mais!</p><p>Classe PedidoFacade.java</p><pre>package facade.solution;<br><br>import java.math.BigDecimal;<br>import java.util.Arrays;<br><br>public class PedidosFacade {<br>    private GerarPedidoDados dados;<br><br>    public PedidosFacade(String nomeCliente, BigDecimal valor, int quantidadeItens) {<br>        this.dados = new GerarPedidoDados(nomeCliente, valor, quantidadeItens);<br>    }<br><br>    public void executar() {<br>        GerarPedidoHandler gerador = new GerarPedidoHandler(Arrays.asList(<br>                new SalvarPedidoNoBancoDeDados(),<br>                new EnviarEmailPedido()<br>            /*<br>                new EmitirNotaFiscal(),<br>                new SepararEstoque(),<br>                new NotificarComprasParaEncomendarProdutosDoFornecedor(),<br>                etc...<br>            */<br>        ));<br><br>        gerador.executar(dados);<br><br>    }<br>}</pre><p>Vejamos como estruturamos esta fachada:</p><ul><li>O construtor fica responsável por criar uma instância da classe GeraPedidoDados, passando os dados do pedido (nome do cliente, valor do pedido, e quantidade de itens*). Instância esta que passa a ser uma propriedade privada nesta camada;</li><li>O método “executar”, fica responsável por instanciar o gerador de pedidos, instanciar na sequência, as classes de etapas da geração do pedido, e de invocar o método “executar” do gerador, passando a propriedade privada “dados”.</li></ul><p>Veja como deixamos, com este intermediário, o “client” mais enxuto, e sem a responsabilidade de configurar o funcionamento da geração do pedido!</p><p>Enquanto o padrão “<strong>Command</strong>” propõe atomizar subtarefas de uma ação em um caso de uso, o padrão “<strong>Facade</strong>” tem por objetivo permitir a atomização desta preparação entre o client e este caso de uso.</p><blockquote><strong>*</strong> Muito embora no artigo sobre o padrão “Composite”, nós alteramos a gestão de itens do pedido, criando uma classe que encapsularia informações e ações relacionadas a itens deste pedido, neste caso eu tomei como base a solução do padrão “Observer”, que ainda não contava com esta alteração. Didaticamente, não há diferenças entre as 2 versões, no que se refere à implementação do código utilizando este padrão.</blockquote><h3>Indicações</h3><p>Este padrão atenderá você nas seguintes situações:</p><ul><li><strong>Quando se faz necessário uma interface (camada) limitada porém simples para um subsistema complexo:</strong> Frequentemente, subsistemas ficam mais complexos ao longo do tempo. Um subsistema pode se tornar mais flexível e fácil de se reutilizar em vários contextos, mas a quantidade de configurações e código duplicado que isso demanda à um ou mais “clients” cresce sempre. O <strong>Facade</strong> tenta corrigir este problema, providenciando um atalho para armazenar as implementações mais utilizadas do subsistema que atenda melhor aos requisitos do client;</li><li><strong>Quando você deseja estruturar subsistemas em camadas:</strong> Crie <strong>Facades</strong> para definir pontos de entrada para cada nível de um subsistema. Pode-se assim diminuir acoplamento entre múltiplos subsistemas requisitando-os para se comunicar somente entre fachadas. Veja como só precisamos passar os dados do cliente, valor e quantidade do pedidos para a classe de Facade, e à partir dali ela foi capaz de acionar e tratar o caso de uso!</li></ul><h3>Prós e contras</h3><p>A vantagem deste padrão é que assim podemos isolar nosso código da complexidade de um subsistema.</p><p>Contudo, devemos ter cuidado com a classe de <strong>Facade</strong>, para que ela não se torne um objeto centralizador acoplado a todas as classes de uma aplicação. Considere a possibilidade de extrair parte de seu comportamento para classes de Facades mais especializadas, se ela ficar muito grande.</p><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6edf725ac08d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Estrutural Composite (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-composite-s%C3%A9rie-design-patterns-f0946a2b3f90?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0946a2b3f90</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[composite]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[structural-patterns]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 02 Sep 2023 23:34:16 GMT</pubDate>
            <atom:updated>2023-09-02T23:34:16.052Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*dxvsM-SJ0C7qX16Ry9s-XQ.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/composite">https://refactoring.guru/design-patterns/composite</a></figcaption></figure><p>Olá caro seguidor!</p><p>Neste artigo, seguiremos com uma nova demanda em nosso sistema de orçamentos, e para implementar esta funcionalidade, faremos uso do padrão estrutural <strong>Composite </strong>(também chamado de “Object tree”, ou “Árvore de Objetos”), à partir do código que implementamos no artigo sobre o padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-decorators-s%C3%A9rie-design-patterns-d87e58c4460c">Decorator</a>”.</p><p>Nosso artigo está estruturado desta forma:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações da implementação crua desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>Uma nova demanda nos foi solicitada pelo time comercial para o sistema de orçamentos. Acontece que, nosso sistema finaliza um orçamento reprovado, e caso um novo orçamento seja feito para este mesmo cliente, ele precisa ser refeito do “zero”, incluindo novamente os itens do orçamento anteriormente reprovado e mais os itens que do atual orçamento, para submete-lo a aprovação.</p><p>O time comercial solicitou a possibilidade de “reaproveitar” o orçamento reprovado, para que a elaboração de orçamentos fique mais rápida, fazendo assim com que pedidos sejam feitos com mais praticidade para o cliente, agilizando o processo de venda.</p><h3>O desenvolvimento cru da solução</h3><p>Para este artigo, prosseguirei com a solução apresentada no padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-decorators-s%C3%A9rie-design-patterns-d87e58c4460c">Decorator</a>”.</p><p>Mas antes, vou fazer uma breve alteração (que não tem a ver com o padrão, mas que faz com que o código fique mais coeso) na nossa estrutura da classe Orçamentos: criarei uma classe “ItemOrcamento” para isolar os dados referentes aos itens do orçamento.</p><p>A nova estrutura antes de começarmos ficará assim à partir de agora:</p><p>Class <em>ItemOrcamento.java</em></p><pre>package composite.raw;<br><br>import java.math.BigDecimal;<br><br>public class ItemOrcamento {<br><br>    private BigDecimal valor;<br><br>    public ItemOrcamento(BigDecimal valor) {<br>        this.valor = valor;<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br>}</pre><p>Para facilitar as coisas e exemplificar o conceito, o item de um orçamento conta apenas com o valor deste item (mas considere em sua implementação um item com código de produto, valor unitário, se ele teve desconto, quantidade, sku etc…)</p><p>Classe <em>Orcamento.java</em></p><pre>package composite.raw;<br><br>import composite.raw.statuses.EmAnalise;<br>import composite.raw.statuses.Finalizado;<br>import composite.raw.statuses.Status;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.List;<br><br>public class Orcamento {<br><br>    private BigDecimal valor;<br>    private List&lt;ItemOrcamento&gt; itens;<br>    private Status status;<br><br>    public Orcamento() {<br>        this.valor = BigDecimal.ZERO;<br>        this.itens = new ArrayList&lt;&gt;();<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.itens.size();<br>    }<br><br>    public boolean isFinalizado() {<br>        return this.status instanceof Finalizado;<br>    }<br><br>    public void adicionarItem(ItemOrcamento item) {<br>        this.valor = this.valor.add(item.getValor());<br>        this.itens.add(item);<br>    }<br>}</pre><p>O que mudamos nesta classe?</p><ol><li>A propriedade do tipo “int” que armazenava a quantidade de itens foi substituída por uma Lista de “ItemOrcamento”, que armazena uma lista de itens, como o próprio nome sugere;</li><li>O construtor da classe Orcamento perdeu todos os parâmetros de inicialização, e agora inicia a propriedade Status com uma instância da classe “EmAnalise” (como antes), o valor do orçamento zerado (como antes) e a lista de itens zerada;</li><li>O método “getQuantidadeItens” retorna o tamanho atual da lista de itens;</li><li>Um novo método foi criado, para que através dele, um item possa ser inserido na lista, que é o “adicionarItem”;</li></ol><p>Classe <em>Main.java</em></p><pre>package composite.raw;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Orcamento antigo = new Orcamento();<br>        antigo.adicionarItem(new ItemOrcamento(new BigDecimal(&quot;200&quot;)));<br>        antigo.reprovar();<br><br>        Orcamento novo = new Orcamento();<br>        novo.adicionarItem(new ItemOrcamento(new BigDecimal(&quot;500&quot;)));<br><br>        CalculadoraDeImpostos calculadora = new CalculadoraDeImpostos();<br>        System.out.println(calculadora.calcular(novo, new ISS(<br>                                                            new ICMS(<br>                                                                    null // ou new IPI()<br>                                                            )<br>        )));<br>    }<br>}</pre><p>A classe Main (que é o nosso client), tem um orçamento (que chamamos de antigo), onde nele adicionamos um item de R$200,00, e o reprovamos.</p><p>Em seguida, criamos um novo orçamento (chamado sugestivamente de “novo”), onde adicionamos um novo item, desta vez de R$500,00.</p><p>A calculadora de impostos e a impressão do resultado deste cálculo neste exemplo é irrelevante, mas deixei para exemplificar o fluxo da criação do orçamento.</p><h3>Problemas</h3><p>À partir da classe Main, você consegue pensar em uma forma de “reaproveitar” o orçamento anteriormente reprovado?</p><p>Veja que da forma como implementamos a adição de itens no orçamento, somente os itens do orçamento é que são admitidos nesta ação.</p><p>Como podemos resolver este problema através de código, sem que dupliquemos implementação ou criemos uma propriedade do tipo “Orcamento” dentro de nossa classe “Orcamento”, gerando uma redundância que engessará esta classe?</p><h3>A solução</h3><p>O padrão “<strong>Composite</strong>” nos sugere uma abordagem (já vista no padrão “Decorator”) para que possamos contornar este problema.</p><p>Através de uma interface, eu posso garantir que tanto Orcamento quanto Item possam ser aceitos como um item “orçável”, e assim reaproveitar os itens de um orçamento previamente realizado.</p><p>Vejamos como ficaria a estrutura de classes/interfaces:</p><p>Interface <em>Orcavel.java</em></p><pre>package composite.solution;<br><br>import java.math.BigDecimal;<br><br>public interface Orcavel {<br>    BigDecimal getValor();<br>}</pre><p>A interface neste caso apenas exige que um objeto que fala as vezes de um orçamento ou de um item implemente seu próprio método de retorno do valor (através do método “getValor”).</p><p>Classe <em>ItemOrcamento.java</em></p><pre>package composite.solution;<br><br>import java.math.BigDecimal;<br><br>public class ItemOrcamento implements Orcavel {<br><br>    private BigDecimal valor;<br><br>    public ItemOrcamento(BigDecimal valor) {<br>        this.valor = valor;<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br>}</pre><p>A mesma classe ItemOrcamento que criamos sem o padrão, mas agora implementando a interface e retornando o valor dos itens, através do método getValor.</p><p>Classe <em>Orcamento.java</em></p><pre>package composite.solution;<br><br><br>import composite.solution.statuses.EmAnalise;<br>import composite.solution.statuses.Finalizado;<br>import composite.solution.statuses.Status;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.List;<br><br>public class Orcamento implements Orcavel {<br><br>    private BigDecimal valor;<br>    private List&lt;Orcavel&gt; itens;<br>    private Status status;<br><br>    public Orcamento() {<br>        this.valor = BigDecimal.ZERO;<br>        this.itens = new ArrayList&lt;&gt;();<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.itens.size();<br>    }<br><br>    public boolean isFinalizado() {<br>        return this.status instanceof Finalizado;<br>    }<br><br>    public void adicionarItem(Orcavel item) {<br>        this.valor = this.valor.add(item.getValor());<br>        this.itens.add(item);<br>    }<br>}</pre><p>Idem, com as devidas adequações (a declaração da propriedade itens agora espera uma lista de “Orcavel”, e o método de adicionarItem admite qualquer implementação da interface “Orcavel”).</p><p>Ela já tinha implementado um método “getValor”, e isso se manteve assim.</p><p>Classe <em>Main.java</em></p><pre>package composite.solution;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Orcamento antigo = new Orcamento();<br>        antigo.adicionarItem(new ItemOrcamento(new BigDecimal(&quot;200&quot;)));<br>        antigo.reprovar();<br><br>        Orcamento novo = new Orcamento();<br>        novo.adicionarItem(new ItemOrcamento(new BigDecimal(&quot;500&quot;)));<br>        novo.adicionarItem(antigo);<br><br>        System.out.println(novo.getValor()); // 700<br>    }<br>}</pre><p>Perceba que no nosso “client”, com estas alterações, pudemos acionar o método “adicionarItem” do objeto “novo”, e passar nele tanto um item novo para este orçamento quanto um orçamento antigo!</p><p>A invocação do método “getValor” do objeto “novo”, na última linha do método estático “main”, imprime o valor do orçamento, que já soma o item inserido com o valor de R$500,00, bem como o item inserido no orçamento cujo objeto está no código como “antigo”.</p><p>Pode parecer meio sem sentido, do ponto de vista metafísico, considerar “Orçamento” e “ItemOrcamento” como iguais, uma vez que as classes possuem finalidades e estruturas distintas, sem contar que um Orcamento abriga 1:N ItemOrcamento, e o oposto não é verdadeiro. Neste caso, fique a vontade para imaginar que a classe Orcamento poderia ter uma implementação adequada (um método, uma classe criada só para este fim, etc) para absorver os dados do objeto “ItemOrcamento” (se ele tivesse valores como quantidade, preço, código do produto etc) de um “Orcamento” adicionado e faria os devidos tratamentos neste objeto para normalizar o “orçamento”.</p><h3>Indicações</h3><p>Este padrão se mostra útil nas seguintes situações:</p><ul><li><strong>Quando você precisar implementar uma estrutura, onde um objeto tenha uma estrutura similar a uma árvore</strong>: Este padrão provê dois tipos básicos de elementos que compartilham uma interface única. O elemento pode ser uma “simples folha”, ou um “galho com várias folhas” (ou um galho com vários galhos e folhas também, de maneira aninhada). Assim é possível construir uma estrutura recursiva que se assemelha à a estrutura de uma árvore;</li><li><strong>Quando você deseja que o “client” trate os elementos simples ou aninhados de maneira uniforme: </strong>Como o padrão compartilha uma interface comum, o “client” que instanciar este objeto não deve se preocupar com o funcionamento da classe concreta deste objeto;</li></ul><h3>Prós e contras</h3><p>Vantagens deste padrão:</p><ul><li>Pode-se trabalhar com complexas estruturas em árvove de maneira mais conveniente. Use o polimorfismo e recursão a seu favor!</li><li><strong>Aplicação prática da letra “O” dos princípios SOLID (Open/Closed Principle):</strong> Você pode introduzir novos tipos de elementos na aplicação sem quebrar o código existente, que agora dispõe de uma estrutura hierárquica;</li></ul><p><strong>Mas cuidado!</strong> Pode ser difícil prover uma interface comum à classes cujas funcionalidades diferem demais. Em alguns cenários, você pode ser forçado a fazer uma super-generalização da interface, deixando-a difícil de ser compreendida quanto à sua natureza.</p><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0946a2b3f90" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Estrutural Decorators (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-decorators-s%C3%A9rie-design-patterns-d87e58c4460c?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/d87e58c4460c</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[decorators]]></category>
            <category><![CDATA[structural-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sun, 13 Aug 2023 23:49:08 GMT</pubDate>
            <atom:updated>2023-08-13T23:49:08.761Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*hyof9e7Vbfa86x3xv0ZgPw.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/decorator">https://refactoring.guru/design-patterns/decorator</a></figcaption></figure><p>Olá caro seguidor!</p><p>Neste artigo, seguiremos com mais um incremento em nosso fluxo de orçamentos, e para implementar esta funcionalidade, faremos uso do padrão estrutural <strong>Decorators </strong>(também chamado de “Wrappers”), à partir do código que implementamos no artigo sobre o padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-adapter-s%C3%A9rie-design-patterns-a3c5a26593ea">Adapter</a>”.</p><p>Nosso artigo está estruturado desta forma:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações da implementação crua desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>Como disse no início deste artigo, um novo incremento nos foi solicitado para a gestão de orçamentos. Desta vez, o departamento fiscal nos informou que uma mudança na legislação tributária estadual, fez com que agora, mais de um tipo de imposto diferente fosse cobrado em um mesmo orçamento. Lembre-se que, no padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-strategy-s%C3%A9rie-design-patterns-70fa24a2eff5">Strategy</a>”, havíamos implementado um mecanismo que incidia imposto(s) em um orçamento, mas que era apenas um único tributo por orçamento. Agora precisamos flexibilizar o sistema para incidir 2 ou mais impostos neste.</p><h3>O desenvolvimento cru da solução</h3><p>Neste exemplo, vou resgatar a nossa interface de Imposto, uma das classes que implementam esta interface, e nossa calculadora de impostos, que em outros artigos estávamos usando-a para calcular a alíquota de nossos orçamentos:</p><p>Interface <em>Imposto.java</em></p><pre>package decorators.raw;<br><br>import java.math.BigDecimal;<br><br>public interface Imposto {<br>    BigDecimal calcular(Orcamento orcamento);<br>}</pre><p>Neste exemplo, ela tem apenas um método “calcular”, que exige um objeto do tipo Orcamento e retorna um valor do tipo BigDecimal</p><p>Classe ICMS.java</p><pre>package decorators.raw;<br><br>import java.math.BigDecimal;<br>public class ICMS implements Imposto {<br>    public BigDecimal calcular(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.1&quot;));<br>    }<br>}</pre><p>Exemplo de uma classe que implementa esta interface.</p><p>Classe <em>CalculadoraDeImpostos.java</em></p><pre>package decorators.raw;<br><br>import java.math.BigDecimal;<br>public class CalculadoraDeImpostos {<br>    public BigDecimal calcular(Orcamento orcamento, Imposto imposto) {<br>        return imposto.calcular(orcamento);<br>    }<br>}</pre><p>Esta não sofrerá alterações neste padrão. Trouxe-a apenas para relembrarmos de sua finalidade e funcionamento.</p><p>Ela calcula o valor do imposto de um orçamento, à partir da implementação do método “calcular” da interface “Imposto”. Note que nesta construção, a calculadora realiza o cálculo de apenas um único tributo (a classe que implementa a interface “Imposto”).</p><p>Acontece que precisamos aplicar o cálculo de mais um (ou vários) imposto(s) nos orçamentos à partir de agora. E para isso temos 2 caminhos:</p><ol><li>Realizar a instância da calculadora uma vez, criar no “client” uma variável que armazenará o resultado dos cálculos, e para cada imposto, invocar a calculadora passando uma instância da classe que calcula a alíquota referente a este imposto, e soma-las nesta variável (isso tornaria o “client” um pouco disperso, não acha?)</li><li>Criar classes que combinem os impostos a serem incididos. Por exemplo: Se o sistema precisa calcular em um orçamento a alíquota combinada dos tributos ISS e ICMS, poderíamos criar uma classe como no exemplo abaixo:</li></ol><p>Classe <em>ICMSComISS.java</em></p><pre>package decorators.raw;<br><br>import java.math.BigDecimal;<br><br>public class ICMSComISS implements Imposto {<br>    @Override<br>    public BigDecimal calcular(Orcamento orcamento) {<br>        BigDecimal icms = new ICMS().calcular(orcamento);<br>        BigDecimal iss = new ISS().calcular(orcamento);<br><br>        return icms.add(iss);<br>    }<br>}</pre><p>Trata-se de uma tentativa de aglutinar os cálculos de impostos. A estratégia neste caso consiste em criar classes que combinam os tributos.</p><h3>Problemas</h3><p>Mas… e se futuramente o orçamento precisar prever a alíquota de IPI? Eu teria que criar uma classe chamada ICMSComISSeIPI? E se depois desta implementação, o governo decide não cobrar mais ISS, eu deveria criar uma classe chamada ICMSComIPI? Se a quantidade de tributos aumentar e for necessário fazer combinações distintas de impostos para cada categoria de produto/serviço, eu teria que criar uma classe para cada combinação? Parece razoável esta estratégia?</p><h3>A solução</h3><p>Podemos pensar em uma abordagem onde podemos passar a quantidade de impostos (classes) que precisarmos sem que isso tenha impacto em nosso sistema atual.</p><p>Para isso, podemos utilizar o padrão “<strong>Decorator</strong>”, e aplicar as seguintes mudanças:</p><p>Classe <em>Imposto.java</em></p><pre>package decorators.solution;<br><br>import java.math.BigDecimal;<br><br>public abstract class Imposto {<br>    private Imposto outroImposto;<br><br>    public Imposto(Imposto imposto) {<br>        this.outroImposto = imposto;<br>    }<br><br>    protected abstract BigDecimal realizarCalculo(Orcamento orcamento);<br>    public BigDecimal calcular(Orcamento orcamento) {<br>        BigDecimal valorImposto = realizarCalculo(orcamento);<br>        BigDecimal valorDoOutroImposto = BigDecimal.ZERO;<br><br>        if (outroImposto != null) {<br>            valorDoOutroImposto = outroImposto.realizarCalculo(orcamento);<br>        }<br>        return valorImposto.add(valorDoOutroImposto);<br>    }<br>}</pre><p>Outrora, Imposto era uma interface que exigia apenas a implementação do método calcular. Agora ela passa a ser uma classe abstrata, com as seguintes características:</p><ul><li>Ela armazena em uma propriedade privada um objeto que seja do seu próprio tipo (entenderemos futuramente seu propósito);</li><li>Um método construtor foi criado para atribuir a esta propriedade um valor;</li><li>O método “calcular” que era exigido na interface, agora virou um método que agora aglutina o cálculo do valor do imposto atual, e do “outro imposto” (se existir), que é informado durante seu instanciamento (veremos isso acontecendo em breve);</li><li>Um novo método, abstrato, chamado “realizarCalculo” passa a ter sua implementação delegada para as subclasses (classes de impostos que a extenderão)</li></ul><p>Classe <em>ICMS.java</em></p><pre>package decorators.solution;<br><br>import java.math.BigDecimal;<br><br>public class ICMS extends Imposto {<br><br>    public ICMS(Imposto imposto) {<br>        super(imposto);<br>    }<br><br>    public BigDecimal realizarCalculo(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.1&quot;));<br>    }<br><br>}</pre><p>A classe ICMS.java, que realiza os cálculos de alíquota inerentes ao imposto homômimo, agora <strong>extende </strong>ao invés de <strong>implementar </strong>Imposto.</p><p>Seu método construtor passa via parâmetro, um objeto do tipo Imposto (que veremos em frente do que se trata), à classe Imposto.</p><p>Além disso, ela implementa o método “realizarCalculo” (que era o método calcular anteriormente).</p><p>Classe ISS.java</p><pre>package decorators.solution;<br><br>import java.math.BigDecimal;<br><br>public class ISS extends Imposto {<br><br>    public ISS(Imposto imposto) {<br>        super(imposto);<br>    }<br><br>    public BigDecimal realizarCalculo(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.06&quot;));<br>    }<br>}</pre><p>Idem.</p><p>Demais classes que calculam alíquotas de impostos deverão seguir este padrão à partir de agora.</p><p>Classe Main.java</p><pre>package decorators.solution;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Orcamento orcamento = new Orcamento(new BigDecimal(&quot;100&quot;), 1);<br><br>        CalculadoraDeImpostos calculadora = new CalculadoraDeImpostos();<br>        System.out.println(calculadora.calcular(orcamento, new ISS(<br>                                                            new ICMS(<br>                                                                    null // new IPI()<br>                                                            )<br>        )));<br>    }<br>}</pre><p>É aqui que as coisas acontecem.</p><p>Veja que criamos no “client” o orçamento, instanciamos a calculadora, e invocamos o método calcular da calculadora.</p><p>A diferença é no que eu estou passando como instância do tipo “imposto”!</p><p>Lembra do “outroImposto” da classe abstrata Imposto? Lembra do construtor das subclasses que agora precisam informar um objeto do tipo “imposto” para o construtor da classe principal?</p><p>Pois bem, a alteração que fizemos permite que eu encadeie (como no padrão “Chain of responsibility”) instâncias dentro de instâncias dos impostos que eu quiser calcular agora (neste exemplo, o ICMS é o “outro imposto” do ISS, e que poderia ter outros impostos aninhados ou “null”, para encerrar a cadeia.</p><p>E isso sem alterar a calculadora!</p><h3>Indicações</h3><p>Este padrão se mostra útil nas seguintes situações:</p><ul><li><strong>Quando você precisar de um meio para incluir comportamentos extras a objetos em runtime sem quebrar o código que usa estes objetos</strong>: O padrão permite que você estruture sua lógica de negócio em camadas, criar um “decorator” para cada camada e compor objetos com várias combinações desta lógica em runtime (lembra da propriedade outroImposto da classe Imposto?). O código do “client” pode tratar estes objetos da mesma forma desde que todos eles sigam uma interface comum (lembra como encadeamos instâncias de impostos na classe Main?)</li><li><strong>Quando não for possível extender um comportamento de um objeto usando herança, ou quando até for possível mas não parecer uma idéia cômoda: </strong>Muitas linguagens de programação tem a palavra chave “<strong>final</strong>” que pode ser utilizada para prevenir possíveis extensões de uma classe. Para uma classe final, a única forma de reutilizar o comportamento existente seria envolver a classe com seu próprio “empacotador” (neste exemplo, a classe abstrata Imposto), usando o padrão Decorator.</li></ul><h3>Prós e contras</h3><p>Vantagens deste padrão:</p><ul><li>Pode-se extender um comportamento de um objeto sem criar uma subclasse (através de composição);</li><li>Pode-se adicionar ou remover responsabilidades de um objeto em runtime;</li><li>Pode-se combinar vários comportamentos envolvendo um objeto em vários “decorators”;</li><li><strong>Aplicação prática da letra “S” dos princípios SOLID (Single Responsibility Principle):</strong> Pode-se dividir uma classe monolítica que implementa várias possíveis variantes de comportamento em várias classes menores, com responsabilidades únicas;</li></ul><p>Ressalvas quanto a esta abordagem:</p><ul><li>É dificil remover um “empacotador” específico da pilha de “empacotadores”;</li><li>É díficil implementar um “decorator” de uma forma tal que seu comportamento não dependa da ordem da pilha de “decorators”;</li><li>A configuração inicial de código das camadas podem parecer um pouco feias;</li></ul><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d87e58c4460c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Estrutural Adapter (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-estrutural-adapter-s%C3%A9rie-design-patterns-a3c5a26593ea?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/a3c5a26593ea</guid>
            <category><![CDATA[adapter-design-pattern]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[structural-design-pattern]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 05 Aug 2023 19:16:06 GMT</pubDate>
            <atom:updated>2023-08-05T19:16:06.472Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*uMLUCtCQRW6gADkOEGgDzA.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/adapter">https://refactoring.guru/design-patterns/adapter</a></figcaption></figure><p>Olá caro seguidor!</p><p>Neste artigo, implementaremos uma nova funcionalidade em nosso fluxo de orçamentos, e para implementar esta funcionalidade, faremos uso do padrão estrutural <strong>Adapter</strong>, à partir do código que implementamos no artigo sobre o padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-observer-s%C3%A9rie-design-patterns-44fee3ef30a7">Observer</a>”.</p><p>Nosso artigo está estruturado desta forma:</p><ul><li><strong>O cenário:</strong> a situação hipotética;</li><li><strong>O desenvolvimento cru da solução:</strong> implementação básica do código para atender à nova demanda;</li><li><strong>Problemas:</strong> as implicações da implementação crua desta solução;</li><li><strong>A solução:</strong> a apresentação da abordagem;</li><li><strong>Indicações:</strong> que tipo de problemas este padrão visa solucionar;</li><li><strong>Prós e contras:</strong> Vantagens e desvantagens desta abordagem;</li></ul><h3>O Cenário</h3><p>No início deste artigo, eu disse que uma nova funcionalidade em “nosso fluxo de orçamentos nos foi solicitada pelo departamento de marketing”. A demanda que “chegou ao time” foi:</p><blockquote>“Quando um orçamento for finalizado, precisamos enviar as informações deste para um CRM (hubspot ou salesforce, por exemplo), pois trata-se de um insumo para métricas que contribuirão para melhores decisões estratégicas do time de marketing, comercial etc…”.</blockquote><h3>O desenvolvimento cru da solução</h3><p>Por se tratar de uma demanda voltada ao orçamento, e não a pedidos, vamos atuar neste artigo apenas nas classes Orcamento, Main (classe “client”, para testar a implementação), e uma classe nova que fará esta integração com o serviço externo:</p><p>Classe <em>Orcamento.java</em></p><pre>package adapter.solution;<br><br>import adapter.solution.statuses.EmAnalise;<br>import adapter.solution.statuses.Finalizado;<br>import adapter.solution.statuses.Status;<br><br>import java.math.BigDecimal;<br><br>public class Orcamento {<br><br>    private BigDecimal valor;<br>    private int quantidadeItens;<br>    private Status status;<br><br>    public Orcamento(BigDecimal valor, int quantidadeItens) {<br>        this.valor = valor;<br>        this.quantidadeItens = quantidadeItens;<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.quantidadeItens;<br>    }<br><br>    public boolean isFinalizado() {<br>        return this.status instanceof Finalizado;<br>    }<br>}</pre><p>Na verdade, só estou incluindo esta classe neste artigo porque tomei a liberdade de implementar um método que valida se o orçamento foi finalizado. Este método não tem a ver com este padrão (os <em>stati </em>deste orçamento foram implementados no artigo que aborda o padrão “State”, que pode ser consultado clicando <a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-state-s%C3%A9rie-design-patterns-20b7571d1c50">aqui</a>.)</p><p>Classe <em>Main.java</em></p><pre>package adapter.raw;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        Orcamento orcamento = new Orcamento(BigDecimal.TEN, 1);<br>        orcamento.aprovar();<br>        orcamento.finalizar();<br><br>        //Implementação do adapter que fará a conexão HTTP com o serviço externo<br>        RegistroDeOrcamento registro = new RegistroDeOrcamento();<br>        registro.registrar(orcamento);<br>    }<br>}</pre><p>Um “client” básico.</p><p>Instância de um novo orçamento de R$10,00 com 1 item.</p><p>Orçamento aprovado. Orçamento finalizado.</p><p>Instanciamento da classe que é responsável pelo Registro deste orçamento no serviço externo e subsequente registro do orçamento.</p><p>Classe <em>RegistroDeOrcamento.java</em></p><pre>package adapter.raw;<br><br>public class RegistroDeOrcamento {<br><br>    public void registrar(Orcamento orcamento) {<br>        if (!orcamento.isFinalizado()) {<br>            throw new RuntimeException(&quot;Orçamento não finalizado!&quot;);<br>        }<br>        System.out.println(&quot;Instanciando a classe da biblioteca HttpClient para fazer a conexão HTTP com o serviço externo&quot;);<br>        System.out.println(&quot;Definindo configurações para a conexão&quot;);<br>        System.out.println(&quot;Preparando o payload para o envio do conteúdo&quot;);<br>        System.out.println(&quot;Enviando o payload para o serviço externo&quot;);<br>        System.out.println(&quot;Tratando o retorno e possíveis erros de conexão&quot;);<br>    }<br>}</pre><p>O método “registrar” é responsável por realizar as seguintes tarefas:</p><ul><li>Validar se o orçamento foi finalizado;</li><li>Instanciar uma implementação concreta da classe de client HTTP (neste exemplo, a HttpClient;</li><li>Definir as configurações necessárias para esta conexão;</li><li>Preparar o payload para atender os requisitos mínimos para o serviço externo;</li><li>Enviar o payload para este serviço;</li><li>Tratar retornos (erros e status);</li></ul><h3>Problemas</h3><p>Percebe-se que esta classe está se responsabilizando por ações inerentes à regras de negócio (validações e preparo de conteúdo) e infraestrutura (instanciamento e configuração de biblioteca para conexão HTTP), quando idealmente ele deveria cuidar de uma coisa apenas (Letra “S”, <em>Single Responsibility</em>, dos princípios SOLID).</p><p>Além disso, estamos realizando uma instância de uma implementação concreta de uma biblioteca de conexão HTTP. E se por acaso futuramente houver a necessidade de trocar de biblioteca de conexão, por alguma falha de segurança detectada, ou quando o mantenedor desta biblioteca não oferecer mais suportes ou outros problemas surgirem? Eu terei que alterar a implementação deste método, correndo o risco de “quebrar” o que estava funcionando?</p><h3>A solução</h3><p>O padrão Adapter nos permite criar uma forma de atender à nossa demanda, usando algum mecanismo externo, independente da forma como este mecanismo realiza as ações necessárias para atingir este objetivo (por exemplo: um conector USB Type-C, que precisa se conectar a um dispositivo cuja entrada seja USB Micro, e para isso preciso de um elemento intermediário que receba o input Type-C e conecte ao output Micro, tornando possível a conexão em um dispositivo cujo input seja USB micro).</p><p>Para tal, definiremos um “contrato” para que os adaptadores (qualquer classe que seja responsável por realizar a comunicação HTTP com o serviço externo) estejam aptos a atender as necessidades do demandante (classe RegistroDeOrcamento):</p><p>Interface <em>HttpAdapter.java</em></p><pre>package adapter.solution.http;<br><br>import java.util.Map;<br><br>public interface HttpAdapter {<br>    void post(String url, Map&lt;String,Object&gt; dados);<br>}</pre><p>Tomei a liberdade de colocar ele em um pacote separado, chamado “http”, para esta finalidade.</p><p>Note que ele tem um método (neste exemplo apenas um método), chamado “post”, e que deve receber uma url (string) e os dados (um Map com uma chave em string e o valor em qualquer formato).</p><p>Isso significa que qualquer adaptador de conexão com este serviço externo, precisa ter este método com esta assinatura!</p><p>Classe <em>RegistroDeOrcamento.java</em></p><pre>package adapter.solution;<br><br>import adapter.solution.http.HttpAdapter;<br><br>import java.util.Map;<br><br>public class RegistroDeOrcamento {<br>    private HttpAdapter http;<br><br>    public RegistroDeOrcamento(HttpAdapter http) {<br>        this.http = http;<br>    }<br>    public void registrar(Orcamento orcamento) {<br>        if (!orcamento.isFinalizado()) {<br>            throw new RuntimeException(&quot;Orçamento não finalizado!&quot;);<br>        }<br>        String url = &quot;http://url.ficticia&quot;;<br>        Map&lt;String, Object&gt; dados = Map.of(<br>                &quot;valor&quot;, orcamento.getValor(),<br>                &quot;quantidadeItens&quot;, orcamento.getQuantidadeItens()<br>        );<br>        http.post(url, dados);<br>    }<br>}</pre><p>A classe agora possui uma propriedade que armazena um objeto de uma classe que implementa este contrato, e através de injeção de dependência, ela recebe uma instância deste tipo.</p><p>O método “registrar”, faz a validação para saber se o pedido foi finalizado, prepara os dados necessários para a conexão (a url e os dados), e invoca o método “post” da própria classe, passando estes dados.</p><p>Observe que desta forma, não interessa à esta classe qual biblioteca está sendo utilizada para esta conexão HTTP, pois esta responsabilidade agora pertence à outra classe, que será delegada pelo “client”, como pode ser visto logo abaixo:</p><p>Classe <em>Main.java</em></p><pre>package adapter.solution;<br><br>import adapter.solution.http.HttpAdapter;<br>import adapter.solution.http.JavaHttpClient;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        Orcamento orcamento = new Orcamento(BigDecimal.TEN, 1);<br>        orcamento.aprovar();<br>        orcamento.finalizar();<br><br>        //Implementação do adapter que fará a conexão HTTP com o serviço externo<br>        HttpAdapter client = new JavaHttpClient();<br>        RegistroDeOrcamento registro = new RegistroDeOrcamento(client);<br>        registro.registrar(orcamento);<br>    }<br>}</pre><p>O client desta vez, instancia uma implementação concreta de um adaptador criado para este fim (neste exemplo a classe javaHttpClient, explanada logo mais), injeta este objeto no construtor da classe RegistroDeOrcamento, e invoca finalmente seu método “registrar”, passando como parâmetro o orçamento.</p><p>Abaixo segue a classe “adaptadora”, responsável por realizar a conexão HTTP com o serviço externo:</p><p>Classe <em>JavaHttpClient.java</em></p><pre>package adapter.solution.http;<br><br>import java.util.Map;<br><br>public class JavaHttpClient implements HttpAdapter {<br>    @Override<br>    public void post(String url, Map&lt;String, Object&gt; dados) {<br>        System.out.println(&quot;Conectando via HttpClient à URL &quot; + url + &quot;...&quot;);<br>    }<br>}</pre><p>A classe implementa a interface HttpAdapter como esperado, e implementa o método “post”, de acordo com a assinatura esperada.</p><p>Substitua este “sysout” por toda a implementação de instanciação da classe concreta da biblioteca HttpClient, configurações inerentes a esta biblioteca, envio da requisição e tratamento de retornos de erro. É neste ponto mesmo que elas implementações devem ficar.</p><p>Mas… e se eu precisar trocar de biblioteca de conexão Http de HttpCliente pela HttpComponents do Apache, por exemplo?</p><p>Simples: na classe Main.java, substitua a linha de:</p><pre>HttpAdapter client = new JavaHttpClient();</pre><p>Para:</p><pre>HttpAdapter client = new HttpComponentsClient();</pre><p>E implemente esta classe desta forma:</p><p>Classe <em>HttpComponentsCliente.java</em></p><pre>package adapter.solution.http;<br><br>import java.util.Map;<br><br>public class HttpComponentsClient implements HttpAdapter  {<br>    @Override<br>    public void post(String url, Map&lt;String, Object&gt; dados) {<br>        System.out.println(&quot;Conectando via Apache HttpComponents à URL &quot; + url + &quot;...&quot;);<br>    }<br>}</pre><p>Neste caso, considere que este “sysout” seja toda a implementação de instanciamento da classe concreta da biblioteca HttpComponents da Apache, configurações inerentes a esta biblioteca, envio da requisição e tratamento de retornos de erros.</p><p>OK… Mas e se eu precisar substituir o HttpClient por outra biblioteca, como a OkHttpClient?</p><p>Simples: assim como a substituição pela classe HttpComponentsClient, você pode substituir, na classe Main.java, a linha de:</p><pre>HttpAdapter client = new JavaHttpClient();</pre><p>Para:</p><pre>HttpAdapter client = new OkHttpClient();</pre><p>E a classe OkHttpClient, implemente desta forma:</p><p>Classe <em>OkHttpClient.java</em></p><pre>package adapter.solution.http;<br><br>import java.util.Map;<br><br>public class OkHttpClient implements HttpAdapter {<br>    @Override<br>    public void post(String url, Map&lt;String, Object&gt; dados) {<br>        System.out.println(&quot;Conectando via OkHttpClient à URL &quot; + url + &quot;...&quot;);<br>    }<br>}</pre><p>Assim como nas demais classes que implementam HttpAdapter, listadas accima, substitua o “sysout”, pelas implementações e configurações necessárias para a conexão utilizando esta biblioteca.</p><p>Mas e se eu precisar me conectar utilizando a biblioteca WebClient da Spring?</p><p>Simples também!</p><p>Para isso, criamos a classe abaixo:</p><p>Classe <em>SpringWebClient.java</em></p><pre>package adapter.solution.http;<br><br>import java.util.Map;<br><br>public class SpringWebClient implements HttpAdapter {<br>    @Override<br>    public void post(String url, Map&lt;String, Object&gt; dados) {<br>        System.out.println(&quot;Conectando via Spring WebClient à URL &quot; + url + &quot;...&quot;);<br>    }<br>}</pre><p>E na classe Main.java, na linha que o objeto “client” é criado, instancia-se a classe SpringWebClient, substituindo a linha de:</p><pre>HttpAdapter client = new JavaHttpClient();</pre><p>Para:</p><pre>HttpAdapter client = new SpringWebClient();</pre><p>Veja como não importa qual biblioteca a governança de TI de sua empresa decida adotar para realizar esta tarefa, e quantas vezes ela decida trocar de biblioteca. Adotando esta abordagem, a implementação e chaveamento entre estes adaptadores fica simples e os impactos destas alterações são mínimos, já que a classe que representa a conexão de baixo nível com o serviço externo (o adaptador) está separada da classe responsável por fazer a preparação e integração entre serviços, além de cada adaptador poder livremente implementar e configurar sua forma de conexão de acordo com as necessidades de cada biblioteca.</p><h3>Indicações</h3><p>Este padrão se mostra útil nas seguintes situações:</p><ul><li><strong>Quando você quer usar alguma classe existente (uma biblioteca por exemplo), mas que a interface dela não é compatível com o resto de seu código</strong>: Este padrão permite que você crie uma camada intermediária que serve de “tradutor” entre seu código e um código legado, ou biblioteca de terceiros, ou qualquer outra classe com interfaces estranhas a seu sistema;</li><li><strong>Quando você quer reutilizar várias subclasses existentes que carecem de funcionalidades comuns e que não podem ser adicionadas em uma superclasse</strong>: Você poderia até extender cada subclasse e colocar as funcionalidades faltantes dentro de novas subclasses. Contudo, você precisará duplicar o código através de todas estas novas classes, o que só piora a manutenibilidade do código. Seria muito mais elegante colocar estas funções faltantes em uma classe adaptadora. Então você aglutinaria objetos com as funcionalidades faltantes dentro deste adaptador, ganhando as caracteristicas necessárias dinamicamente. Para isso dar certo, as classes alvo pecisam implementar uma interface comum, e o campo do adaptador precisa seguir esta interface (como se fosse um “Decorator”);</li></ul><h3>Prós e contras</h3><p>Vantagens desta abordagem:</p><ul><li><strong>Aplicação prática da letra “S” dos princípios SOLID (Single Responsibility Principle):</strong> Você pode separar a interface ou o “conversor” (no nosso caso, do conector HTTP) da regra de negócio primária (integração com serviço externo);</li><li><strong>Aplicação prática da letra “O” dos princípios SOLID (Open/Closed Principle):</strong> Cada adaptador a ser criado é uma classe nova, que pode ser introduzida ao sistema sem que classes que atualmente estão implementadas e estáveis sejam afetadas;</li></ul><p>Mas cuidado! Deve-se avaliar bem se é de fato necessário a separação destas responsabilidades, pois a complexidade geral do código aumenta na medida que você precisará introduzir uma série de novas interfaces e classes. Algumas vezes é mais simples apenas mudar a classe de serviço (no nosso exemplo, a RegistroDeOrcamento) para que a mudança se adeque ao resto do código.</p><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3c5a26593ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Comportamental Observer (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-observer-s%C3%A9rie-design-patterns-44fee3ef30a7?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/44fee3ef30a7</guid>
            <category><![CDATA[behavioral-design-pattern]]></category>
            <category><![CDATA[observer-design-pattern]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sun, 30 Jul 2023 19:40:45 GMT</pubDate>
            <atom:updated>2023-07-30T19:40:45.349Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*1m9ZIdfT7Pa1OyJQT-GvHQ.png" /><figcaption><a href="https://refactoring.guru/design-patterns/observer">https://refactoring.guru/design-patterns/observer</a></figcaption></figure><p>Olá caro seguidor!</p><p>Neste artigo complementaremos o código que estava sendo implementado no artigo sobre o padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-command-s%C3%A9rie-design-patterns-2db2367acbd9">Command</a>”, com algumas melhorias que o padrão “<strong>Observer</strong>” pode nos proporcionar, para mantermos a coesão de nosso handler, não importando a quantidade de etapas que nosso caso de uso precise comportar para gerar este nosso pedido.</p><p>Como padrão, esta é a estrutura deste artigo:</p><ul><li><strong>O Cenário</strong>: a situação hipotética, o problema a ser resolvido;</li><li><strong>O desenvolvimento da solução sem o padrão</strong>: implementação básica do código para resolver o problema;</li><li><strong>Problemas</strong>: as implicações da implementação sem o uso deste padrão;</li><li><strong>A solução</strong>: reestruturação do código segundo esta abordagem;</li><li><strong>Indicações</strong>: a que se destina este tipo de padrão;</li><li><strong>Prós e contras</strong> desta abordagem.</li></ul><h3>O cenário</h3><p>Prosseguindo ainda no nosso handler, paramos na parte onde o handler fica responsável por “orquestrar” as chamadas aos objetos/métodos de etapas a serem executadas para cumprir com a ação de gerar um pedido no sistema.</p><p>Recapitulando: Para que um pedido seja gerado à partir de um orçamento, tinhamos definido que as etapas necessárias eram (nesta ordem):</p><ul><li>Salvar no banco de dados;</li><li>Enviar email para o cliente confirmando o pedido e com os detalhes do mesmo;</li></ul><h3>O desenvolvimento da solução sem o padrão</h3><p>Abaixo segue o código, agora substituindo aqueles “<em>System.out.println’</em>s” que simulavam a implementação da etapa, por instanciamento de classes que as implementam e invocação dos respectivos métodos de execução.</p><p>Classe <em>main.java</em>:</p><pre>package observer.raw;<br><br>import java.math.BigDecimal;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        String cliente = args[0];<br>        BigDecimal valor = new BigDecimal(args[1]);<br>        int quantidade = Integer.parseInt(args[2]);<br><br>        GerarPedidoDados dados = new GerarPedidoDados(cliente, valor, quantidade);<br>        GerarPedidoHandler gerador = new GerarPedidoHandler(/*Dependências injetadas aqui*/);<br>        gerador.executar(dados);<br>    }<br>}</pre><p>O nosso “client”, que neste exemplo está representado pela classe Main, recebe via parâmetros o nome do cliente, o valor do pedido e a quantidade de itens, cria um objeto que amazena estes dados, um handler responsável por gerar pedidos, e por fim o método “executar” deste handler, passando como parâmetro, o objeto com os dados do pedido.</p><p>Classe <em>GerarPedidoHandler.java</em></p><pre>package observer.raw;<br><br>import java.time.LocalDateTime;<br><br>public class GerarPedidoHandler {<br><br>    //construtor com injeção de dependências: repositories, services etc...<br><br>    public void executar(GerarPedidoDados dados) {<br>        Orcamento orcamento = new Orcamento(dados.getValorOrcamento(), dados.getQuantidadeItens());<br><br>        Pedido pedido = new Pedido(dados.getCliente(), LocalDateTime.now(), orcamento);<br><br>        SalvarPedidoNoBancoDeDados salvar = new SalvarPedidoNoBancoDeDados();<br>        EnviarEmailPedido enviar = new EnviarEmailPedido();<br><br>        salvar.executar(pedido);<br>        enviar.executar(pedido);<br>        //System.out.println(&quot;Salvar pedido no banco de dados&quot;); // Que pode ser substituído pela abstração de inserção no banco de dados, de algum objeto repository<br>        //System.out.println(&quot;Enviar email com dados do novo pedido para o cliente&quot;); // Que pode ser substituído pela abstração de algum service de disparo de emails<br>    }<br>}</pre><p>À partir dos dados informados no client, o handler cria um orçamento, um pedido, e invoca as 2 etapas esperadas para esta ação.</p><p>O que no artigo sobre o padrão “Commander” eram apenas “<em>sysout’s</em>”, se tornaram, como já dito, a invocação do método “executar” de dois novos objetos, frutos de instâncias de 2 classes criadas, cada uma com a implementação necessária para executar a etapa que compõe a ação de gerar pedido no sistema.</p><p>Classe <em>SalvarPedidoNoBancoDeDados.java</em></p><pre>package observer.raw;<br><br>public class SalvarPedidoNoBancoDeDados {<br><br>    public void executar (Pedido pedido) {<br>        System.out.println(&quot;Salvar pedido no banco de dados&quot;);<br>    }<br>}</pre><p>(Substitua este “<em>sysout</em>” pelas ações necessárias para salvar este pedido no banco de dados.)</p><p>Classe <em>EnviarEmailPedido.java</em></p><pre>package observer.raw;<br><br>public class EnviarEmailPedido {<br><br>    public void executar (Pedido pedido) {<br>        System.out.println(&quot;Enviando email com dados do pedido&quot;);<br>    }<br>}</pre><p>(Substitua este “<em>sysout</em>” pelas ações necessárias para disparar um email para o cliente com as informações do pedido dele.)</p><h3>Problemas</h3><p>Por enquanto, nós temos apenas 2 etapas para a geração de pedido. Mas e se futuramente for decidido que o sistema deverá disparar um processo de geração de nota fiscal deste pedido? E se futuramente, for necessário que o departamento de expedição seja notificado (via envio de email, atualização em um sistema fora do escopo que este departamento consulte para operação) para separar no estoque os produtos comprados neste pedido? E se futuramente, uma nova funcionalidade for solicitada para avisar o departamento de compras para que eles façam as encomendas necessárias junto ao fornecedor para repor estoque ou comprar itens que não tem atualmente no estoque para completar o pedido? E se passado um tempo, uma nova integração com a transportadora foi implementada e ela tem que ser capaz de agendar junto ao time de logística a entrega deste pedido?</p><p>Para cada etapa desta ação, uma nova instância precisou ser gerada e o método de execução invocado para executar esta ação, o que faz com que a coesão acabe sempre diminuindo, pois este handler passa a ser acrescido de responsabilidades diferentes do objetivo ao qual ele foi concebido no começo do projeto, além da manutenibilidade do código ficar cada vez mais comprometida, com estes incrementos.</p><h3>A solução</h3><p>A alternativa para este impasse, que o padrão “<strong>Observer” </strong>nos apresenta, pode ser adotada a fim de que mudemos a estrutura do código para a seguinte estrutura:</p><p>Interface <em>AcaoAposGerarPedido.java</em></p><pre>package observer.solution;<br><br>public interface AcaoAposGerarPedido {<br>    public void executarAcao(Pedido pedido);<br>}</pre><p>Como as classes que implementam etapas do processo de criação de pedido possuem uma estrutura similar, podemos criar uma interface que exige que qualquer classe que implemente qualquer etapa deste processo, tenha um método “executarAcao”, que receba um Pedido como parâmetro.</p><p>Classe <em>EnviarEmailPedido.java</em></p><pre>package observer.solution;<br><br>public class EnviarEmailPedido implements AcaoAposGerarPedido {<br><br>    public void executarAcao (Pedido pedido) {<br>        System.out.println(&quot;Enviando email com dados do pedido&quot;);<br>    }<br>}</pre><p>A classe EnviarEmailPedido agora implementa esta interface, e o método “executar” foi nomeado para “executarAcao” (não precisava se chamar executarAcao. Apenas mudamos para não confundirmos com o “executar” do handler)</p><p>Classe <em>SalvarPedidoNoBancoDeDados.java</em></p><pre>package observer.solution;<br><br>public class SalvarPedidoNoBancoDeDados implements AcaoAposGerarPedido {<br><br>    public void executarAcao (Pedido pedido) {<br>        System.out.println(&quot;Salvar pedido no banco de dados&quot;);<br>    }<br>}</pre><p>A classe SalvarPedidoNoBancoDeDados agora também implementa esta interface, e o método “executar” também foi nomeado para “executarAcao”.</p><p>Classe <em>GerarPedidoHandler.java</em></p><pre>package observer.solution;<br><br>import java.time.LocalDateTime;<br>import java.util.List;<br><br>public class GerarPedidoHandler {<br><br>    private List&lt;AcaoAposGerarPedido&gt; acoes;<br><br>    public GerarPedidoHandler(List&lt;AcaoAposGerarPedido&gt; acoes) {<br>        this.acoes = acoes;<br>    }<br><br>    //construtor com injeção de dependências: repositories, services etc...<br><br>    public void executar(GerarPedidoDados dados) {<br>        Orcamento orcamento = new Orcamento(dados.getValorOrcamento(), dados.getQuantidadeItens());<br><br>        Pedido pedido = new Pedido(dados.getCliente(), LocalDateTime.now(), orcamento);<br><br>        acoes.forEach(a -&gt; a.executarAcao(pedido));<br>    }<br>}</pre><p>Aqui temos algumas alterações que devem ser destacadas.</p><p>A primeira delas é que as dependências (classes que implementam a interface AcaoAposGerarPedido) ficarão armazenadas em uma lista, que será populada quando este handler for instanciado (via construtor).</p><p>O método “executar” desta classe faz uma iteração sobre os objetos desta lista, e invoca o método “executarAcao” de cada um destes objetos, sem exceção. Desta forma, não importa quantas dependências (etapas) sejam necessárias para que a ação de gerar pedido sejam executadas: este handler não sofrerá mais alterações por este motivo!</p><p>Classe <em>Main.java</em></p><pre>package observer.solution;<br><br>import java.math.BigDecimal;<br>import java.util.ArrayList;<br>import java.util.Arrays;<br>import java.util.List;<br><br>public class Main {<br>    public static void main(String[] args) {<br><br>        String cliente = args[0];<br>        BigDecimal valor = new BigDecimal(args[1]);<br>        int quantidade = Integer.parseInt(args[2]);<br><br>        GerarPedidoDados dados = new GerarPedidoDados(cliente, valor, quantidade);<br><br>        GerarPedidoHandler gerador = new GerarPedidoHandler(Arrays.asList(<br>            new SalvarPedidoNoBancoDeDados(),<br>            new EnviarEmailPedido()<br>            /*<br>                new EmitirNotaFiscal(),<br>                new SepararEstoque(),<br>                new NotificarComprasParaEncomendarProdutosDoFornecedor(),<br>                etc...<br>            */<br>        ));<br><br>        gerador.executar(dados);<br>    }<br>}</pre><p>À partir de agora, é o client que será o responsável por instanciar e injetar todas as dependências do handler. Neste exemplo, notem que estamos passando uma lista (Arrays.asList()) com as instâncias das dependências necessárias para o funcionamento deste handler (por hora as instâncias das classes SalvarPedidoNoBancoDeDados e EnviarEmailPedido).</p><p>Futuramente se precisarmos injetar mais dependências (como nos comentários logo abaixo, das classes EmitirNotaFiscal, SepararEstoque etc…), basta inserir estas instâncias separadas por vírgulas, que o handler executará prontamente!</p><h3>Indicações</h3><p>Este padrão atenderá você nas seguintes situações:</p><ul><li>Quando alterações do estado de um objeto requer a alteração de outros objetos, e o atual conjunto de objetos é desconhecido de antemão, ou se alteram dinamicamente;</li><li>Quando alguns objetos em sua aplicação precisa observar outros, mas somente por um tempo limitado ou em casos específicos;</li><li>É um padrão muito útil quando se desenvolve sistemas com uma arquitetura orientada a eventos;</li></ul><h3>Prós e contras</h3><p>Vantagens deste padrão:</p><ul><li><strong>Aplicação prática da letra “O” do princípio SOLID (Open / Closed Principle)</strong>: Note que desta forma, permitimos que inúmeras dependências fossem injetadas na classe que representa um “handler” em nosso sistema, as ações de cada uma destas dependências (subscribers) fossem executadas, sem que a implementação deste “handler” seja alterada;</li><li>Você pode estabelecer relações entre objetos durante o runtime;</li></ul><p><strong>Mas cuidado:</strong> Muito embora haja a garantia de que estas dependências todas sejam acionadas, <strong>não há como garantir a sequência de execução destas dependências</strong>!</p><p>Espero que tenham gostado deste artigo, e que o conteúdo desta publicação pode ajudar você no desenvolvimento de seus sistemas.</p><p>Fique à vontade para acompanhar o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44fee3ef30a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão Comportamental Command (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-command-s%C3%A9rie-design-patterns-2db2367acbd9?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/2db2367acbd9</guid>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[behavioral-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[command-design-pattern]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 29 Jul 2023 18:35:56 GMT</pubDate>
            <atom:updated>2023-07-29T18:35:56.901Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*neA0X-vqwLgWh0RPVOM5vQ.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/command">https://refactoring.guru/design-patterns/command</a></figcaption></figure><p>Olá caro leitor!</p><p>O design pattern de que falaremos hoje é comumente usado em arquiteturas de software como Domain Driven Design e Clean Architecture, onde o sistema que adota estas abordagens permite que tais ações sejam acionadas por interfaces distintas (API’s REST, Webservices, interfaces web, linha de comando etc), mas que para manter a integridade e a manutenibilidade destes sistemas, isolamos casos de uso da representação do cliente. Estamos falando do padrão “<strong>Command</strong>”.</p><p>Os tópicos deste artigo são:</p><ul><li><strong>O Cenário</strong>: a situação hipotética, o problema a ser resolvido;</li><li><strong>O desenvolvimento da solução sem o padrão</strong>: implementação básica do código para resolver o problema;</li><li><strong>Problemas</strong>: o que pode acontecer com o sistema, cujo código não segue este padrão;</li><li><strong>A solução</strong>: aplicação da abordagem;</li><li><strong>Indicações</strong>: a que se destina este tipo de padrão;</li><li><strong>Prós e contras</strong> desta abordagem.</li></ul><h3>O Cenário</h3><p>Dando continuidade ao nosso sistema dos artigos anteriores, agora iremos implementar a funcionalidade de criação de pedido. Vou prosseguir a partir do código da solução do padrão “state” (veja o artigo clicando <a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-state-s%C3%A9rie-design-patterns-20b7571d1c50?source=user_profile---------0----------------------------">aqui</a>).</p><p>Para facilitar a didática, estou desconsiderando as funcionalidades de aplicação de impostos e descontos, bem como movimentações no status no orçamento, e estou considerando que o orçamento já está com o valor final consolidado (descontos aplicados e impostos concedidos), e o seu status já como finalizado, pronto para que um pedido seja criado a partir dele.</p><p>O caso de uso de geração de pedido que iremos implementar, prevê as seguintes ações:</p><ul><li>Criação do objeto “pedido” (apenas para ilustração… na vida real isso poderia significar validações, resgatar histórico de pedidos deste cliente etc.);</li><li>Salvar no banco de dados</li><li>Enviar um email para o cliente com os dados do pedido</li></ul><h3>O Desenvolvimento da solução sem o padrão</h3><p>Como estamos desconsiderando todos os desdobramentos que tivemos ao longo destes artigos desta série, vamos aproveitar apenas a classe de Orçamento, resultado das evoluções dos artigos anteriores, e criar uma nova classe para abstrair o pedido.</p><p>Classe <em>Orcamento.java</em></p><pre>package command.raw;<br><br>import command.raw.statuses.EmAnalise;<br>import command.raw.statuses.Status;<br>import java.math.BigDecimal;<br><br>public class Orcamento {<br>    private BigDecimal valor;<br>    private int quantidadeItens;<br>    private Status status;<br><br>    public Orcamento(BigDecimal valor, int quantidadeItens) {<br>        this.valor = valor;<br>        this.quantidadeItens = quantidadeItens;<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br>j<br>    public int getQuantidadeItens() {<br>        return this.quantidadeItens;<br>    }<br>}</pre><p>A classe Orçamento, como no artigo anterior, possui uma propriedade que armazena o valor total, a quantidade de itens, e seu status. Além disso, tem um construtor que recebe estes valores, “getters” e os métodos que ali já estavam. Nenhuma alteração será feita nesta classe neste exemplo.</p><p>Classe <em>Pedido.java</em></p><pre>package command.raw;<br><br>import java.time.LocalDateTime;<br><br>public class Pedido {<br>    private String cliente;<br>    private LocalDateTime data;<br>    private Orcamento orcamento;<br><br>    public Pedido(String cliente, LocalDateTime data, Orcamento orcamento) {<br>        this.cliente = cliente;<br>        this.data = data;<br>        this.orcamento = orcamento;<br>    }<br><br>    public String getCliente() {<br>        return cliente;<br>    }<br><br>    public LocalDateTime getData() {<br>        return data;<br>    }<br><br>    public Orcamento getOrcamento() {<br>        return orcamento;<br>    }<br>}</pre><p>A classe Pedido será responsável por abstrair o pedido em nosso sistema. Neste exemplo, recebe o nome do cliente como uma string (poderia ser uma classe que abstraísse o cliente, mas por hora, o nome dele basta), a data da realização do pedido, e o orçamento que o originou. Ele possui um método construtor que atribui valores à estas propriedades, e getters que retornam estes valores.</p><p>Classe <em>Main.java</em></p><pre>package command.raw;<br><br>import command.solution.GerarPedidoDados;<br>import command.solution.Orcamento;<br>import command.solution.Pedido;<br>import java.math.BigDecimal;<br>import java.time.LocalDateTime;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        Orcamento orcamento = new Orcamento(new BigDecimal(&quot;100.0&quot;), 6);<br>        String cliente = &quot;Cliente 1&quot;;<br>        LocalDateTime data = LocalDateTime.now();<br><br>        Pedido pedido = new Pedido(cliente, data, orcamento);<br>        System.out.println(&quot;Salvar pedido no banco de dados&quot;);<br>        System.out.println(&quot;Enviar email com dados do novo pedido para o cliente&quot;);<br>    }<br>}</pre><p>A classe Main é uma representação do cliente que consome funcionalidades do sistema. Neste exemplo ela cria um orçamento, cria um cliente, instancia a classe Pedido. Ela também está invocando a ação que salva o pedido no banco de dados, e está se responsabilizando por invocar a funcionalidade de envio de email para o cliente (os 2 últimos “sysout’s” do método).</p><h3>Problemas</h3><p>Este exemplo mostra apenas uma representação que se responsabiliza por “orquestrar” os passos necessários para se gerar um pedido no sistema.</p><p>Futuramente pode ser necessária a implementação de uma representação de linha de comando (que seja possível que um pedido seja gerado à partir da execução de um shell script ou um terminal, onde as informações básicas para a geração de um pedido sejam passados via parâmetros), e ele também terá que “orquestrar” os passos necessários para gerar este pedido.</p><p>Futuramente pode ser necessária a implementação de uma interface web (um formulário HTML por exemplo), que receberá informações básicas para a geração de um pedido, via POST, e ele também “orquestrará” os passos necessários para gerar este pedido.</p><p>Futuramente pode ser necessária a implementação de uma API REST, em que as informações serão enviadas ao sistema através de uma requisição HTTP, com os dados em formato JSON ou XML, e ele também se responsabilizará por orquestrar os passos necessários para gerar este pedido.</p><p>Futuramente pode ser necessária a implementação de um webservice SOAP, e através de um método exposto, uma requisição poderá acionar os mecanismos de geração de pedido.</p><p>Futuramente pode ser necessária a implementação de uma interface GraphQL, que também terá as responsabilidades das representações citadas acima.</p><p>Futuramente pode ser necessária a implementação de uma interface gRPC, que também fará terá as responsabilidades das representações citadas acima.</p><p>Futuramente, depois de todas estas representações (API Rest, gRPC, SOAP, web, CLI, GraphQL etc) pode ser que precisemos mudar a forma de disparar emails ao cliente depois que o pedido for gerado (acionando um serviço externo como o Mailchimp, ao invés de servidor próprio por exemplo), e para isso tenhamos que fazer a mesma alteração em todas estas representações.</p><p>Futuramente, pode ser que precisemos implantar um sistema de monitoramento para acompanhar o comportamento do sistema durante este processo, e tenhamos que fazer esta chamada em todas estas representações, já que cada uma delas é responsável pelas ações de geração de pedido, individualmente.</p><p>Futuramente, pode ser que precisemos implementar uma funcionalidade de notificação de evento para outro domínio do sistema, para que assim que um pedido seja gerado, que, por exemplo, o departamento de expedição seja avisado de que há a necessidade de se fazer a devida separação de estoque dos itens deste pedido, ou acionar o departamento de compras para que ele faça as devidas encomendas para o fornecedor, e isso terá que ser replicado igualmente em todas as representações existentes…</p><p>Perceba que há uma infinidade de incrementos que podem ser implementados ao longo do tempo, e que por causa da descentralização do processo, a implementação e a manutenção destas representações se tornam cada vez mais complexas, bem como a garantia da consistência do comportamento, já que em cada interface há formas diferentes de implementação das ações.</p><p>Como podemos garantir uma organização desse código? Como podemos garantir que ao fazer um novo incremento (como monitoramento, indexação, notificação de eventos, disparos de emails etc), este incremento seja refletido em todas as representações existentes e nas novas que surgirão?</p><h3>Solução</h3><p>O padrão “Command” propõe que um único método aglutinador destas ações (um caso de uso) seja criado e exposto, para que seja invocado pelas inúmeras representações que necessitarem das funcionalidades deste caso de uso. Ou seja, uma nova camada separará a representação do cliente (interface web, API, controllers etc) das regras de negócio.</p><p>Não irei exibir o código da classes “Pedido” e “Orcamento” neste exemplo, pois elas se manterão inalteradas. Vejamos como esta nova estrutura será escrita:</p><p>Classe <em>Main.go</em></p><pre>package command.solution;<br><br>import java.math.BigDecimal;<br>import java.time.LocalDateTime;<br><br>public class Main {<br>    public static void main(String[] args) {<br>        String cliente = args[0];<br>        BigDecimal valor = new BigDecimal(args[1]);<br>        int quantidade = Integer.parseInt(args[2]);<br>        GerarPedidoDados dados = new GerarPedidoDados(cliente, valor, quantidade);<br>        GerarPedidoHandler gerador = new GerarPedidoHandler(/*Dependências injetadas aqui*/);<br>        gerador.executar(dados);<br>    }<br>}</pre><p>Esta classe Main, como informada anteriormente, representa uma interface do cliente. Neste caso uma interface de linha de comando, onde os dados necessários para o pedido são informados via argumentos.</p><p>O comportamento de uma representação de cliente agora terá o seguinte padrão:</p><ul><li>Receber, filtrar e tratar o input enviado pelo cliente;</li><li>Instanciar o “handler” do caso de uso, e passar os dados necessários para a atuação do caso de uso, bem como suas devidas injeções de dependências;</li><li>Invocar o método principal deste caso de uso (neste caso, o método “executar”);</li></ul><p>Não importa mais qual será a representação do cliente. Todas estas classes serão responsáveis apenas por preparar os dados à partir do input do usuário, e enviar para o handler que irá realizar a ação desejada.</p><p>Classe <em>GerarPedidoHandler.java</em></p><pre>package command.solution;<br><br>import java.time.LocalDateTime;<br><br>public class GerarPedidoHandler {<br>    //construtor com injeção de dependências: repositories, services etc...<br>    public void executar(GerarPedidoDados dados) {<br>        Orcamento orcamento = new Orcamento(dados.getValorOrcamento(), dados.getQuantidadeItens());        Pedido pedido = new Pedido(dados.getCliente(), LocalDateTime.now(), orcamento);<br>        System.out.println(&quot;Salvar pedido no banco de dados&quot;); // Que pode ser substituído pela abstração de inserção no banco de dados, de algum objeto repository<br>        System.out.println(&quot;Enviar email com dados do novo pedido para o cliente&quot;); // Que pode ser substituído pela abstração de algum service de disparo de emails<br>    }<br>}</pre><p>Esta classe admite a implementação de uma interface, para garantir que todo handler de caso de uso tenha o seu próprio método “executar”, responsável por executar as ações necessárias para este caso de uso. Mas não é obrigatória.</p><p>Ela pode ter um construtor que receberá os dados para a ação, e também receber as injeções de dependências necessárias para tal (repositórios, serviços etc).</p><p>Ela admite também métodos auxiliares para a execução do caso de uso, desde que tenha o seu método principal, uma vez que é este método quem será acionado pelos “clients”.</p><p>Observando o seu método principal, note que nele estamos criando um orçamento (baseado nas informações passadas pelo “client”, instanciamos um pedido, e estamos invocando a funcionalidade de criação do registro no banco de dados (aqui um “sysout” imprimindo a mensagem, mas que pode ser substituído pela invocação do método adequado do repositório, pertencente à dependência injetada pela camada de representação do cliente), bem como o disparo do email (aqui também um “sysout”, mas que pode ser substituído por uma invocação de método de um serviço de email, também injetado como dependência). Demais incrementos que seriam necessários à esta funcionalidade, independentemente de quem o aciona (logs de monitoramento, disparos de notificações de eventos etc) seriam implementados aqui também.</p><p>Classe <em>GerarPedidoDados.java</em></p><pre>package command.solution;<br><br>import java.math.BigDecimal;<br>import java.time.LocalDateTime;<br><br>public class GerarPedidoDados {<br>    private String cliente;<br>    private BigDecimal valorOrcamento;<br>    private int quantidadeItens;<br><br>    public GerarPedidoDados(String cliente, BigDecimal valorOrcamento, int quantidadeItens) {<br>        this.cliente = cliente;<br>        this.valorOrcamento = valorOrcamento;<br>        this.quantidadeItens = quantidadeItens;<br>    }<br><br>    public String getCliente() {<br>        return cliente;<br>    }<br><br>    public BigDecimal getValorOrcamento() {<br>        return valorOrcamento;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return quantidadeItens;<br>    }<br>}</pre><p>A classe GerarPedidosDados é na verdade desnecessária. É apenas uma tentativa de separação de estados desta classe de seus comportamentos, para evitar que a classe fique muito grande. Mas você pode criar uma única classe “GerarPedidos”, que mantenha os dados e os comportamentos da mesma se preferir.</p><p>Todavia, veja que se trata de uma classe anêmica, que apenas armazena e disponibiliza dados.</p><p>Entendido este conceito (me refiro à criação desta camada com o caso de uso), podemos considerar a possibilidade de se criar um caso de uso, similar a este handler, que calcula o valor do orçamento, incidindo impostos e aplicando descontos a ele, de acordo com o que implementamos nos outros artigos (a calculadora de orçamento poderia virar um CalculaOrcamentoHandler, e seguir este padrão). O que acha?</p><h3>Indicações</h3><p>Considere a possibilidade de aplicar este padrão nas seguintes situações:</p><ul><li>Quando você quer parametrizar objetos com operações: Assim como fizemos com os dados do orçamento e do pedido, em que ele fizesse a geração do pedido à partir dos dados (nome do cliente, valor do pedido, data) que o “cliente” o passou via parâmetro;</li><li>Quando você quer enfileirar operações, agendar suas execuções ou executa-las remotamente, e/ou quando você quer ter a possibilidade de reexecutar estas operações em casos de erro: Como isolamos o caso de uso das representações de clientes, é possível que estes dados estejam todos armazenados em um arquivo ou banco de dados, e que um robô possa iterar sobre estes registros e acionar novamente os casos de uso para tentar reprocessar estas informações. Inclusive é uma abordagem muito comum em sistemas orientados a eventos!</li></ul><h3>Prós e contras</h3><p>As vantagens desta abordagem são:</p><ul><li><strong>Aplicação prática da letra “S” dos princípios SOLID (Single Responsibility Principle)</strong>: Dessa forma, é possível desacoplar classes que invocam operações de classes que executarão estas operações (a classe de representação era responsável apenas por filtrar o input e passar estes dados ao caso de uso, que acaba de ser acionado);</li><li><strong>Aplicação prática da letra “O” dos princípios SOLID (Open/Closed Principle)</strong>: Você pode introduzir novos comandos (casos de uso) na aplicação sem fazer alterações nos códigos já existente;</li><li>Com esta abordagem, é possível implementar mecanismos de “rollback” (undo/redo) em informações já processadas com erro;</li><li><strong>Com esta abordagem, é possível implementar execuções adiadas de operações</strong>: É possível reagender execuções futuras, caso ocorram erros durante o processamento, sem perda de informação, já que podemos serializar estes dados e armazena-los em um banco de dados para futuras consultas;</li><li><strong>Com esta abordagem, você pode montar um conjunto de simples comandos para realizar uma tarefa complexa</strong>: No nosso exemplo, “gerar pedido” significa também salvar ele no banco de dados, e também enviar por email os dados deste pedido ao cliente, mas poderia implicar também, através de disparo de eventos, em acionamentos de departamentos diversos, como expedição para separação de estoque, compras para acionamento de fornecedores, financeiro para emissão de nota fiscal etc;</li></ul><p><strong>Mas cuidado</strong>: A complexidade das ações deste domínio deve justificar a aplicação desta abordagem, pois você estará criando uma nova camada entre o “client” e a lógica de negócios, e para operações muito simples, isso pode ser um “overengineering” desnecessário.</p><p>Espero que tenham gostado deste artigo.</p><p>Fiquem à vontade para ver o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a></p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2db2367acbd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão comportamental State (Série design patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-state-s%C3%A9rie-design-patterns-20b7571d1c50?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/20b7571d1c50</guid>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[behavioral-design-pattern]]></category>
            <category><![CDATA[state-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 29 Jul 2023 18:23:58 GMT</pubDate>
            <atom:updated>2023-07-29T18:23:58.868Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*Vfc6ODYrCM6ZLxL4wRDKuA.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/state">https://refactoring.guru/design-patterns/state</a></figcaption></figure><p>Olá caro seguidor!</p><p>Prosseguindo com a nossa série, venho apresentar a você o padrão comportamental “<strong>State</strong>”, controlando fluxos de código sem ficar presos a condicionais infinitas que poluem o código, além de flexibilizar as ações para cada condição, de maneira similar ao strategy.</p><p>Como os demais artigos, a estrutura deste artigo segue:</p><ul><li><strong>O cenário</strong>: a situação hipotética em que estamos trabalhando;</li><li><strong>O desenvolvimento da solução sem o padrão</strong>: escrita do código sem a aplicação do padrão, apenas visando a entrega da solução;</li><li><strong>Problemas</strong>: o que pode acontecer sem a adoção deste padrão;</li><li><strong>A solução</strong>: um exemplo de como este padrão pode nos ajudar;</li><li><strong>Indicações</strong>: Situações em que este padrão se mostra apropriado;</li><li><strong>Prós e contras</strong>: vantagens e desvantagens desta abordagem.</li></ul><h3>O Cenário</h3><p>Continuaremos com o mesmo sistema, que está sendo implementado nos artigos anteriores, e para fins didáticos, vou aplicar o padrão no código presente na solução do padrão template method (clique <a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-template-method-s%C3%A9rie-design-patterns-69e4bc5aacc4?source=user_profile---------0----------------------------">aqui</a> para acessar o artigo sobre este padrão).</p><p>O novo incremento agora se trata de uma nova regra de negócio, que o “time comercial solicitou”: precisamos que seja possível aplicar, além dos descontos já concedidos pelo valor ou quantidade de itens do orçamento, um novo desconto ao orçamento, baseado no status deste orçamento (que pode ser “Em Análise”, “Aprovado”, “Reprovado” ou “Finalizado”).</p><p>Para orçamentos ainda “em análise”, serão permitidos um desconto extra de 5%. Para orçamentos “aprovados”, 2%. Para os demais stati, não serão concedidos quaisquer descontos.</p><p>Além da aplicação do desconto, cada orçamento deverá seguir a seguinte regra de migração de um status para outro:</p><ul><li><strong>Em análise</strong>: Orçamentos “Em análise” só podem ser avançados para “Aprovado” ou “Reprovado” (Finalizado não);</li><li><strong>Aprovado</strong>: Orçamentos aprovados só podem avançar para “Finalizado” (ou seja: um orçamento aprovado não pode mais voltar para o status “Em Análise” tampouco para “Reprovado”);</li><li><strong>Reprovado</strong>: Orçamentos reprovados só podem avançar para “Finalizado” (não será permitido mover um orçamento neste status para “Em análise” e nem aprová-lo);</li><li><strong>Finalizado</strong>: Estado final (Orçamentos finalizados não podem ser movidos para “Em Análise”, nem aprovados ou reprovados).</li></ul><h3>O Desenvolvimento da solução, sem o padrão</h3><p>Compreendidas as novas regras, vamos começar a fazer as alterações cabíveis na classe Orcamento (as demais classes neste artigo permanecerão intactas desta vez).</p><p>Classe <em>Orcamento.java</em></p><pre>package state.raw;<br><br>import java.math.BigDecimal;<br><br>public class Orcamento {<br><br>    private BigDecimal valor;<br>    private int quantidadeItens;<br>    private String status;<br><br>    public Orcamento(BigDecimal valor, int quantidadeItens) {<br>        this.valor = valor;<br>        this.quantidadeItens = quantidadeItens;<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = BigDecimal.ZERO;<br><br>        if (status.equals(&quot;EM ANALISE&quot;)) {<br>            valorDoDescontoExtra = new BigDecimal(&quot;0.05&quot;);<br>        } else if (status.equals(&quot;APROVADO&quot;)) {<br>            valorDoDescontoExtra = new BigDecimal(&quot;0.02&quot;);<br>        }<br><br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void aprovar() {<br>        this.status = &quot;APROVADO&quot;;<br>    }<br><br>    public void reprovar() {<br>        this.status = &quot;REPROVADO&quot;;<br>    }<br><br>    public void finalizar() {<br>        this.status = &quot;FINALIZADO&quot;;<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.quantidadeItens;<br>    }<br>}</pre><p>Destacando as alterações na classe:</p><ul><li>Foi criada uma propriedade chamada “status”, do tipo String. O controle de status é bem simples, textual mesmo;</li><li>Foi criado o método aplicarDescontoExtra, que será o responsável por calcular o desconto extra, baseado no status do orçamento;</li><li>Foram criados os método “aprovar”, “reprovar” e “finalizar”, que serão os responsáveis por mover o orçamento de status. Estes métodos serão acionados por alguma funcionalidade (algum client ou caso de uso), que para este exemplo didático não tem relevância, e por este motivo, não implementei um exemplo do client os invocando;</li></ul><h3>Problemas</h3><p>De imediato, podemos elencar 2 problemas nessa forma de implementação, sendo um para o controle de migração de status e outro para o cálculo do desconto:</p><ul><li><strong>Migração do status</strong>: Apesar de termos conhecimento das regras de negócio quanto as limitações de fluxo de status, o responsável por controlar este fluxo será o “client” que invocará tais métodos. Ou seja, é o client que vai ter que verificar o status atual do orçamento, e saber quais são os possíveis status das quais um orçamento pode migrar, pois não haverá nenhum controle por parte do orçamento e do motor de migração de status do orçamento para validar este fluxo. Isso acarretará em uma série de if’s aninhados poluindo o código do client;</li><li><strong>Cálculo do desconto</strong>: Se para cada status o percentual do desconto é diferente, eu vou ter que criar uma série de “if’s e elses”, ou “switch case’s” para retornar o valor adequado, o que faz com que a implementação fique confusa se eu precisar aplicar mais ações a cada nova ação futura a ser executada que venha a surgir com a evolução do sistema;</li></ul><h3>A solução</h3><p>O padrão “<strong>State</strong>” sugere que você crie novas classes para todos os possíveis estados de um objeto, e extraia todos os comportamentos específicos deste estado para estas classes.</p><p>Ao invés de implementar todos os comportamentos nesta classe de contexto (neste caso, o contexto é o Orcamento), você pode armazenar uma referência para um estado deste objeto, que representará o status corrente, e delegar a esta classe todo o comportamento esperado para este objeto, quando estiver neste status.</p><p>Levando em consideração que os comportamentos possíveis para uma classe de status, sejam o cálculo do desconto (todos os stati tem um percentual de desconto, exceto os stati “Finalizado” e “Reprovado”) e migração do status podem se repetir, criaremos uma classe abstrata que implementará estes métodos, definindo um comportamento padrão, que serão customizados pelas classes especializadas.</p><p>Classe <em>Status.java</em></p><pre>package state.solution.statuses;<br><br>import state.solution.Orcamento;<br>import java.math.BigDecimal;<br><br>public abstract class Status {<br>    public BigDecimal calcularValorDescontoExtra(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(BigDecimal.ZERO);<br>    }<br><br>    public void aprovar(Orcamento orcamento) {<br>        throw new RuntimeException(&quot;Este orçamento não pode ser aprovado&quot;);<br>    }<br><br>    public void reprovar(Orcamento orcamento) {<br>        throw new RuntimeException(&quot;Este orçamento não pode ser reprovado&quot;);<br>    }<br><br>    public void finalizar(Orcamento orcamento) {<br>        throw new RuntimeException(&quot;Este orçamento não pode ser finalizado&quot;);<br>    }<br>}</pre><p>Tomei a liberdade de colocar estas classes que representam os vários estados em um pacote separado para este fim.</p><p>Como podemos observar a classe abstrata Status, ela define um cálculo padrão de descontos, que retorna 0, e implementa 4 métodos que fazem as migrações de estado que mapeamos na regra de negócio. Notemos também que estes métodos todos por padrão lançam uma exceção se forem invocados. Falaremos sobre isso futuramente.</p><p>Classe <em>EmAnalise.java</em></p><pre>package state.solution.statuses;<br><br>import state.solution.Orcamento;<br>import java.math.BigDecimal;<br><br>public class EmAnalise extends Status {<br>    public BigDecimal calcularValorDescontoExtra(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.05&quot;));<br>    }<br><br>    public void aprovar(Orcamento orcamento) {<br>        orcamento.setStatus(new Aprovado());<br>    }<br><br>    public void reprovar(Orcamento orcamento) {<br>        orcamento.setStatus(new Reprovado());<br>    }<br>}</pre><p>A classe EmAnalise (assim como as demais deste pacote) estende da classe Status, e faz uma sobrecarga dos métodos “calcularValorDescontoExtra”, implementando o desconto que lhe cabe aplicar (5%), bem como os métodos “aprovar” e “reprovar”, sobrescrevendo o comportamento padrão delas (de lançar a exceção caso tenham sido chamadas). Desta forma, se o status atual do pedido for “EmAnalise” e alguém invocar o método “finalizar”, uma exceção será lançada, pois não podemos finalizar um orçamento que esteja em análise ainda, lembra?</p><p>Classe <em>Aprovado.java</em></p><pre>package state.solution.statuses;<br><br>import state.solution.Orcamento;<br>import java.math.BigDecimal;<br><br>public class Aprovado extends Status {<br>    public BigDecimal calcularValorDescontoExtra(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.02&quot;));<br>    }<br><br>    public void finalizar(Orcamento orcamento) {<br>        orcamento.setStatus(new Finalizado());<br>    }<br>}</pre><p>Esta classe também estende a classe Status, sobrecarrega o método “calcularValorDescontoExtra” e calcula o valor do desconto que lhe é cabido (2%), e altera somente o comportamento do método finalizar, deixando os demais métodos de migração de status com o comportamento padrão (não podemos reprovar ou retornar para “Em Análise” um orçamento aprovado).</p><p>Classe <em>Reprovado.java</em></p><pre>package state.solution.statuses;<br><br>import state.solution.Orcamento;<br><br>public class Reprovado extends Status {<br>    public void finalizar(Orcamento orcamento) {<br>        orcamento.setStatus(new Finalizado());<br>    }<br>}</pre><p>Como o orçamento reprovado não tem descontos aplicáveis, não há o que alterar do comportamento padrão do método calcularValorDescontoExtra (que retorna 0). Mas como o próximo estado possível de um orçamento reprovado é “finalizado”, implementa-se uma sobrecarga do método finalizar.</p><p>Classe <em>Finalizado.java</em></p><pre>package state.solution.statuses;<br><br>public class Finalizado extends Status {<br>    // outros métodos e propriedades que não as herdadas da superclasse Status<br>}</pre><p>Um orçamento finalizado não sofre alterações de status nem admite aplicação de descontos, e por este motivo herdará todos os comportamentos padrão, já implementados na superclasse Status.</p><p>E como prometido, falando novamente sobre a superclasse Status, os métodos de migração por padrão lançam exceções, para evitar que estes comportamentos sejam acionados indevidamente. São as classes especializadas que se incumbirão de alterar os comportamentos destes métodos, se houver necessidade (esta é a forma de validar a alteração de estado, se usar nenhuma condicional de verificação prévia!). Dessa forma, evita-se duplicação de código para implementação, e garante-se a consistência destes comportamentos.</p><p>Classe <em>Orcamento.java</em></p><pre>package state.solution;<br><br>import state.solution.statuses.EmAnalise;<br>import state.solution.statuses.Status;<br>import java.math.BigDecimal;<br><br>public class Orcamento {<br>    private BigDecimal valor;<br>    private int quantidadeItens;<br>    private Status status;<br><br>    public Orcamento(BigDecimal valor, int quantidadeItens) {<br>        this.valor = valor;<br>        this.quantidadeItens = quantidadeItens;<br>        this.status = new EmAnalise();<br>    }<br><br>    public void aplicarDescontoExtra() {<br>        BigDecimal valorDoDescontoExtra = this.status.calcularValorDescontoExtra(this);<br>        this.valor = this.valor.subtract(valorDoDescontoExtra);<br>    }<br><br>    public void setStatus(Status status) {<br>        this.status = status;<br>    }<br><br>    public void aprovar() {<br>        this.status.aprovar(this);<br>    }<br><br>    public void reprovar() {<br>        this.status.reprovar(this);<br>    }<br><br>    public void finalizar() {<br>        this.status.finalizar(this);<br>    }<br><br>    public BigDecimal getValor() {<br>        return valor;<br>    }<br><br>    public int getQuantidadeItens() {<br>        return this.quantidadeItens;<br>    }<br>}</pre><p>Finalmente, a classe Orcamento, que hoje foi a classe em que aplicamos o padrão.</p><p>Podemos descrever as alterações nela como:</p><ul><li>A propriedade “status”, que era uma String com o título do estado, agora é do tipo da nossa classe abstrata “Status”. Assim tornamos o controle de <em>stati</em> mais sofisticado;</li><li>O Construtor do orçamento inicia esta propriedade, atribuindo a ela uma instância da classe especializada “EmAnalise”, que é um subtipo da classe Status;</li><li>O método “aplicarDescontoExtra”, que concentrava uma série de condicionais para determinar qual valor aplicar, agora invoca o método “calcularValorDesconto” do objeto “status”, independente do estado atual. Quem faz o cálculo agora é o objeto do estado, que já tem a funcionalidade implementada e isolada na sua classe;</li><li>O método “setStatus”, que recebe um objeto do tipo Status, e atribui este objeto à propriedade “status”. Este método é invocado pelos métodos de migração de status que criamos nas classes especializadas de status, que de certa forma “configura” o comportamento dos métodos da classe “Orcamento”;</li><li>Os métodos aprovar, reprovar e finalizar invocam os métodos homônimos do objeto na propriedade “status” da classe “Orcamento”</li></ul><p>O “client” que vai invocar a classe Orcamento e mover o status deste receberá uma exceção se tentar migrar de status indevidamente.</p><h3>Indicações</h3><p>Este padrão é adequado para as seguintes situações:</p><ul><li>Quando você tem um objeto que se comporta de maneira diferente dependendo do seu estado atual, você tem uma quantidade enorme de estados, e o código destes estados mudam frequentemente;</li><li>Quando você tem uma classe poluída com incontáveis estruturas condicionais que decide qual será o comportamento da classe de acordo com os valores correntes nas variáveis e propriedades desta classe (similar ao padrão “<a href="https://www.linkedin.com/pulse/padr%C3%A3o-comportamental-strategy-s%C3%A9rie-design-patterns-r-woelke-/?lipi=urn%3Ali%3Apage%3Ad_flagship3_publishing_published%3BlOH3zzKUQQO9ZTE348m4mg%3D%3D">Strategy</a>”);</li><li>Quando você tem muito código duplicado entre similares estados e transições entre estado e outro e que as mudanças se dão por uma estrutura condicional;</li></ul><h3>Prós e contras</h3><p>As vantagens desta abordagem são:</p><ul><li><strong>Aplicação prática da letra “S” dos princípios SOLID (“Single Responsibility Principle”)</strong>: Assim você estará organizando o código para cada ação a ser executada dependendo do estado, em classes separadas, criadas para este fim;</li><li><strong>Aplicação prática da letra “O” dos princípios SOLID (“Open/Closed Principle”)</strong>: Dessa forma, é possível introduzir novos estados sem alterar o contexto ou as classes existentes;</li><li>Simplificação do código do contexto, eliminando as estruturas de if’s e switch case’s para tomada de decisões estruturais do sistema;</li></ul><p>Como ressalva, assim como no padrão “Strategy”, esta abordagem pode ser contraproducente se a quantidade de estados a administrar seja pequena, e se estes poucos estados raramente sofrem alterações.</p><p>Espero que tenham gostado deste artigo.</p><p>Fiquem à vontade para ver o repositório com este e demais exemplos de padrões de projetos implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a></p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20b7571d1c50" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Padrão comportamental Template Method (Série Design Patterns)]]></title>
            <link>https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-template-method-s%C3%A9rie-design-patterns-69e4bc5aacc4?source=rss-7f8342a15dfc------2</link>
            <guid isPermaLink="false">https://medium.com/p/69e4bc5aacc4</guid>
            <category><![CDATA[behavioral-design-pattern]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[object-oriented-program]]></category>
            <category><![CDATA[template-method-pattern]]></category>
            <dc:creator><![CDATA[Guilherme Woelke]]></dc:creator>
            <pubDate>Sat, 29 Jul 2023 18:14:14 GMT</pubDate>
            <atom:updated>2023-07-29T18:14:14.686Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*Vfc6ODYrCM6ZLxL4wRDKuA.png" /><figcaption>Imagem retirada de <a href="https://refactoring.guru/design-patterns/template-method">https://refactoring.guru/design-patterns/template-method</a></figcaption></figure><p>Olá caro seguidor!</p><p>Dando continuidade à nossa série, vou apresentar a vocês o padrão comportamental “<strong>Template Method</strong>”, reduzindo quando possível a quantidade de código a ser digitada.</p><p>Como os demais artigos, a estrutura segue:</p><ul><li><strong>O cenário</strong>: descreverá uma situação hipotética (uma funcionalidade necessária a uma regra de negócio do sistema);</li><li><strong>O desenvolvimento da solução sem o padrão</strong>: o jeito que faríamos normalmente, sem a aplicação do padrão (só o código suficiente para a entrega da funcionalidade);</li><li><strong>Problemas</strong>: as implicações e problemas que enfrentaríamos ao longo da evolução do sistema, sem a adoção da aplicação do padrão;</li><li><strong>A solução</strong>: a aplicação do padrão e os ganhos que obtivemos no exemplo ao aplicar o padrão;</li><li><strong>Indicações</strong>: Onde que a implementação adotando este padrão se mostra adequada;</li><li><strong>Prós e contras</strong>: Um paralelo mostrando as vantagens e desvantagens (ou ressalvas) de se utilizar este padrão;</li></ul><h3>O Cenário</h3><p>Prosseguiremos com o mesmo cenário do artigo sobre o padrão “<a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-chain-of-responsability-s%C3%A9rie-design-patterns-ed43ce38f852?source=user_profile---------0----------------------------">Chain of Responsability</a>”, onde um desconto pode ser aplicado comparando características diversas e não-correlatas de um orçamento.</p><h3>O desenvolvimento da solução sem o padrão</h3><p>Como este padrão é apenas uma continuação das melhorias de código, tomei como base a solução via classe abstrata para a evolução da refatoração. Para encurtar este artigo (no sentido de não ter que copiar e colar o mesmo código aqui novamente, te convido a acessar o artigo (e tomar como base o código da “solução via classe abstrata”) clicando <a href="https://medium.com/@guilherme_wolke/padr%C3%A3o-comportamental-chain-of-responsability-s%C3%A9rie-design-patterns-ed43ce38f852?source=user_profile---------0----------------------------">aqui</a>.</p><h3>Problemas</h3><p>Nota-se que (estou presumindo que você está vendo o código implementado em outro artigo) para todas as classes especializadas, o passo a passo de todas as implementações do método “calcular”, presente nas classes cujos objetos fazem parte da corrente é:</p><ul><li>Verificar se a regra para o desconto foi satisfeita;</li><li>Realizar o cálculo;</li></ul><p>Se pudéssemos pensar em uma forma de manter esta funcionalidade, tornando este código menos repetitivo (por exemplo, se em um único lugar estas sequências padronizadas pudessem ser executadas, e só as particulariedades de cada classe precisassem ser implementadas), seria muito interessante, concorda?</p><h3>A solução</h3><p>Se isolarmos os (neste caso) 2 passos que este método “calcular” executa, podemos extrair 2 funções:</p><ul><li><strong>deveAplicarODesconto</strong>: faz a verificação, e retorna true caso as condições sejam satisfeitas, e false em caso contrário;</li><li><strong>efetuarCalculo</strong>: efetua o cálculo simplesmente;</li></ul><p>Neste padrão, a classe abstrata Desconto será responsável por “orquestrar” a execução sequencial destes dois passos, cuja implementação destes passos será delegada às subclasses.</p><p>Vejamos como ficam as classes da corrente, com esta nova abordagem abaixo (as implementações respectivamente presentes em CalculadoraDeDescontos.java, Orcamento.java e Main.java não sofrerão alterações neste padrão):</p><p>Classe <em>Desconto.java</em></p><pre>package templateMethod.solution;<br><br>import java.math.BigDecimal;<br><br>public abstract class Desconto {<br>    protected Desconto proximo;<br><br>    public Desconto(Desconto proximo) {<br>        this.proximo = proximo;<br>    }<br><br>    protected BigDecimal calcular(Orcamento orcamento) {<br>        if (deveAplicarDesconto(orcamento)) {<br>            return efetuarCalculo(orcamento);<br>        }<br><br>        return proximo.calcular(orcamento);<br>    }<br><br>    protected abstract BigDecimal efetuarCalculo(Orcamento orcamento);<br>    protected abstract boolean deveAplicarDesconto(Orcamento orcamento);<br>}</pre><p>As alterações foram as seguintes:</p><ul><li>Criamos 2 métodos abstratos protegidos, com os 2 passos que isolamos: deveAplicarDesconto (que recebe um orçamento e retorna um valor booleano), e efetuarCalculo (que recebe um orçamento, aplica o cálculo do desconto sobre o valor do orçamento, e devolve este valor), forçando as classes especializadas a implementarem seus respectivos comportamentos;</li><li>O método “calcular”, que outrora era abstrato e tinha como objetivo forçar as classes especializadas a verificar se o desconto era devido e calcular o valor, à partir de agora ela passa a ser um método concreto, que se responsabiliza por efetuar o cálculo de desconto da instância atual (se o retorno do método deveAplicarDesconto for true), ou chamar o próximo elo da corrente e realizar a mesma ação (caso o retorno for false);</li></ul><p>Classe <em>DescontoPorQuantidadeDeItens.java</em></p><pre>package templateMethod.solution;<br><br>import java.math.BigDecimal;<br><br>public class DescontoPorQuantidadeDeItens extends Desconto {<br>    public DescontoPorQuantidadeDeItens(Desconto proximo) {<br>        super(proximo);<br>    }<br><br>    @Override<br>    public boolean deveAplicarDesconto(Orcamento orcamento) {<br>        return orcamento.getQuantidadeItens() &gt; 5;<br>    }<br><br>    public BigDecimal efetuarCalculo(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.1&quot;));<br>    }<br>}</pre><p>O método calcular foi substituído pelos 2 métodos abstratos da superclasse Desconto, e implementa a lógica para determinar se o desconto é aplicável (deveAplicarDesconto), e também o cálculo do desconto (efetuarCalculo).</p><p>Classe <em>DescontoPorValorDoOrcamento.java</em></p><pre>package templateMethod.solution;<br><br>import java.math.BigDecimal;<br><br>public class DescontoPorValorDoOrcamento extends Desconto {<br>    public DescontoPorValorDoOrcamento(Desconto proximo) {<br>        super(proximo);<br>    }<br><br>    public BigDecimal efetuarCalculo(Orcamento orcamento) {<br>        return orcamento.getValor().multiply(new BigDecimal(&quot;0.05&quot;));<br>    }<br><br>    @Override<br>    public boolean deveAplicarDesconto(Orcamento orcamento) {<br>        return orcamento.getValor().compareTo(new BigDecimal(&quot;500.0&quot;)) &gt; 0;<br>    }<br>}</pre><p>Idem à classe anterior.</p><p>Classe <em>SemDesconto.java</em></p><pre>package templateMethod.solution;<br><br>import java.math.BigDecimal;<br><br>public class SemDesconto extends Desconto {<br>    public SemDesconto() {<br>        super(null);<br>    }<br><br>    @Override<br>    public BigDecimal efetuarCalculo(Orcamento orcamento) {<br>        return BigDecimal.ZERO;<br>    }<br><br>    @Override<br>    public boolean deveAplicarDesconto(Orcamento orcamento) {<br>        return true;<br>    }<br>}</pre><p>Idem à classe anterior, exceto por retornar true invariavelmente, uma vez que é sempre o último objeto da corrente.</p><h3>Indicações</h3><ul><li>Use este padrão quando você deseja que os “clients” extendam apenas passos particulares de um algoritmo, e não todo o algoritmo ou estrutura;</li><li>Use este padrão quando, apesar de diferentes ações a serem executadas, você perceber que estas ações tem uma sequência de passos padronizados, com diferenças pequenas (neste caso, todas tinham uma sequência similar de verificação se caberia desconto, e posterior cálculo deste desconto) entre si. Como resultado, você pode agora precisar alterar todas as classes quando o algoritmo mudar;</li></ul><h3>Prós e contras</h3><p>Seguem abaixo as vantagens desta abordagem:</p><ul><li>Você pode deixar que clientes sobrescrevam apenas certas partes de um algoritmo grande, causando menos impacto por alterações que acontecem em outras partes do algoritmo;</li><li>Você pode deixar um código que seria duplicado em várias classes, em uma única implementação na superclasse (o método calcular por exemplo, que é herdado pelas subclasses);</li></ul><p>Ressalvas quanto ao uso deste padrão:</p><ul><li>Alguns “clients” podem ficar limitados pelo “skeleton” pré-determinado de um algoritmo;</li><li>A liberdade concedida em face da delegação às classes especializadas por parte da superclasse abre margem para a violação do princípio descrito na letra “L” dos princípios SOLID (Liskov Substitution Principle), uma vez que não há nenhum um controle sobre o comportamento das classes especializadas;</li><li>A dificuldade de manutenção dos templates de métodos é proporcional à quantidade de passos descritos (quanto mais passos forem necessários para executar a funcionalidade, mais difícil será a manutenção desta estrutura);</li></ul><p>Espero que tenham gostado deste artigo.</p><p>Fiquem à vontade para ver o repositório com este e demais padrões de projeto implementados nesta série de artigos em meu github: <a href="https://github.com/guilhermewolke/java-design-patterns-series">https://github.com/guilhermewolke/java-design-patterns-series</a>.</p><p>Obrigado e até semana que vem!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69e4bc5aacc4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>