<?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 João Victor on Medium]]></title>
        <description><![CDATA[Stories by João Victor on Medium]]></description>
        <link>https://medium.com/@jvoliveiran?source=rss-3ef378412346------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*6YfKOA8mVD625xQ8M5bB6Q@2x.jpeg</url>
            <title>Stories by João Victor on Medium</title>
            <link>https://medium.com/@jvoliveiran?source=rss-3ef378412346------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:31:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jvoliveiran/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[Micronaut x Spring Boot: Uma análise comparativa de desenvolvimento, desempenho e consumo de…]]></title>
            <link>https://medium.com/@jvoliveiran/micronaut-x-spring-boot-uma-an%C3%A1lise-comparativa-de-desenvolvimento-desempenho-e-consumo-de-5b055169129b?source=rss-3ef378412346------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b055169129b</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[micronaut]]></category>
            <dc:creator><![CDATA[João Victor]]></dc:creator>
            <pubDate>Wed, 12 Jun 2019 22:15:13 GMT</pubDate>
            <atom:updated>2019-06-12T22:15:13.264Z</atom:updated>
            <content:encoded><![CDATA[<h3>Micronaut x Spring Boot: Uma análise comparativa de desenvolvimento, desempenho e consumo de recursos.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uZK9RpB-14klRI5PyEkF-w.png" /><figcaption>Logo do Micronaut e Spring Boot, respectivamente</figcaption></figure><h3>Histórias anteriores</h3><ul><li><a href="https://medium.com/@jvoliveiran/micronaut-uma-vis%C3%A3o-geral-1f640c5a7ad4">Micronaut: Uma visão geral</a></li><li><a href="https://medium.com/@jvoliveiran/primeiros-passos-com-micronaut-da764ac3e288">Primeiros passos com Micronaut</a></li></ul><h3>Introdução</h3><p>O Spring domina a área de aplicações web desenvolvidas com Java devido a facilidade e agilidade no desenvolvimento, graças a grande quantidade de módulos existente no framework.</p><p>No entanto, o Spring deixa a desejar em algumas questões como o consumo de recursos e tempo de startup da aplicação. Esses fatores negativos têm um peso significativo se pensarmos em aplicações que utilizam IaaS (<em>Infrastructure as a Service</em>), como AWS, Azure, Google Cloud, dentre outras, uma vez que essas plataformas cobram pela quantidade de recursos consumidos.</p><p>Será que vale abrir mão da facilidade de desenvolvimento que o Spring provê para adotar soluções que consomem menos recursos e têm um menor tempo de startup? E se existir uma solução tão simples quanto o Spring mas que apresentem um melhor desempenho?</p><h3>Objetivo</h3><p>Este artigo tem como objetivo realizar uma análise comparativa entre o Spring Boot e o Micronaut, através de um experimento onde foram criadas três versões de uma mesma API simples, com apenas dois <em>endpoints</em>, onde uma versão utiliza Spring Boot, outra versão utiliza Micronaut e a última versão também utiliza o Micronaut, mas será compilada para <em>native.</em></p><p>A comparação entre os frameworks será feita em duas partes, na primeira parte serão abordados aspectos relativos ao desenvolvimento, comparando como as APIs foram criadas e mostrando as semelhanças entre o Spring e o Micronaut a nível de código. Na segunda fase serão comparados aspectos relativos a desempenho, como tempo de startup das aplicações, consumo de memória, tamanho final dos executáveis e tempo de build para cada projeto.</p><p>Por fim serão apresentados os resultados do estudo comparativo e, como nem tudo tem apenas aspectos positivos, também serão apresentados os problemas enfrentados durante a realização deste experimento.</p><h3>Descrição da API</h3><p>Para este experimento, a API que será implementada terá apenas os seguintes <em>endpoints</em>:</p><pre>GET /greetings<br>GET /greetings/{name}</pre><p>O response terá o seguinte formato:</p><pre>{<br> message: String,<br> date: Long<br>}</pre><p>Onde o campo <em>message </em>irá retornar uma mensagem simples de saudação e o campo <em>date </em>terá o <em>timestamp</em> no qual a mensagem foi gerada.</p><p>As aplicações criadas nesse experimento terão os mesmo artefatos. Uma classe de domínio chamada <em>Greeting </em>que será utilizada para gerar o <em>response. </em>Para mapear os <em>endpoints</em> citados anteriormente, será utilizada a classe <em>GreetingsController </em>que receberá, através de injeção de dependência, a classe <em>GreetingsService,</em> responsável por montar o objeto <em>Greetings, </em>que será retornado ao <em>controller</em>.</p><h3>Criação dos projetos</h3><p>Antes de iniciar a implementação dos três projetos (Spring Boot, Micronaut e Micronaut compilado para nativo) é necessário criar os projetos, e cada um deles tem algumas particularidades.</p><p>O primeiro projeto criado será o projeto utilizando Spring Boot. Para isso, será utilizado o <a href="https://start.spring.io/">Spring Initializr</a>. A imagem abaixo mostra a configuração utilizada no Spring Initializr para a criação deste projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5SlFMTgzYzCSTBhbZDji8A.png" /><figcaption>Criação do projeto Spring utilizando Spring Initializr</figcaption></figure><p>Basta clicar no botão <em>&quot;Generate Project&quot; </em>para realizar o download do projeto e então executar o seguinte comando no terminal, na raiz do projeto, para instalar as dependências.</p><pre>$ mvn clean compile</pre><p>Criado o primeiro projeto, agora é necessário criar os dois projetos do Micronaut. Para esses projetos será utilizado o Micronaut CLI. Caso ainda não tenha este CLI instalado, na <a href="https://medium.com/@jvoliveiran/primeiros-passos-com-micronaut-da764ac3e288">história anterior</a> é possível verificar como é feita a instalação do mesmo.</p><p>Para criar o projeto do Micronaut rodando na JVM, utilize o seguinte comando no terminal</p><pre>$ mn create-app com.jvoliveira.greetings-micronaut -b maven</pre><p>Este comando irá criar uma pasta &quot;<em>greetings-micronaut&quot;</em> contendo os arquivos do projeto. Acesse esta pasta e execute o mesmo comando utilizado anteriormente no projeto Spring para instalar as dependências.</p><p>Por fim, resta a criação do projeto do Micronaut compilado para nativo. Da mesma forma que no projeto Micronaut para JVM, utilizaremos o Micronaut CLI para criação do projeto. O comando para este projeto será:</p><pre>$ mn create-app com.jvoliveira.greetings-micronaut-native -f graal-native-image -b maven</pre><p>Para instalar as dependências, basta utilizar o mesmo comando do maven utilizado nos projetos anteriores.</p><h3>Implementação da API</h3><p>Para comparar o desenvolvimento de uma API utilizando Spring e outra utilizando Micronaut, está seção irá apresentar o desenvolvimento das aplicações de forma paralela, começando pelo arquivo de configuração da aplicação (<em>application) </em>e depois implementando as classes <em>Greetings, GreetingsService </em>e <em>GreetingsController.</em></p><p>Para esta seção será abordada apenas a comparação entre Spring e Micronaut, visto que não existe diferença entre a implementação do Micronaut para JVM e <em>native. </em>A diferença entre ambos será apresentada mais a frente.</p><p>A configuração dos projetos será feita através do arquivo <em>application, </em>que existe tanto no projeto Spring quanto nos projetos Micronaut. No Spring será utilizada a extensão <em>.properties </em>e no Micronaut a extensão .<em>yml </em>para este arquivo<em>.</em> Ambos os projetos aceitam essas duas extensões.</p><p>O arquivo abaixo está sendo utilizado para configurar a aplicação Spring:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/959ec37ce5de512840da19bfee88b219/href">https://medium.com/media/959ec37ce5de512840da19bfee88b219/href</a></iframe><p>E este é o arquivo de configuração do projeto Micronaut:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ecbe0f2330416eea4d2b1949fe82eb12/href">https://medium.com/media/ecbe0f2330416eea4d2b1949fe82eb12/href</a></iframe><p>Ambos os projetos foram configurados para serem executados na porta 8085 e possuem a propriedade <em>greetings.message.default, </em>uma propriedade específica para a aplicação que está sendo criada.</p><p>O desenvolvimento da classe de domínio <em>Greetings </em>não difere entre as aplicações Spring e Micronaut<em>, </em>já que basicamente é um <a href="https://pt.wikipedia.org/wiki/Plain_Old_Java_Objects">POJO</a> contendo dois campos, a mensagem e o <em>timestamp</em> referente a data de criação da mensagem.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5af66dc102edba9df48daa09d914cdba/href">https://medium.com/media/5af66dc102edba9df48daa09d914cdba/href</a></iframe><p>A próxima classe a ser criada será o <em>GreetingsService, </em>que será um <em>bean </em>responsável por construir o objeto <em>Greeting</em>. A implementação abaixo foi feita para o projeto Spring.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/87aff467edbe5475e26c7322b4bf5bff/href">https://medium.com/media/87aff467edbe5475e26c7322b4bf5bff/href</a></iframe><p>Nesta implementação, a classe <em>GreetingsService </em>foi definida como um <em>bean </em>através da anotação <em>Service, </em>um estereotipo da anotação <em>Component </em>indicando que este <em>bean </em>faz parte da camada de negócio da aplicação. Este <em>bean </em>possui a propriedade <em>defaultMessage, </em>que através da anotação <em>Value </em>recebe o valor definido na propriedade <em>greetings.message.default, </em>definida no arquivo <em>application.properties. </em>O restando do código é apenas código Java para construir uma instância do objeto <em>Greetings.</em></p><p>A classe <em>GreetingsService </em>foi implementada no projeto Micronaut da seguinte forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/281d1d2c9165ef2ef82ebec5f1d62c5d/href">https://medium.com/media/281d1d2c9165ef2ef82ebec5f1d62c5d/href</a></iframe><p>A implementação da classe <em>GreetingsService </em>no projeto Micronaut difere do projeto Spring apenas pela anotação utilizada para definir esta classe como um <em>bean. </em>Ao invés de utilizar a anotação <em>Service </em>do Spring, é utilizada a anotação <em>Singleton, </em>que intuitivamente faz com que esse <em>bean </em>tenha uma única instância, criada pelo Micronaut, já que se trata de um <a href="https://en.wikipedia.org/wiki/Singleton_pattern"><em>singleton</em></a><em>. </em>O restante do código não difere em nada da implementação para o projeto Spring, nem mesmo a forma como obter valores definidos no arquivo de configuração da aplicação, através da anotação <em>Value.</em></p><p>Por fim, resta a implementação da classe <em>GreetingsController, </em>que será responsável por mapear as duas rotas existentes na aplicação. A implementação abaixo foi utilizada no projeto Spring.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0b207b6747bd98697be1ab8ac473f318/href">https://medium.com/media/0b207b6747bd98697be1ab8ac473f318/href</a></iframe><p>A anotação <em>RestController </em>faz da classe <em>GreetingsController </em>um <em>bean </em>através deste estereotipo, indicando que se trata de um <em>controller </em>para uma API Rest. Esta classe tem como dependência o <em>GreetingsService, </em>que é injetado no construtor deste <em>controller</em>. Essa injeção de dependência é realizada de forma implícita pelo Spring, mas pode ser feita de forma explícita utilizando a anotação <em>Autowired </em>no construtor ou diretamente no atributo <em>service.</em> Além do construtor, existem dois outros métodos responsáveis por mapear as duas rotas existentes na API. O mapeamento é realizado pela anotação <em>GetMapping </em>que recebe como argumento o <em>endpoint</em> desejado. O retorno do método é um objeto do tipo <em>ResponseEntity </em>que permite, além de definir o corpo da <em>response,</em> também permite definir status, cabeçalhos, dentre outras informações.</p><p>Para o projeto <em>greetings-micronaut </em>a implementação da <em>GreetingsController </em>é apresentada abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/829c5320902aa199b91749886392231f/href">https://medium.com/media/829c5320902aa199b91749886392231f/href</a></iframe><p>A implementação do <em>GreetingsController </em>é quase idêntica ao projeto Spring, a diferença fica para a anotação <em>Controller, </em>que também existe no Spring. Além disso a anotação que mapeia os <em>endpoints</em> no Micronaut é mais simples e intuitiva do que no Spring, sendo composta apenas pelo verbo HTTP utilizado, neste caso foi utilizada a anotação <em>Get. </em>A última diferença encontrada fica para o objeto de resposta, que no Spring temos o <em>ResponseEntity </em>e no Micronaut pode ser substituído pelo objeto <em>HttpResponse.</em></p><p>Da mesma forma que no Spring, o Micronaut realiza a injeção de dependência de forma implícita, sem precisar declarar explicitamente uma anotação para tal. Também é possível realizar a injeção de dependência de forma explícita, através da anotação <em>Inject, </em>seguindo a especificação <em>JSR-330, </em>também conhecida como <a href="https://docs.oracle.com/javaee/7/tutorial/cdi-basic.htm">CDI ou <em>Context and Dependency Injection</em></a><em>.</em></p><p>Para executar a aplicação <em>greetings-spring </em>via terminal, o comando utilizado é:</p><pre>$ mvn spring-boot:run</pre><p>E para o projeto <em>greetings-micronaut, </em>o comando utilizado é:</p><pre>$ mvn exec:exec</pre><p><strong>Atenção: </strong>Ambas as aplicações foram configuradas para escutar a porta 8085. Iniciar ambas as aplicações simultaneamente, sem modificar as configurações de porta realizadas previamente, irá causar erro ao subir as aplicações devido ao conflito de portas.</p><h3>Configurações específicas para Micronaut Native</h3><p>O processo de compilação do Micronaut para <em>native </em>tem algumas particularidades se comparado com os outros dois projetos executados na JVM, que podem ser facilmente iniciados com o auxílio do <em>Maven.</em> <a href="https://guides.micronaut.io/micronaut-creating-first-graal-app/guide/index.html">Aqui</a> segue um guia oficial de como compilar a aplicação para código nativo, já que isto requer uma JVM específica (GraalVM) e algumas outras configurações auxiliares.</p><p>Para gerar um executável nativo, já tendo instalado a GraalVM e o native-image (recomendo o <a href="https://sdkman.io/">SDKMAN</a> para isso), basta executar o seguinte comando na raiz do projeto</p><pre>$ native-image — no-server -cp target/greetings-micronaut-native-*.jar</pre><p>O comando acima irá gerar o executável <em>greetings-micronaut-native. </em>Para iniciar a aplicação, basta executa-lá da mesma forma que um app nativo para o SO utilizado.</p><pre>$ ./greetings-micronaut-native</pre><h3>Comparando desempenho e consumo de recursos</h3><p>Sabendo que ambos os projetos, Spring e Micronaut, fazem exatamente a mesma coisa, é possível realizar alguns testes de desempenho e consumo de recursos de forma mais justa e assertiva.</p><h4>Startup</h4><p>O primeiro comparativo será com o tempo de startup. Iniciando cada uma das aplicações via terminal, o tempo de startup apresentado foi:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FWyvdGQOP7sUh0rG15hOUw.png" /><figcaption>Startup da aplicação greetings-spring, desenvolvida com Spring Boot</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tkbcIt4DsMYmQsyGpGd9xQ.png" /><figcaption>Startup da aplicação greetings-micronaut, desenvolvida com Micronaut para JVM</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L4pR-6Z_6j-CFtC1WGvYcw.png" /><figcaption>Startup da aplicação greetings-micronaut, desenvolvida com Micronaut compilada para código nativo</figcaption></figure><p>Neste primeiro comparativo, a aplicação desenvolvida com Micronaut para JVM tem um tempo de startup de 6,3 segundos, enquanto a aplicação desenvolvida com Spring inicializou depois de 16,5 segundos. Já a aplicação Micronaut compilada para nativo inicia em apenas 108 milisegundos.</p><h4>App size</h4><p>O próximo comparativo realizado é sobre o tamanho dos executáveis de cada aplicação. Tanto a aplicação Micronaut para JVM quanto a aplicação Spring geram um arquivo <em>jar</em> como executável, enquanto o Micronaut compilado para nativo gera uma executável de acordo com o SO utilizado para compilar o projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/1*hmEjZKZ6q2TtfsKcBbswlw.png" /><figcaption>Tamanho do executável para o projeto greetings-spring</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/802/1*4CHpD_aAq9_wRnkeZn-FFA.png" /><figcaption>Tamanho do executável para o projeto greetings-micronaut, executado na JVM</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/696/1*GkQMffxpl3QW20m-pwcilA.png" /><figcaption>Tamanho do executável para o projeto greetings-micronaut-native, compilado para nativo e executado fora da JVM.</figcaption></figure><p>O executável gerado para o projeto <em>greetings-spring, </em>utilizando Spring Boot, possui 16MB de tamanho. Já o projeto <em>greetings-micronaut </em>sendo executado na JVM possui 12MB de tamanho. Por fim, o projeto <em>greetings-micronaut-native, </em>compilado para código nativo, possui 53MB de tamanho.</p><h4>Tempo de Build</h4><p>Esse aspecto avalia o tempo necessário para compilar o projeto e gerar um executável da aplicação.</p><p>Para calcular o tempo de build dos projetos Spring e Micronaut para JVM, basta utilizar o comando abaixo:</p><pre>$ mvn clean package</pre><p>Este comando gera um executável da aplicação e informa o tempo desse processo.</p><p>Para a aplicação Micronaut Native o comando utilizado é:</p><pre>$ native-image — no-server -cp target/greetings-micronaut-native-*.jar</pre><p>Seguem os resultados obtidos referente ao tempo de build de cada projeto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rwk_L0Gie--bxFQFTqulWQ.png" /><figcaption>Tempo de build para o projeto greetings-spring, utilizando Spring Boot</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q3lSUuWrfDk_EWxIIQUP3w.png" /><figcaption>Tempo de build para o projeto greetings-micronaut, utilizando Micronaut compilado para rodar na JVM</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/877/1*Rn0VUnMERV9QyHb82IdWOw.png" /><figcaption>Tempo de build para o projeto greetings-micronaut-native, utilizando Micronaut compilado para rodar nativamente.</figcaption></figure><h4>Consumo de memória e CPU</h4><p>Para esse comparativo serão criadas três imagens docker diferentes, uma para cada aplicação, utilizando a mesma imagem base. O Dockerfile para o projeto <em>greetings-micronaut-native </em>já é criado no momento da criação deste projeto, ao adicionar a dependência <em>graal-native-image.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/75a9ee5cd87fb09432454336920fd214/href">https://medium.com/media/75a9ee5cd87fb09432454336920fd214/href</a></iframe><p>Para os projetos <em>greetings-micronaut </em>e <em>greetings-spring, </em>foi utilizada a mesma imagem base para ambos, de acordo com os dockerfiles a seguir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c16fa632af5bf5676d4ce48a5f143c0d/href">https://medium.com/media/c16fa632af5bf5676d4ce48a5f143c0d/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ce7e058422009bf1244e400e651c8736/href">https://medium.com/media/ce7e058422009bf1244e400e651c8736/href</a></iframe><p>Após criar a imagem de cada projeto, é possível iniciar um <em>container</em> para cada nova imagem criada. Através do comando abaixo, é possível ver os recursos consumidos por cada <em>container</em> em execução:</p><pre>$ docker stats </pre><p>O consumo de recursos para os <em>containers</em> em execução pode ser visto na imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yik6LxclVw1hSgoyrA3psQ.png" /><figcaption>Consumo de recurso dos três containers em execução simultaneamente.</figcaption></figure><p>Na imagem acima os <em>containers</em> estão em execução mas as aplicações não estão recebendo requisições, apenas foram iniciadas.</p><p>O primeiro <em>container</em> da lista, seguindo a ordem de cima para baixo, está executando a aplicação criada com Spring Boot e está consumindo 64MB de memória e 0.79% de CPU. O <em>container</em> seguinte está executando a aplicação Micronaut rodando na JVM e consumindo 45MB de memória e 0.06% de CPU. Por último, a aplicação desenvolvida com Micronaut compilado para código nativo, consumindo 10MB de memória e 0.01% de CPU.</p><h3>Resultados</h3><p>Comparando os dois frameworks, Micronaut e Spring Boot, os dois apresentam várias semelhanças em termos de código. Em ambos os frameworks é fácil iniciar um novo projeto e desenvolver uma API, permitindo que desenvolvedores já ambientados ao framework da Pivotal não sintam dificuldades ao se adaptar com o Micronaut. Algumas anotações serão um pouco diferentes, mas nada que exija muito de quem já conhece e utiliza o Spring.</p><p>Analisando o consumo de recursos que foram avaliados nessa história, o Micronaut sendo executado na JVM se mostrou mais eficiente que o Spring nos aspectos de consumo de memória e CPU, tempo de startup da aplicação, tempo de build e tamanho do executável final.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*7nxRb9jcq_N1Sy8JE6yOmw.png" /><figcaption>Comparativo para tempo de startup das aplicações.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*fJSxqWBdHYlKYOa_y-zjMg.png" /><figcaption>Tamanho final dos executáveis.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*53ZbMNubr04yXHKMrp2bJw.png" /><figcaption>Consumo de memória RAM para apps rodando em containers Docker.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*N91GP1ctPPKiywK2bFFuoQ.png" /><figcaption>Tempo de Build para gerar os executáveis dos projetos.</figcaption></figure><h3>Problemas enfrentados</h3><p>Durante a realização deste experimento foram identificados alguns problemas/dificuldades que valem a pena serem compartilhados.</p><p>Os principais problemas foram relacionados ao processo de build do Micronaut para gerar um executável nativo. Este processo é bem mais demorado que o processo de build convencional utilizando Maven, e além disso requer mais recursos (memória) do <em>host </em>que está criando o app nativo.</p><p>O Dockerfile que é criado junto do projeto <em>micronaut-greetings-native </em>cria um container docker específico para realizar o build do app nativo, e pelo fato desse processo consumir muita memória, poderá levar a um erro de <em>Out of Memory </em>ao executar esse procedimento no MacOS, uma vez que nesse SO o Docker é executado dentro de uma VM que limita o consumo de memória do Docker para 2GB, sendo insuficiente para realizar o processo de build. Atualmente permito que o Docker use até 8GB de RAM do <em>host </em>e não tive mais problemas de memória no processo de build.</p><h3>Conclusão</h3><p>A versão da API utilizando o Micronaut compilado para código nativo mostrou resultados bem divergentes se comparado com a versão utilizando Spring Boot e Micronaut para JVM. Com código nativo é possível ter uma aplicação que inicia muito mais rápido que outras aplicações desenvolvidas neste experimento, quase que instantaneamente, e apresenta consumo de memória e CPU muito menor que as outras aplicações. Em contrapartida, o tempo para criar um executável da aplicação é muito superior as aplicações Spring e Micronaut para JVM, além do executável gerado ter um tamanho consideravelmente maior que os outros projetos executados na JVM.</p><p>O Micronaut vem se mostrando bastante estável, com uma <a href="https://docs.micronaut.io/snapshot/guide/index.html">documentação</a> detalhada, e esse experimento demonstrou as várias vantagens que o Micronaut tem frente ao Spring, sem perder a facilidade no desenvolvimento, característica marcante que tornou o Spring tão popular. Usar o Micronaut rodando na JVM traz ganhos significativos se comparado ao Spring, mas o uso do Micronaut compilado para código nativo irá potencializar muito alguns fatores já citados, porém isso leva a um <em>trade-off </em>que precisa ser considerado ao optar pelo uso de código nativo.</p><h3>Referências</h3><ul><li>Micronaut Graal Application — <a href="https://guides.micronaut.io/micronaut-creating-first-graal-app/guide/index.html">https://guides.micronaut.io/micronaut-creating-first-graal-app/guide/index.html</a></li><li>Micronaut Documentation — <a href="https://micronaut.io/documentation.html">https://micronaut.io/documentation.html</a></li><li>Micronaut Guides — <a href="https://guides.micronaut.io/">https://guides.micronaut.io/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b055169129b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primeiros passos com Micronaut]]></title>
            <link>https://medium.com/@jvoliveiran/primeiros-passos-com-micronaut-da764ac3e288?source=rss-3ef378412346------2</link>
            <guid isPermaLink="false">https://medium.com/p/da764ac3e288</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[micronaut]]></category>
            <dc:creator><![CDATA[João Victor]]></dc:creator>
            <pubDate>Thu, 23 May 2019 19:54:24 GMT</pubDate>
            <atom:updated>2019-05-24T14:33:34.239Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*UeHV1PMWJX3qsGlc9LEsnA.png" /></figure><p>Na <a href="https://medium.com/@jvoliveiran/micronaut-uma-vis%C3%A3o-geral-1f640c5a7ad4">história anterior</a><strong> </strong>expliquei a motivação para o surgimento do Micronaut e o que esse framework trás de inovador para competir com gigantes como o Spring. Caso ainda não tenha lido essa artigo, recomendo a leitura (<a href="https://medium.com/@jvoliveiran/micronaut-uma-vis%C3%A3o-geral-1f640c5a7ad4"><strong>link</strong></a>) para entender melhor alguns conceitos por trás desse framework que vem se destacando no mundo Java.</p><p>Agora que já temos vários conceitos apresentados, vamos fazer alguns experimentos simples para descobrir na prática se o Micronaut consegue ser tão simples como os seus concorrentes.</p><p>Caso queira pular toda a explicação e ir direto ao código, <a href="https://github.com/jvoliveiran/hello-micronaut"><strong>aqui</strong></a><strong> </strong>está o link do projeto no GitHub.</p><h3>Pré-requisitos</h3><p>Antes de começarmos, certifique-se de ter instalado na sua máquina as seguintes ferramentas:</p><ul><li>JDK 1.8+</li><li>Maven(preferencialmente) ou Gradle</li><li>Docker</li><li>Package Manager: Homebrew (preferencialmente) ou SDKMAN</li><li>IDE com suporte para Java</li></ul><p>Tudo pronto? Então vamos para a prática</p><h3>Micronaut CLI</h3><p>Para facilitar a criação de novos projetos, o Micronaut dispõe de uma <a href="https://docs.micronaut.io/latest/guide/index.html#cli"><em>Command Line Interface</em> (CLI)</a> bem simples porém bastante útil.</p><p>A instalação dessa ferramenta, em sistemas UNIX, pode ser feita de forma extremamente simples através do <a href="https://brew.sh/">Homebrew</a> ou <a href="https://sdkman.io/">SDKMAN</a>.</p><p>Instalação via Homebrew:</p><pre>$ brew install micronaut</pre><p>Instalação via SDKMAN:</p><pre>$ sdk install micronaut</pre><p>Para confirmar que o Micronaut CLI foi instalado corretamente, execute o seguinte comando no terminal:</p><pre>$ mn --version</pre><p>O comando acima deverá retornar a versão do Micronaut e a versão da JVM instaladas em seu computador. Algo semelhante a isso:</p><pre>| Micronaut Version: 1.1.2</pre><pre>| JVM Version: 1.8.X_XXX</pre><p>Caso tenha dúvidas na instalação, este <a href="https://docs.micronaut.io/latest/guide/index.html#buildCLI"><strong>link</strong></a> para a documentação pode te ajudar.</p><p>Podemos ver a lista dos principais comandos da CLI através do seguinte comando:</p><pre>$ mn --help</pre><p>Segue a lista de comandos , em destaque, e de suas respectivas descrições, exibidos ao executar a instrução acima:</p><ul><li><strong>create-app</strong> : Creates an application</li><li><strong>create-cli-app</strong> : Creates a command line application</li><li><strong>create-federation</strong> : Creates a federation of services</li><li><strong>create-function</strong> : Creates a serverless function application</li><li><strong>create-profile</strong> : Creates a profile</li><li><strong>help</strong> : Prints help information for a specific command</li><li><strong>list-profiles</strong> : Lists the available profiles</li><li><strong>profile-info</strong> : Display information about a given profile</li></ul><p>É necessário que toda instrução seja iniciada com &quot;mn&quot;, da mesma forma que fizemos anteriormente para verificar a versão e para listar os principais comandos da CLI.</p><p>Caso seja executado apenas o comando <em>mn </em>no terminal, é possível executar o Micronaut CLI em modo interativo, que é recomendado para execução de comandos para geração de código, além de possuir auto-complete através da tecla TAB para comandos específicos do Micronaut.</p><pre>$ mn <br>| Starting interactive mode… <br>| Enter a command name to run. Use TAB for completion: <br>mn&gt;</pre><h3>Hello, Micronaut!</h3><p>Chegou a hora de dar os primeiros passos com o Micronaut. E nada mais natural do que começar com o tradicional <em>Hello World.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*YAEZYcbO5IN3mO-7n5onPg.jpeg" /></figure><p>Neste exemplos simples vamos criar um novo projeto utilizando Java com linguagem, Maven para gerenciamento das dependências e build do projeto e por fim vamos criar uma imagem utilizando o Dockerfile gerado pelo Micronaut para rodar nossa aplicação em um container docker.</p><p>Para criar nossa aplicação usaremos o seguinte comando</p><pre>$ mn create-app com.jvoliveira.hello-world -f management,micrometer -b maven</pre><p>Explicando um pouco do comando acima:</p><ul><li><strong>create-app: </strong>cria um projeto <em>web-app</em></li><li><strong>com.jvoliveira.hello-world: </strong>o projeto terá como package base &#39;com.jvolivera&#39; e o nome do projeto será &#39;hello-world&#39;.</li><li><strong>-f : </strong>também poderia ser escrito como --feature, indica quais dependências serão adicionadas ao projeto. Nesse caso incluimos o <em>management </em>para gerenciar alguns endpoints providos pelo micronaut e o <em>micrometer </em>para adicionar algumas informações de métricas relevantes.</li><li><strong>-b: </strong>também poderia ser escrito como --build, indica que utilizaremos o maven para gerenciar as dependências e realizar o build do nosso projeto. Lembrando que o por padrão, caso o comando -b não seja informado, o padrão do Micronaut é utilizar o Gradle.</li></ul><p>Após o maven instalar as devidas dependências ao executar o comando acima, será criada uma nova pasta chamada &#39;hello-world&#39;, que é o nome que demos ao nosso projeto. Entrando na pasta do projeto, você encontrará uma estrutura semelhante a da imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*cIkBo9zKLpHJHkP3Bp8itg.png" /><figcaption>Estrutura inicial do projeto hello-world</figcaption></figure><p>Agora vamos criar um <em>Controller </em>para atender requisições HTTP utilizando o método GET no endpoint<em> /greetings. </em>Para realizar essa tarefa, poderíamos simplesmente criar uma nova classe e escrever nosso método, porém a CLI do Micronaut pode nos ajudar nessa tarefa. Na raiz do projeto <em>hello-world, </em>execute o seguinte comando:</p><pre>$ mn create-controller com.jvoliveira.resource.GreetingsController -l java</pre><p>Esse comando irá gerar uma classe chamada <em>GreetingsController </em>no pacote <em>com.jvoliveira.resource.</em> A classe gerada será semelhante a esta abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/512624727af8b4c7e78764daef51d01e/href">https://medium.com/media/512624727af8b4c7e78764daef51d01e/href</a></iframe><p>Vamos subir nossa aplicação e verificar se o nosso <em>controller </em>funciona. Como muita coisa no Micronaut é resolvida em tempo de compilação, conforme apresentado no <a href="https://medium.com/@jvoliveiran/micronaut-uma-vis%C3%A3o-geral-1f640c5a7ad4">artigo anterior</a><strong> </strong>é recomendado compilar os fontes da aplicação antes de executar a mesma. Utilize o seguinte comando na raiz do projeto para subir a aplicação.</p><pre>$ mvn compile exec:exec</pre><p>Será feito o build do projeto e o mesmo irá subir na porta 8080. Para alterar a porta na qual a aplicação irá subir, basta definir/alterar a seguinte propriedade no arquivo <em>application.yml</em></p><pre>micronaut:</pre><pre>   server:</pre><pre>     port: 8080</pre><p>Agora que nossa aplicação está sendo executado e ouvindo requisições HTTP na porta 8080, vamos realizar uma requisição simples através de uma outra janela no terminal para verificar se o nosso <em>controller</em> está mesmo funcionando. Execute o seguinte comando no terminal:</p><pre>$ curl -v http://localhost:8080/greetings</pre><p>A saída deve ser algo semelhante a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/684/1*U4cC0pG2QeCET2dPk4gJSA.png" /><figcaption>Resultado do comando &#39;curl -v <a href="http://localhost:8080/greetings">http://localhost:8080/greetings</a>&#39;</figcaption></figure><p>Note que o retorno da nossa requisição contém o status 200 OK, justamente o que foi configurado para ser retornado pelo <em>GreetingsController, </em>conforme linha 12 desta classe.</p><p>Além da criação do <em>GreetingsController, </em>o comando <em>create-controller </em>do Micronauto CLI ainda nos dá como bônus a classe de teste <em>GreetingsControllerTest.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9183f278de63086082d1fa420b95847c/href">https://medium.com/media/9183f278de63086082d1fa420b95847c/href</a></iframe><p>Ao executar os testes é importante observar que é iniciada uma instância da aplicação para executar o testes nessa instância. Esse comportamento pode gerar conflito de portas uma vez que a porta utilizada para o teste é a mesma para execução da aplicação realizada previamente. Antes de rodar os testes verifique se não existe nenhuma instância da aplicação em execução.</p><p>Agora vamos evoluir um pouco nosso <em>GreetingsController.</em> No momento temos uma única rota que retorna apenas um status 200. Vamos criar uma nova rota /greetings/{nome} que receberá requisições do tipo GET e irá retornar uma mensagem de boas vindas, para o nome passado na URL.</p><p>Vamos definir nossa nova rota em uma nova <em>interface </em>que será implementada pelo <em>GreetingsController.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/96b59e2d4f7e9e664d53372a707a897d/href">https://medium.com/media/96b59e2d4f7e9e664d53372a707a897d/href</a></iframe><p>Criamos a interface acima para definir novas rotas para o <em>GreetingsController. </em>Temos uma nova rota acessada pelo método GET recebe um parâmetro via URL chamada <em>name</em>. Podemos acessar esse parâmetro programaticamente pelo argumento <em>name </em>do método greeting, onde o Micronaut já faz o <em>binding</em> dos valores de forma automática por terem o mesmo nome. Nosso método greeting retonar um objeto do tipo <em>HttpResponse</em> que recebe uma String como <em>generics</em>. O objeto <em>HttpResponse</em> permite configurar diferentes aspectos da resposta dada pelo server, como status e cabeçalhos.</p><p>O próximo passo é fazer com que o <em>GreetingsController </em>implemente a <em>interface GreetingsControllerRoutes</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/00a338ab12d8fb622b4429cfb9625949/href">https://medium.com/media/00a338ab12d8fb622b4429cfb9625949/href</a></iframe><p>Agora <em>GreetingsController </em>implementa o método <em>greeting </em>definido na interface <em>GreetingControllerRoutes. </em>A implementação desse método é bem simples, apenas retornar um objeto HttpResponse com o status 200 OK e o corpo do <em>response</em> é formado por uma concatenação de Strings.</p><p>Um ponto ainda não explicado até aqui o atributo greeting definido na classe <em>GreetingsController. </em>Você deve estar se perguntando de onde veio esse valor, pois bem, a anotação @Value permite acessar valores definidos no arquivo <em>application.yml.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/efb320f3a8a6e6014d8bb20dfc0cf346/href">https://medium.com/media/efb320f3a8a6e6014d8bb20dfc0cf346/href</a></iframe><p>Note que no <em>application.yml </em>foi definida a propriedade greeting.message, a mesma que está sendo acessada no anotação <em>value</em>.</p><p>Vamos executar novamente nossa aplicação e fazer uma nova requisição. Novamente irei utilizar o <a href="https://curl.haxx.se/"><em>curl</em></a><em> </em>mas caso prefira usar alguma ferramenta para realizar <em>requests </em>como o <a href="https://www.getpostman.com/">Postman</a>, deve funcionar da mesma forma.</p><p>Com a aplicação em execução, execute o seguinte comando:</p><pre>$ curl -v http://localhost:8080/greetings/joao</pre><p>O resultado deve ser algo semelhante a este:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/674/1*JYWYFTLIq8XEeANPmMCVpQ.png" /></figure><p>Note que na última linha é retornada a mensagem &quot;Hello, joao!&quot;. Nosso controller agora tem o comportamento que desejamos, no entanto precisamos evoluir nossos testes para cobrir o novo método criado.</p><p>Na classe <em>GreetingsControllerTest </em>que foi gerada automaticamente pelo Micronaut CLI teste o <em>endpoit </em>/greeting criando um <em>client </em>genérico através do EmbeddedServer injetado na classe de testes. Isso é interessante porque pela primeira vez estamos falando sobre como é feita injeção de dependências no Micronaut, porém o processo de criar um <em>client </em>genérico dessa forma é um pouco mais verboso.</p><p>Vamos tirar proveito da nossa <em>interface GreetingsControllerRoutes </em>para criar um <em>client </em>específico e de forma muito mais simples, que irá facilitar nosso teste.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/832b15a556304cace1dd19c451648111/href">https://medium.com/media/832b15a556304cace1dd19c451648111/href</a></iframe><p>Vamos começar a análise pelos novos atributos. Foi criado o atributo <em>greetingMessage </em>anotado como <em>Value, </em>nada diferente do que fizemos anteriormente. O destaque aqui fica para a <em>interface GreetingsControllerRoutes </em>que foi injetada no nosso teste. Mas espera aí, não existe uma implementação para essa interface! Pois bem, o Micronaut cria a implementação dessa <em>interface </em>durante a compilação, e utiliza como referência a anotação <em>Client, </em>que literalmente cria um <em>client, </em>nesse caso associado a rota <em>/greeting. </em>Essa forma de criar <em>clients </em>é interessante porque incentiva a separação da definição de rotas em <em>interfaces, </em>gerando &quot;contratos&quot;pra API de forma separada de sua implementação. Sem dúvida, uma boa prática.</p><p>Por último, temos nosso novo teste <em>greetingsByNameTest. </em>Agora com a instância do <em>client </em>já em mãos, fica fácil fazer uma requisição ao método <em>greetings </em>passando um nome como argumento do método e obtendo um objeto HttpResponse cujo corpo do response é uma String.</p><h3>Monitoramento</h3><p>No momento que criamos nosso projeto, adicionamos algumas dependências que não foram abordadas até o momento. O Management e o <a href="https://micrometer.io/">Micrometer</a> nos dão outros endpoints que podemos utilizar para obter informações sobre a nossa aplicação.</p><p>Segue lista de endpoints disponíveis:</p><ul><li>/beans— Informações sobre os beans já carregados</li><li>/info— Informações estáticas da aplicação providas ao implementar um bean para <em>InfoSource</em></li><li>/health — Disponibilidade da aplicação</li><li>/metrics — Metricas (disponibilizado pelo Micrometer)</li><li>/refresh — Recarrega Beans ( @Refreshable )</li><li>/routes — Informações de rotas disponíveis</li><li>/loggers — Informações sobre log.</li></ul><p>É possível ver a lista de <em>features</em> disponíveis para o Micronaut utilizando o seguinte comando:</p><pre>$ mn profile-info base</pre><h3>Docker e Micronaut</h3><p>Agora que nossa aplicação está finalizada, vamos criar uma imagem dela e subir um container com o Docker.</p><p>O <em>boilerplate</em> do projeto já nos dá um Dockerfile pronto para criamos nossa imagem. Para esse exemplo não vamos modifica-lo, mas para exemplos reais é interessante fazer modificações de fino ajuste, como configuração de memória disponível, porta onde a aplicação será executada ou adição de algum parâmetro específico para executar a aplicação.</p><p>Antes de gerar nossa imagem, é necessário gerar um executável da aplicação, um .jar, que será utilizado pelo Dockerfile para construção da imagem. Para isso, execute o seguinte comando na raiz do projeto.</p><pre>$ mvn clean package</pre><p>Isso irá executar os testes existentes na aplicação e caso os testes passem irá gerar o executável <em>hello-world-0.1.jar </em>dentro da pasta <em>target. </em>Agora podemos criar a imagem docker da nossa aplicação utilizando o seguinte comando:</p><pre>$ docker build -t jvoliveira/hello-world:0.1 .</pre><p>Para verificar se a imagem foi mesmo criada, poderá consultar as imagens utilizando o comando:</p><pre>$ docker images </pre><p>Com a imagem criada, agora só falta iniciar um container utilizando a nossa nova imagem. O comando abaixo realiza esse procedimento:</p><pre>$ docker run -d -p 8090:8080 --name micronaut jvoliveira/hello-world:0.1</pre><p>Nesse comando estamos expondo nossa aplicação na porta 8090 do host, então para acessar os endpoints da nossa aplicação, vamos utilizar o curl novamente</p><pre>$ curl -v http://localhost:8090/greetings/joao</pre><p>Se tudo deu certo, será exibido a resposta do servidor com o status 200 OK e na última linha será exibida a mensagem &quot;Hello, joao!&quot;</p><h3>Conclusão</h3><p>Esse foi apenas um exemplo bem simples de como criar rapidamente uma API com testes e executar dentro de um container Docker, além de apresentar o Micronaut CLI e algumas features disponibilizadas pelo Micronaut.</p><p>Quer ver o código na integra? <a href="https://github.com/jvoliveiran/hello-micronaut"><strong>Aqui</strong></a><strong> </strong>está o link para o GitHub.</p><p>Em breve, novos artigos falando um pouco mais sobre Micronaut.</p><h3>Referências</h3><ul><li>Cloud Native with Micronaut — <a href="https://medium.com/@mesirii/cloud-native-with-micronaut-733c9784850f">https://medium.com/@mesirii/cloud-native-with-micronaut-733c9784850f</a></li><li>Micronaut Documentation — <a href="https://micronaut.io/documentation.html">https://micronaut.io/documentation.html</a></li><li>Micronaut Guides — <a href="https://guides.micronaut.io/">https://guides.micronaut.io/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da764ac3e288" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Micronaut: Uma visão geral]]></title>
            <link>https://medium.com/@jvoliveiran/micronaut-uma-vis%C3%A3o-geral-1f640c5a7ad4?source=rss-3ef378412346------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f640c5a7ad4</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[micronaut]]></category>
            <category><![CDATA[framework]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[João Victor]]></dc:creator>
            <pubDate>Wed, 22 May 2019 14:43:33 GMT</pubDate>
            <atom:updated>2019-05-24T14:02:29.216Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*BxLJuCCk3Rqz7f1mjYwsbQ.png" /></figure><p>Lançado oficialmente em 23 de outubro de 2018, o <a href="https://micronaut.io/">Micronaut</a> é um framework full-stack moderno, baseado na JVM e que pode ser utilizado para a construção de microserviços, ferramentas de CLI e aplicações Serverless, de forma modular e facilmente testável.</p><p>Mantido pela <a href="https://objectcomputing.com/">Object Computing Inc. (OCi)</a>, o Micronaut é open-source, sob a licença Apache 2.0, e o projeto está sob a liderança de <a href="https://github.com/graemerocher">Graeme Rocher</a>, conhecido na comunidade Java/Groovy por ter sido o criador do framework <a href="https://grails.org/">Grails</a>, trazendo mais de 10 anos de experiência e lições aprendidas com o Grails para criar um novo framework inovador no mundo da JVM. Atualmente, o Micronaut está na versão <a href="https://github.com/micronaut-projects/micronaut-core/releases/tag/v1.1.2">1.1.2</a> e conta com um time de desenvolvedores da OCi dedicados ao projeto, além de vários colaboradores no Github e é apoiado por outras empresas como a <a href="https://jfrog.com/">JFrog</a>.</p><p>No <a href="https://www.thoughtworks.com/radar/languages-and-frameworks">Tech Radar da ThoughtWorks lançado em 29 de abril</a>, o Microunat foi incluído na sessão <em>&quot;experimente&quot;, </em>sendo apontado como um promissor framework no ecossistema da JVM.</p><h3>Uma breve retrospectiva</h3><p>O Micronaut foi lançado em 2018, mas para entendermos as razões pela qual ele surgiu e o seu real impacto e inovação, precisamos voltar um pouco no tempo.</p><p>Dez anos antes do lançamento do Micronaut, em 2008, era lançada a versão 1.0 do Grails e o cenário de tecnologia era completamente diferente do atual. Não tínhamos frameworks front-end modernos como Angular, React, nem muito menos Vue.js. Não tínhamos Docker e microserviços era apenas um conceito em formação, pois sua primeira menção foi feita em um workshop em 2011.</p><p>Os softwares na década passada ainda eram monólitos e os principais frameworks do mercado na época, sendo o Spring e o então promissor Grails parte desses frameworks, foram pensados, criados e evoluídos para essa era, onde os monólitos reinavam.</p><h3>Microrealidade</h3><p>Agora, na era dos microserviços, os frameworks criados para desenvolver monólitos tiveram que ser adaptados para esse novo paradigma. O Spring recebeu um conjunto de módulos completamente novo, o <a href="https://spring.io/projects/spring-cloud">Spring Cloud</a>, para se adaptar aos novos tempos e solucionar os novos problemas que as aplicações distribuídas trouxeram.</p><p>Spring, Grails e Jakarta EE (<a href="https://microprofile.io/">Microprofile</a>) são frameworks baseados em anotações e <a href="https://en.wikipedia.org/wiki/Aspect-oriented_programming"><em>Aspect Oriented Programming (AOP)</em></a>, fazendo uso extensivo de <em>reflection, </em>onde são realizadas uma grande quantidade de análises no <em>byte code </em>em<em> </em>tempo de execução (<em>Runtime</em>). A consequência disso é que quanto maior o código da aplicação, maior será o tempo de startup e maior também será o consumo de memória, sendo esse crescimento não linear.</p><p>Apesar dos problemas relatados nos frameworks mais difundidos no ecossistema da JVM, eles possuem vantagens que são massivamente valorizadas pela comunidade de desenvolvedores e que promovem um ganho de produtividade muito alto, já que esses frameworks resolvem problemas como segurança, log, profile, sem muito esforço por parte do desenvolvedor, deixando-o focado apenas na lógica de negócio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3vBAteHu55a3BGJCzNgQlg.png" /></figure><p>Numa época onde infraestrutura é oferecida como serviço, e esse serviço cobra apenas pela quantidade de recurso que é consumido, otimizar o consumo de memória está diretamente relacionado com economia de custos de um projeto.</p><p>Outro ponto que merece destaque é a relevância no tempo de disponibilidade das aplicações. Grandes aplicações, como <em>e-commerces</em>, precisam ter 100% de disponibilidade, pois caso a aplicação fique indisponível por pouco tempo poderá gerar um prejuízo financeiro considerável ao negócio. Não é mais plausível que aplicações fiquem indisponíveis devido a alguma atualização, portanto aplicações com alto tempo de startup podem comprometer até mesmo processos de <em>deploy</em> automatizados utilizando orquestradores de containers, como o <a href="https://kubernetes.io/">Kubernetes</a>.</p><h3>Conciliando desempenho e produtividade</h3><p>Assim como frameworks antigos nasceram na época dos monólitos para resolver problemas dos monólitos, novos frameworks surgiram na era dos microserviços para resolver problemas dos microserviços.</p><p>Um ponto de partida para criação de novos frameworks voltados para microserviços foi prover suporte para 12 fatores tidos como cruciais para <em>web-apps </em>modernos, conhecido como <a href="https://12factor.net/"><em>Twelve Factor</em></a><em>.</em></p><p>A motivação para criar o Micronaut foi ter um framework escrito do zero, que fosse pensando para facilitar a criação de microserviços e aplicações <em>serverless</em>, seguindo o <em>twelve factor</em>, e que tivesse um baixo consumo de memória e baixo tempo de startup, além de possuir executáveis pequenos, tudo isso sem perder a produtividade que os frameworks modernos como o Spring e o Grails conseguem prover aos desenvolvedores.</p><p>Para atender a todos esses pré-requisitos era necessário pensar um passo a frente do que foi pensado para os frameworks já existentes.</p><h3>O diferencial do Micronaut</h3><p>O processo de <em>reflection </em>logo foi visto como um fator crítico, pois afetava diretamente o consumo de memória e o tempo de startup da aplicação, uma vez que era necessário analizar todos os <em>beans</em> em busca de anotações e então gerar metadados para essas anotações que eram armazenados em memória. A solução adotada pelo Micronaut foi mitigar ao máximo o uso de <em>reflection, </em>que não foi removido totalmente mas é utilizado apenas em casos muito pontuais.</p><p>Outro ponto que o Micronaut inovou foi na resolução de injeção de dependências e AOP, que antes eram realizados em tempo de execução e agora passam a ser resolvidos em tempo de compilação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TGgeYpFMwrK4nQdi1-XqCA.png" /></figure><p>Essa mudança de ações que eram antes realizadas em tempo de execução e agora são resolvidas em tempo de compilação não é algo novo, o <a href="https://github.com/google/dagger"><em>Google Dagger</em></a><em> </em>já utilizava essa abordagem para Android, uma vez que dispositivos móveis que utilizam o sistema operacional da Google possuem recurso de memória bastante limitado, então a otimização no consumo deste recurso se torna crucial para criar um <em>app </em>com desempenho satisfatório sem consumir grande parte da memória do dispositivo.</p><h3>Visão Geral</h3><p>Conhecido como um framework poliglota, o Micronaut suporta três diferentes linguagens que rodam na JVM: Java, <a href="https://kotlinlang.org/">Kotlin</a> e Groovy. A flexibilidade do framework é algo que chama a atenção pois é possível escrever a implementação da aplicação em Java e os testes em Groovy usando a biblioteca <a href="http://spockframework.org/">Spock</a>.</p><p>O framework se mostra flexível também nas diferentes possibilidades de aplicações que o mesmo suporta. Com o Micronaut é possível criar microserviços, aplicações Serverless, ferramentas de CLI, aplicativos Android, IoT ou até mesmo o &quot;bom&quot; e velho monólito.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XAyvD1Lqn1ziFhPTHH8Obg.png" /></figure><p>Outra característica muito importante é que o Micronaut é <em>cloud native, </em>permitindo integração com uma série de ferramentas que dão suporte para <em>cloud</em>. O Micronaut suporta <em>service discovery</em> (<a href="https://www.consul.io/">Consul</a> e <a href="https://github.com/Netflix/eureka">Eureka</a>), <em>load balancing </em>(<a href="https://github.com/Netflix/ribbon">Ribbon</a>), <em>circuit breakers</em> (AOP, <a href="https://github.com/netflix/hystrix">Hystrix</a>), <em>log tracing</em> (<a href="https://zipkin.apache.org/">Zipkin</a> e <a href="https://www.jaegertracing.io/">Jaeger</a>), <em>configuration</em> (Consul e <a href="https://spring.io/projects/spring-cloud-config">Spring Cloud Config</a>), <em>monitoring</em> (<a href="https://micrometer.io/">Micrometer</a>). Além disso, o <em>boilerplate</em> do projeto já incluir um Dockerfile para criação da imagem da aplicação e possui suporte para integração com Amazon AWS e Google Cloud Plataform.</p><h3>Suporte para Graal VM</h3><p>A nova VM da Oracle, <a href="https://www.graalvm.org/">Graal VM</a>, vem se mostrando como um novo caminho para melhorar o desempenho e consumo de recursos de linguagens que rodam na JVM. Devido a deficiências como tempo de startup e consumo de memória, já citados previamente, o Java vem perdendo espaço como linguagem escolhida para implementação de microserviços.</p><p>O fato do Micronaut não utilizar <em>reflection</em> e já resolver DI e AOP em tempo de compilação já torna o framework apto para ser compilado para código nativo pela Graal VM, melhorando ainda mais o desempenho da aplicação.</p><h3>Comunidade</h3><p>Apesar de ser um projeto recente, com menos de um ano após o lançamento da versão 1.0.0 GA, a comunidade do Micronaut já tem uma boa presença no <a href="https://stackoverflow.com/questions/tagged/micronaut">Stackoverflow</a>.</p><p>O <a href="https://github.com/micronaut-projects/">Github do projeto</a> possui também uma boa quantidade de threads e issues resolvidas. Caso tenha encontrado um novo bug, é possível abrir uma nova <a href="https://github.com/micronaut-projects/micronaut-core/issues">issue</a>.</p><p>Outro meio de contato com a comunidade é através do <a href="https://gitter.im/micronautfw">Gitter</a>, que já conta com uma boa quantidade de membros.</p><h3>Próximos passos</h3><p>Agora que o Micronaut foi apresentando, mostrando as suas diferenças com relação a outros frameworks já consolidados no cenário da JVM e quais os problemas que o Micronaut vem para resolver, é hora de mostrar como dar os primeiros passos com esse framework promissor.</p><p>Sequência: <a href="https://medium.com/@jvoliveiran/primeiros-passos-com-micronaut-da764ac3e288"><strong>Primeiros passos com Micronaut</strong></a></p><h3>Referências</h3><ul><li>[Talk Graeme Rocher] — <a href="https://www.youtube.com/watch?v=BL9SsY5orkA">https://www.youtube.com/watch?v=BL9SsY5orkA</a></li><li>[Micronaut Doc] — <a href="https://docs.micronaut.io/latest/guide/index.html">https://docs.micronaut.io/latest/guide/index.html</a></li><li>[Micronaut Guide] — <a href="https://guides.micronaut.io/index.html">https://guides.micronaut.io/index.html</a></li><li>[Micronaut Cloud Native] — <a href="https://medium.com/@mesirii/cloud-native-with-micronaut-733c9784850f">https://medium.com/@mesirii/cloud-native-with-micronaut-733c9784850f</a></li><li>[ThoughtWorks Tech Radar] — <a href="https://www.thoughtworks.com/radar">https://www.thoughtworks.com/radar</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f640c5a7ad4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Cloud Stream: Simplificando o uso de Message Broker — Parte 2]]></title>
            <link>https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-parte-2-e82d02e1371c?source=rss-3ef378412346------2</link>
            <guid isPermaLink="false">https://medium.com/p/e82d02e1371c</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[spring-cloud]]></category>
            <category><![CDATA[spring-framework]]></category>
            <dc:creator><![CDATA[João Victor]]></dc:creator>
            <pubDate>Wed, 10 Apr 2019 21:30:31 GMT</pubDate>
            <atom:updated>2020-05-04T13:58:57.382Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Cloud Stream: Simplificando o uso de Message Broker — Parte 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*3jXUXLFSQ-Yfyl5JEMla6w.png" /><figcaption>Simplificando o uso de message brokers com o Spring Cloud Stream</figcaption></figure><h3>Recapitulando</h3><p>Na <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">parte 1</a> deste série foi explicado sobre a situação dos Message Brokers em arquiteturas modernas e qual o problema que o Spring Cloud Stream se propõe a resolver, considerando o atual cenário de message brokers existentes no mercado. Além disso, foi criado um exemplo bem simples de <em>producer </em>e <em>consumer</em> para mostrar o quão simples pode ser o uso de um message broker utilizando o Spring Cloud Stream.</p><p>E agora, o que faremos aqui?</p><p>Agora já vamos direto para mais exemplos práticos!</p><p>Vamos nessa?!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X7FeuvoMnk6wrxzK9OI5Rw.jpeg" /><figcaption>Here we go!</figcaption></figure><h3>Exemplo 1 — Custom Bindings</h3><p>No primeiro exemplo da <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">história anterior</a>, vimos que o Spring Cloud Stream já nos fornece alguns bindings, como o Source e o Sink para utilizarmos em nossos projetos. Esses bindings funcionam de forma simples<em>, </em>no entanto eles possuem suas limitações. E se desejarmos criar nossos próprios <em>bindings? </em>Esse será o objetivo desse exemplo.</p><p>Vamos criar um projeto chamado <em>spring-cloud-producer-custom. </em>Nesse projeto adicionaremos como dependências o RabbitMQ, o Cloud Stream, Web e também o Actuator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1cWoMglswhP-aHyKHoZ3vQ.png" /></figure><p>Primeiro vamos criar o <em>binding. </em>Ele será apenas uma <em>interface</em> no nosso projeto. Veja no código abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f17d97bec0e2b6080d013c82f7b4780b/href">https://medium.com/media/f17d97bec0e2b6080d013c82f7b4780b/href</a></iframe><p>Nosso <em>binding </em>possui duas assinaturas de métodos, onde ambas retornam um MessageChannel e estão anotadas com Output. O argumento da anotação será o nome do nosso <em>binding</em>, como temos o OUTPUT no Source e o INPUT no Sink.</p><p>Agora vamos criar uma nova classe para fazer a publicação das nossas mensagens. Dessa vez faremos um pouco diferentes, iremos publicar uma mensagem a cada 2 segundos utilizando o <em>binding &quot;default-channel&quot; </em>e publicaremos uma outra mensagem a cada 3 segundos utilizando o <em>binding &quot;custom-channel&quot;. </em>O <em>default channel </em>irá publicar a mensagem no <em>exchange simple-message </em>enquanto o <em>custom-channel </em>irá publicar a mensagem no <em>exchange complete-message.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*-oftNxalMcFlP45ASIfwjg.jpeg" /></figure><p>Já criamos nosso custom <em>binding, </em>então agora precisamos utilizá-lo para publicar nossas mensagens. Para isso, criaremos umas nova classe chamada <em>MyCustomProducer.java</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/af6bbf0792535c954538acc5228c266b/href">https://medium.com/media/af6bbf0792535c954538acc5228c266b/href</a></iframe><p>Inicialmente temos a anotação @EnableBinding(MyCustomSource.class) indicando que nossa classe de publicação de mensagens estará utilizando um <em>custom binding, </em>que no caso é a interface <em>MyCustomSource </em>que criamos previamente.</p><p>Nessa classe de publicação foram criados dois métodos, um para cada <em>exchange</em> que será utilizado para receber as mensagens, conforme foi explicado previamente. Nesse exemplo, a única relação dos dois métodos criados nessa classe com as assinaturas dos métodos presentes na <em>interface MyCustomSource </em>está no channel, note que eles são os mesmo definidos na anotação <em>Output </em>do <em>MyCustomSource. </em>Ambos os métodos recebem a anotação @InboundChannelAdapter fazendo com que esses métodos enviem mensagens para um <em>channel </em>específico de tempos em tempos, onde dessa vez configuramos esse tempo no atributo <em>poller. </em>Além disso, ambos os métodos também são anotados como <em>Beans, </em>uma vez que o Cloud Stream utiliza os <em>Beans</em> para realizar o envio das mensagens.</p><p>O método <em>sendMessageDefault </em>envia uma <em>string </em>simples, sendo esse o tipo de retorno do método, nada diferente do exemplo no <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">artigo anterior</a>. No caso do segundo método, o <em>sendCustomMessage </em>o nosso objeto de retorno é um <em>MessageSource</em> que encapsula, através de <em>generics, </em>um objeto do tipo <em>Message </em>sendo esse um objeto criado para gerar uma mensagem com mais propriedades do que uma simples <em>string, </em>simulando um DTO ou algum objeto mais complexo em um cenário real. Segue o código do nosso objeto <em>Message:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/829be368fe8683df92718f0a402ea989/href">https://medium.com/media/829be368fe8683df92718f0a402ea989/href</a></iframe><p>Por fim, falta configurarmos o arquivo application.properties com algumas informações relevantes para que nossa nova aplicação <em>producer</em> funcione corretamente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1f23245fa38afe7ccc7c80474f41613f/href">https://medium.com/media/1f23245fa38afe7ccc7c80474f41613f/href</a></iframe><p>Novamente criamos <em>destinations</em> específicos para cada um dos dois <em>bindings</em> que criamos nesse projeto. Por estar utilizando o <a href="https://docs.spring.io/spring-boot/docs/current/actuator-api/html/#overview">Spring Actuator</a>, foi necessário realizar algumas configurações específicas nas linhas 5 e 7 desse arquivo para habilitar e também expor alguns endpoints que esse módulo do Spring oferece. O intuito de usar o <em>Actuator</em> nesse projeto é verificar que o <em>Cloud Stream</em> cria <em>Beans </em>tanto para nossa <em>interface</em> <em>MyCustomSource, </em>quanto para o <em>default-channel </em>e para o <em>custom-channel. </em>Para ter acesso aos beans basta acessar a seguinte URL:</p><pre>http://localhost:8092/actuator/beans</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DN1XKAcox5efveMmq2TWoQ.png" /><figcaption>Bean MyCustomSource</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iH4RDWj7pDdIzalVFI1pSQ.png" /><figcaption>Bean default-channel</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F9YIkUT5OInSNtZj8NL8hw.png" /><figcaption>Bean custom-channel</figcaption></figure><p>Agora vamos iniciar a aplicação <em>spring-cloud-producer-custom</em> que acabamos de criar e verificar o dashboard do RabbitMQ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nXdmDpQe-qh0y7f0LDOa0w.png" /><figcaption>Dashboard RabbitMQ, aba Exchanges</figcaption></figure><p>É possível ver que os dois <em>exchanges</em> foram criados com os nomes que configuramos como <em>destination</em> no arquivo applications.properties. Ambos os <em>exchanges</em> estão recebendo mensagens com <em>rate in</em> diferentes, o que também é esperado pois criamos dois métodos para publicar mensagens, um a cada 3 segundos e outro a cada 2 segundos.</p><p>Agora vamos iniciar duas instancias do projeto s<em>pring-cloud-consumer-simple</em>, criado no <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">artigo anterior</a>. Cada instância irá criar uma <em>queue </em>que receberá mensagens de um dos dois <em>exchanges</em> que criamos. Para isso, use o terminal para navegar até a raiz do projeto <em>spring-cloud-consumer-simple. </em>Na raiz do projeto, execute o seguinte comando:</p><pre>mvn clean package</pre><p>Isso irá gerar um novo executável da aplicação na pasta <em>target</em>. Abra uma nova janela do terminal para executarmos duas instâncias do nosso consumer. Em cada uma das duas janelas do terminal execute um dos comandos abaixo:</p><pre>java -jar target/spring-cloud-consumer-simple-0.0.1-SNAPSHOT.jar — server.port=80901 — spring.cloud.stream.bindings.input.destination=simple-message</pre><pre>java -jar target/spring-cloud-consumer-simple-0.0.1-SNAPSHOT.jar — server.port=80902 — spring.cloud.stream.bindings.input.destination=complete-message</pre><p>Esses comandos iniciarão uma instância da nossa aplicação <em>consumer</em> e passará alguns parâmetros de configuração via <em>command line</em> que irão sobrescrever os parâmetros que estiverem configurados no application.properties da aplicação. Dessa forma evitamos conflito de portas e também direcionamos cada instância da aplicação para receber mensagens de um dos <em>exchanges</em>.</p><p>Acessando o dashboard do RabbitMQ, na aba <em>Queues</em> podemos ver que foram criadas duas <em>queues </em>para receber as mensagens, uma para cada <em>exchange.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2nOYxYCG0Rmp2Tk8EIdn9Q.png" /></figure><p>Analisando o console de cada uma das instâncias da aplicação <em>spring-cloud-consumer-simple </em>vemos que as mensagens estão sendo recebidas pelo seu respectivo <em>consumer.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kLj8UhtvNVXcf-Lp_d380Q.png" /><figcaption>Instância da aplicação consumer recebendo mensagens do exchange simple-message</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pApxz5EspBk4fAXKWjYHGA.png" /><figcaption>Instância da aplicação consumer recebendo mensagens do exchange complete-message</figcaption></figure><p>E assim finalizamos esse exemplo, utilizando <em>custom bindings </em>e múltiplos <em>consumers, </em>algo mais próximo de uma aplicação real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/593/1*qOqCWd2LhCdwdGM4V9Dnqw.jpeg" /></figure><h3>Exemplo 2 — REST Producer</h3><p>Agora vamos pensar em um cenário onde um dos microsserviços é acessado através de um determinado <em>endpoint, </em>onde é realizado algum processamento e é necessário enviar uma mensagem para que outro serviço realize uma outra operação, que é parte do processamento. Esse é um cenário bem parecido com o mundo real, e esse é um cenário onde message brokers são utilizados para resolver um problema comum, que é a comunicação entre microsserviços.</p><p>Neste segundo exemplo, ou terceiro exemplo se considerarmos o <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">artigo anterior</a>, iremos criar um novo projeto <em>producer </em>que chamaremos de <em>spring-cloud-producer-rest. </em>Este projeto terá um <em>RestController </em>com um <em>endpoint</em> que receberá uma mensagem. Iremos encapsular essa mensagem, que virá como um JSON, e enviá-la para o Message Broker.</p><p>Como de costume, começamos com as dependências na criação do novo projeto. Usaremos as dependências do RabbitMQ, Cloud Stream e Web.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bxHLAqKvGLGIsPgKz3Fwhg.png" /><figcaption>Dependências spring-cloud-producer-rest</figcaption></figure><p>Nesse projeto a mensagem enviada para o Message Broker será um Produto, representado pela seguinte classe <em>Product:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/07834f422a9fc1f9b1f90f2655e05aa5/href">https://medium.com/media/07834f422a9fc1f9b1f90f2655e05aa5/href</a></iframe><p>Usaremos <em>custom binding </em>novamente, da mesma forma que utilizamos no exemplo anterior. Teremos um único <em>channel </em>chamado <em>product-channel </em>e definido no nosso <em>binding RestSource:</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f501bac924276ea81247135a1cc81eb/href">https://medium.com/media/4f501bac924276ea81247135a1cc81eb/href</a></iframe><p>Mais uma vez nosso <em>binding </em>é definido apenas através de uma <em>interface </em>onde informamos a assinatura dos métodos que irão representar os <em>channels. </em>Nosso <em>binding </em>terá um <em>channel </em>chamado <em>product-channel, </em>como explicado anteriormente.</p><p>Agora precisamos de um classe para habilitar o <em>binding </em>que acabamos de criar. Para isso criamos uma classe simples, <em>RestSourceImpl,</em> e iremos apenas incluir a anotação @EnableBinding(RestSource.class) e nada mais.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f245150b57dffdae6d388100334b99db/href">https://medium.com/media/f245150b57dffdae6d388100334b99db/href</a></iframe><p>Feito isso, criaremos a classe <em>RestProducer </em>que será anotada como <em>@Component </em>para que possamos injeta-la em nosso <em>@RestController </em>mais a frente. Esta classe será responsável por fazer o envio da mensagem, dado o <em>payload</em> que se deseja enviar através de um <em>binding </em>específico.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2eec2591c84dcdf08ac2ec76dba9b6e5/href">https://medium.com/media/2eec2591c84dcdf08ac2ec76dba9b6e5/href</a></iframe><p>Nesse caso, nosso método de envio recebe um <em>Product </em>como <em>payload,</em> além de uma instância do nosso <em>custom binding RestResource.</em> Usamos o <em>MessageBuilder </em>para construir a nossa mensagem encapsulando o <em>payload</em> e então usamos o <em>channel </em>do <em>custom binding </em>para fazer o envio da mensagem, retornando um booleano como <em>status </em>de envio da mensagem.</p><p>Temos o nosso <em>custom binding </em>pronto, bem como o DTO <em>Product </em>e a classe que é responsável por enviar a mensagem, no caso o <em>RestProducer </em>que acabamos de criar. Agora a última classe que precisaremos criar nesse projeto será o nosso <em>RestController.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2244a58e9ba5fe1355db0972c8996cb/href">https://medium.com/media/d2244a58e9ba5fe1355db0972c8996cb/href</a></iframe><p>Nossa última classe criada é a <em>ProductRestController, </em>que é anotada como <em>RestController </em>e também como <em>RequestMapping(&quot;/product&quot;), </em>indicando que todos os <em>endpoints</em> nessa classe sejam precedidos desse prefixo passado como argumento da anotação.</p><p>No nosso controller são injetados dois beans, o primeiro é uma <em>interface</em> que representa nosso <em>binding </em>e o segundo é o nosso componente de envio de mensagens.</p><p>Por último, foi definido um método para envio de mensagens chamado <em>processProduct </em>que espera receber um objeto <em>Product </em>no corpo da requisição feita ao <em>endpoint </em>/product/process utilizando o <em>method</em> POST. Um vantagem do módulo web no Spring é que o <em>parser </em>do JSON enviado na <em>request </em>para o objeto <em>Product, </em>que já é feito sem que seja necessário nenhum tratamento específico, desde que o nome dos campos do JSON e do objeto <em>Product </em>sejam os mesmos. Neste método utilizamos o nosso componente <em>RestProducer</em> para fazer sua função, que é enviar de fato a mensagem, e com o retorno dessa operação nós criamos uma resposta para a <em>request </em>utilizando a classe <em>ResponseEntity </em>do Spring.</p><p>O objeto <em>Message</em> passado como <em>generic </em>no retorno do método é o mesmo objeto do exemplo anterior. Pode copia-lo e coloca-lo neste projeto.</p><p>E ainda falta mais uma coisa que não fizemos até o momento</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*_kxkz7ChjDxmJa4PXy9yvg.jpeg" /></figure><p>Precisamos configurar o application.properties com algumas informações.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b9113899ea68d40fc2bfe0ad7bdc477/href">https://medium.com/media/9b9113899ea68d40fc2bfe0ad7bdc477/href</a></iframe><p>Agora já podemos testar nossa nova aplicação <em>producer. </em>Vamos inicia-la e verificar o que acontece no dashboard do <em>RabbitMQ.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XExR4CZBAzAcixGcfVNbdw.png" /><figcaption>Dashboard do RabbitMQ na aba Exchange após iniciar a aplicação spring-cloud-producer-rest</figcaption></figure><p>Observe que nosso <em>exchange product-process </em>foi criado, conforme configuração realizada no application.properties. Outro detalhe interessante é que mesmo com nosso <em>producer </em>de pé, nenhuma taxa de <em>rate in </em>ou <em>rate out</em> está sendo exibida, uma vez que nosso <em>producer </em>não possui mais o comportamento de enviar mensagens periodicamente, já que criamos um componente de envio de mensagem e ele só é executado quando fazemos uma <em>request </em>para o <em>endpoint </em>que criamos.</p><p>No momento não temos nenhuma <em>queue </em>criada para o nosso <em>exchange product-process, </em>então vamos criar uma <em>queue </em>auxiliar através do próprio dashboard, acessando a aba <em>Queues.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gr8P3sRKEl19ZNo-v5rpDg.png" /><figcaption>Criação de nova Queue no dashboard do RabbitMQ</figcaption></figure><p>Após criar uma nova <em>Queue, </em>ainda no dashboard podemos clicar na nova <em>queue </em>para vermos mais detalhes da mesma e acessar a opção de criar um <em>binding </em>para essa <em>queue, </em>onde essa <em>binding </em>será responsável por ler as mensagens no <em>exchange </em>e envia-las para a <em>queue.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4MoszIwp0-7snVVrZByUw.png" /><figcaption>Adicionando binding para a queue</figcaption></figure><p>Agora que temos o <em>binding </em>criado na nossa <em>queue </em>temporária para coletar as mensagens que chegarem ao <em>exchange product-process, </em>vamos utilizar o <a href="https://www.getpostman.com/"><em>Postman</em></a><em> </em>para realizar uma requisição HTTP ao <em>endpoint </em>que criamos na aplicação <em>spring-cloud-producer-rest. </em>A <em>request </em>será feita para o seguinte endereço:</p><pre>http://localhost:8093/product/process</pre><p>Para que a requisição funcione corretamente, devemos utilizar o <em>method</em> POST e no corpo da requisição enviar um JSON equivalente ao nosso objeto <em>Product. </em>Vamos fazer uma requisição no <em>Postman </em>considerando essas regras.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HVVxWnrCYvyk2VDhjIs_bg.png" /><figcaption>Requisição HTTP via Postman</figcaption></figure><p>Enviando essa <em>request </em>é esperado receber a seguinte <em>response:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UY6iFyQlGeaWOM1qhDFisw.png" /><figcaption>Response do spring-cloud-producer-rest para a request na imagem anterior</figcaption></figure><p>Note que o objeto JSON de resposta nada mais é que o objeto Message convertido para JSON. A mensagem retornada dentro do nosso objeto Message indica que o envio da mensagem para o Message Broker ocorreu com sucesso.</p><p>Para termos uma outra confirmação de que o Message Broker recebeu nossa mensagem, podemos verificar a <em>queue </em>que criamos manualmente através do dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kWWaDq_yIJOY9UKwUomeqw.png" /><figcaption>Mensagem recebida pela queue</figcaption></figure><p>E isso conclui o nosso <em>producer, </em>agora conseguimos controlar programaticamente quando mensagens devem ser enviadas ao message broker, através de um exemplo mais próximo do mundo real.</p><p>Ainda tomando como base exemplos do mundo, imagine que em um período de muitos acessos da nossa aplicação, uma quantidade enorme de mensagens sejam enviadas para o Message Broker. Se tivermos apenas uma instância do consumer, provavelmente nossas mensagens demorarão muito tempo para serem processadas. O ideal seria ter diferentes instâncias do nosso <em>consumer</em> (aquele <em>consumer</em> que criamos no <a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5">artigo anterior</a>).</p><p>Vamos modificar o nosso application.properties na aplicação <em>spring-cloud-consumer-simple </em>para subir múltiplas instâncias do <em>consumer </em>e consumir o <em>exchange product-process.</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b2caa0f08bcd07d07779fb814d3aac3/href">https://medium.com/media/8b2caa0f08bcd07d07779fb814d3aac3/href</a></iframe><p>Quando atribuímos o valor 0 (zero) para a porta onde a aplicação será executada, o próprio Spring se encarrega de escolher uma porta que esteja disponível. Agora vamos iniciar duas instâncias do <em>consumer </em>e verificar o impacto disso no dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5iDsHbda263JHQQ-sZ84hw.png" /><figcaption>Duas queues criadas ao subir duas instâncias do consumer</figcaption></figure><p>Podemos ver como resultado que foram criadas duas <em>queues, </em>uma para cada instância da aplicação <em>consumer </em>que iniciamos, logo se escalarmos o <em>consumer </em>criando mais instâncias, não estamos de fato escalando as aplicações, porque estamos criando múltiplas <em>queues </em>que continuam processando todas as mensagens que são enviadas ao <em>exchange. </em>Vamos fazer uma alteração no nosso <em>consumer </em>para evitar esse comportamento.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b535303543be12fea95f572bf1456ca2/href">https://medium.com/media/b535303543be12fea95f572bf1456ca2/href</a></iframe><p>Alterando o application.properties, incluímos na linha 11 uma configuração para unificar as <em>queues </em>criadas ao iniciar múltiplas instâncias do <em>consumer.</em> Vamos confirmar se isso de fato está acontecendo, iniciando novamente duas instâncias do projeto <em>spring-cloud-consumer-simple </em>e analisando a aba <em>Queue </em>no dashboard.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZO5nn2b24qO2ZEKESSfJ6A.png" /><figcaption>Queue única para duas instâncias da aplicação consumer</figcaption></figure><p>Agora temos uma única <em>Queue, </em>que agora possui uma nomenclatura mais amigável, formada pelo nome do <em>exchange</em> que ela consome e pelo nome do grupo que definimos no arquivo de propriedades da aplicação. Examinado essa <em>queue </em>podemos ver mais um detalhe interessante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-yDLphxJTOOS-GlP1i9Lg.png" /><figcaption>Detalhes da queue product-queue, com dois consumers.</figcaption></figure><p>Agora temos o resultado esperado, uma única <em>queue </em>com dois <em>consumers, </em>um para cada instância da nossa aplicação <em>consumer.</em></p><p>Podemos utilizar o Postman para realizar múltiplas requisições e então verificar como as múltiplas instâncias do <em>consumer </em>irão se comportar para consumir as mensagens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EQvjEeg9oiz4afpWqO35Eg.png" /><figcaption>Logs de duas instâncias da aplicação consumer.</figcaption></figure><p>E como em um passe de mágica, o Cloud Stream faz o direcionamento das mensagens recebidas pela <em>Queue </em>para uma das instâncias do nosso <em>consumer</em>. Dessa forma, podemos escalar os <em>consumers </em>conforme seja necesário.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*0yDJFSKRBmiXt1mts0-DSg.jpeg" /></figure><p>E assim finalizamos mais um exemplo.</p><h3>Conclusão</h3><p>Este artigo mostra (um pouco) o quão simples é trabalhar com Message Brokers utilizando o Spring Cloud Stream, um módulo não tão popular mas que definitivamente deve ser considerado por quem utiliza ou pretende utilizar Message Brokers em projetos.</p><p>A documentação do módulo ainda não é abrangente porém a Pivotal vem tentando evolui-la, além do suporte no <a href="https://stackoverflow.com/questions/tagged/spring-cloud-stream">StackOverflow</a> que os engenheiros da Pivotal estão dando.</p><p>Ainda tem uma grande quantidade de <em>features</em> que não foram demonstradas nesses dois artigos, como os <em>Processors, Partitions, SendTo</em>, dentre outras que merecem ser exploradas, talvez em um próximo artigo.</p><p>Até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e82d02e1371c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Cloud Stream: Simplificando o uso de Message Broker]]></title>
            <link>https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-71f1731f5f5?source=rss-3ef378412346------2</link>
            <guid isPermaLink="false">https://medium.com/p/71f1731f5f5</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-cloud]]></category>
            <dc:creator><![CDATA[João Victor]]></dc:creator>
            <pubDate>Tue, 09 Apr 2019 21:20:52 GMT</pubDate>
            <atom:updated>2019-04-11T13:26:27.350Z</atom:updated>
            <content:encoded><![CDATA[<h3>Spring Cloud Stream: Simplificando o uso de Message Broker — Parte 1</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*3jXUXLFSQ-Yfyl5JEMla6w.png" /><figcaption>Simplificando o uso de message brokers com o Spring Cloud Stream</figcaption></figure><h3><strong>Introdução</strong></h3><p>Desacoplamento, escalabilidade, tolerância a falhas, arquiteturas orientadas a eventos, alta disponibilidade, todas essas palavras fazem parte do conjunto de requisitos não funcionais que os sistemas modernos de grande porte buscam atender. Em aplicações modernas a arquitetura é composta, de forma distribuída, por vários elementos que são responsáveis pela orquestração e comunicação entre os microsserviços, sendo os Message Brokers uma peça de extrema importância dentro dessas arquiteturas, uma vez que eles permitem garantir maior escalabilidade para a aplicação e permite a comunicação entre serviços.</p><p>Com a popularidade dos Message Brokers surgiram alguns vendors que ganharam maior popularidade pela sua robustez e simplicidade de uso, gerando uma polarização para dois vendors específicos: <a href="https://kafka.apache.org/"><em>Apache Kafka</em></a><em> </em>e <a href="https://www.rabbitmq.com/"><em>RabbitMQ</em></a><em>. </em>O uso desses message brokers a principio pode parecer complexo, apesar da documentação de ambos ser bem completa, mas compreende-los e utiliza-los possui uma curva de aprendizagem significativa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/454/1*hQUWUN1ybSUEietqZpNP_w.png" /></figure><p>Diante da necessidade do uso de message brokers por arquiteturas modernas e a existência de diferentes vendors sendo adotados pela comunidade, a <a href="https://pivotal.io/">Pivotal</a> criou um novo módulo, o <a href="https://spring.io/projects/spring-cloud-stream">Spring Cloud Stream</a>, fazendo o que o <a href="https://spring.io/">Framework Spring</a> sabe fazer como poucos: facilitar a vida dos desenvolvedores!</p><h3><strong>Objetivo</strong></h3><p>O objetivo deste artigo não é realizar comparativos entre o <em>Kafka </em>e o <em>RabbitMQ </em>para mostrar qual dos dois é mais eficiente ou recomendado em um determinado contexto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*lnTAWhl8d7maghOUgwy49A.jpeg" /></figure><p>O intuito desse artigo é mostrar através de exemplos práticos, leia-se: código, que o Spring Cloud Stream é capaz de abstrair, em alto nível, o uso dos Message Broker mais populares, evitando o tão indesejado <em>vendor lock</em>.</p><h3><strong>Pré-Requisitos</strong></h3><p>Como o foco desse artigo é a demonstração do Spring Cloud Stream através de exemplos, é recomendável realizar o seguinte <em>setup:</em></p><ol><li>Java</li><li>Maven</li><li>Docker</li><li>IDE (<em>Recomendo o </em><a href="https://spring.io/tools"><em>Spring Tool Suite</em></a><em> — STS)</em></li><li>Postman (<em>opcional</em>)</li></ol><p>Utilizaremos o Docker para subir uma instância do <em>RabbitMQ </em>de forma simples e rápida. Ao longo dos exemplos criaremos diferentes projetos pequenos, através da interface de criação de projetos Spring presente no STS (ou pode utilizar o <a href="https://start.spring.io/">Spring Initializr</a>). Utilizaremos também o Maven para gestão de dependência e build dos projetos. Em determinado ponto deste artigo realizaremos algumas requisições HTTP utilizando o Postman.</p><h3>Criando instância do RabbitMQ</h3><p>Para todos os exemplos que faremos adiante, utilizaremos o RabbitMQ como nosso Message Broker. Para simplificar o uso do RabbitMQ, utilizaremos uma imagem docker do RabbitMQ, sendo necessário apenas executar o seguinte comando no terminal:</p><pre>docker run -d --hostname local-rabbit --name rabbit-mq -p 15672:15672 -p 5672:5672 rabbitmq:3.6.9-management</pre><p>Docker também não é o foco deste artigo, mas explicando rapidamente alguns elementos desse comando:</p><ul><li><em>-d </em>: inicializa o container em background</li><li><em>— hostname : </em>nome do host onde a instância do RabbitMQ será executado</li><li><em>— name : </em>nome do container docker</li><li>— <em>p : </em>binding de porta do container com a porta do host</li><li><em>rabbitmq:3.6.9-management : </em>versão da imagem docker do RabbitMQ utilizada.</li></ul><p>Após execução desse comando, a imagem docker será baixada, caso seja a primeira vez que ela esteja sendo utilizada, e posteriormente o container será iniciado. Para verificar se o container está sendo executado, utilize o comando abaixo:</p><pre>docker ps</pre><p>Deverá ser exibido um log semelhante a este no console:</p><pre>CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES</pre><pre>4040853541e8 rabbitmq:3.6.9-management “docker-entrypoint.s…” 6 days ago Up 3 days 4369/tcp, 5671/tcp, 0.0.0.0:5672-&gt;5672/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672-&gt;15672/tcp rabbit-mq</pre><p>Se tudo deu certo até agora, essa imagem docker do RabbitMQ também irá prover uma interface gráfica para utilização do message broker. Através do <em>browser </em>é possível acessar esta interface utilizando o seguinte endereço e credenciais:</p><pre><a href="http://localhost:15672/">http://localhost:15672</a></pre><pre>username: guest<br>password: guest</pre><p>Isso nos dará acesso ao seguinte Dashboard:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XNmewEfxux6WmpmY2qHDSg.png" /><figcaption>Dashboard RabbitMQ</figcaption></figure><p>E agora, sem mais delongas, vamos aos exemplos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*82t0RVdS0DnOBeSUZy2YrA.jpeg" /></figure><h3>Exemplo 1 — Producer &amp; Consumer Básico</h3><p>Neste primeiro exemplo partiremos do básico, enviando uma mensagem simples através de um projeto que será o <em>producer, </em>e teremos também um <em>consumer, </em>que será outro projeto responsável por receber as mensagens enviadas pelo <em>producer.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*f3HZ6bUHJVT9HVguid_f0Q.png" /><figcaption>Fluxo simples producer-consumer</figcaption></figure><p>Primeiro, criaremos um projeto chamado <em>spring-cloud-producer-simple, </em>que terá como dependências apenas o Spring Cloud Stream e o RabbitMQ. Neste projeto e nos subsequentes, será utilizada a versão 2.1.4 do Spring Boot</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*q-nQa6FJK49hwtfV9etl8w.png" /></figure><p>O arquivo <em>pom.xml </em>gerado deverá conter as seguintes dependências:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c6c460c88394f2dd270b75f40ef6845/href">https://medium.com/media/3c6c460c88394f2dd270b75f40ef6845/href</a></iframe><p>Inicialmente é necessário realizar algumas configurações neste projeto através do arquivo <em>application.properties, </em>conforme arquivo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c4b8a083f8f36297dab49507b07801a1/href">https://medium.com/media/c4b8a083f8f36297dab49507b07801a1/href</a></iframe><p>A parte que merece destaque neste arquivo de configuração está na linha 15. Explicando em alto nível, essa configuração define o nome do local(<em>exchange) </em>dentro do message broker<em> </em>onde as mensagens enviadas pelo <em>producer</em> serão armazenadas para serem posteriormente consumidas.</p><p>Agora que a aplicação já consegue se conectar ao <em>RabbitMQ, </em>já sabe para onde deverá enviar as mensagens, resta então configurar o envio das mensagens. Para isso, iremos criar a classe <em>MyProducer.java</em></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d2243aad7470d6c891fcbf303ae0290/href">https://medium.com/media/3d2243aad7470d6c891fcbf303ae0290/href</a></iframe><p>O Spring Cloud Stream utiliza <em>bindings </em>para realizar o encaminhamento das mensagens. Podemos criar nosso próprio <em>binding </em>(faremos isso mais a frente) mas por hora utilizaremos o <em>binding </em>Source, fornecido pelo próprio Spring Cloud Stream. A anotação @EnableBinding(Source.class) indica que estamos fazendo o uso deste <em>binding.</em> A anotação @InboudChannelAdapter(Source.OUTPUT) cria um canal (<em>channel)</em> de saída (<em>output) </em>que irá enviar as mensagens. Essa anotação faz com que o método sendDefaultMessage() realize o envio da mensagem de forma repetitiva.</p><p>Feito isso, nossa aplicação já é capaz de enviar mensagens ao RabbitMQ, então vamos iniciar a aplicação e ver se o nosso producer está de fato funcionando. O STS ou Eclipse possui atalhos para facilitar o start da aplicação, mas é possível iniciar a aplicação via command line utilizando o comando abaixo:</p><pre>mvn spring-boot:run</pre><p>Observando os logs no console, podemos ver que o nosso método está sendo chamado de forma repetida, como esperado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KrfsZKialJiYB_0Hptqvcw.png" /><figcaption>Logs da aplicação spring-cloud-producer-simple</figcaption></figure><p>Tudo ok, nossa aplicação está enviado a mensagem, mas será que o RabbitMQ está recebendo essas mensagens? Podemos verificar o nosso Dashboard do RabbitMQ através do navegador. Lá poderemos ver que foi criado um exchange com o nome <em>simple-message.</em> O nome desse exchange foi dado por nós, quando configuramos o destination do nosso output no arquivo application.properties. Nessa exchange é possível ver uma taxa de transferencia na coluna <em>&quot;message rate in&quot; </em>indicando que esse exchange está recebendo mensagens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7THPFQmrF88Yoqph1N6g4w.png" /><figcaption>Aba &quot;Exchanges&quot; no dashboard do RabbitMQ</figcaption></figure><p>Clicando no exchange <em>simple-message</em> podemos ver mais detalhes das mensagens que estão chegando ao exchange.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wh66RsdwL-QMEnyu7klhAg.png" /><figcaption>Detalhes do exchange simple-message</figcaption></figure><p>Nosso primeiro producer está feito! Bastou algumas configurações no arquivo application.properties, uma classe com um método e voilà! Nossa aplicação está enviando mensagens para um Message Broker sem que fosse necessário usar trechos de código específicos do RabbitMQ. Fácil, não é?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/209/1*eS88jzDYslUA-I8nKwXwoQ.jpeg" /></figure><p>Para finalizar este primeiro exemplo, vamos agora criar um projeto que irá consumir as mensagens recebidas pela nossa instância do RabbitMQ. Para isso, vamos criar um projeto chamado <em>spring-cloud-consumer-simple.</em> Ele terá as mesmas dependências do projeto anterior, apenas o RabbitMQ e o Cloud Stream.</p><p>Se criar nosso producer foi fácil, o consumer é ainda mais simples! Primeiro precisamos configurar alguns detalhes do application.properties. Nada muito diferente do anterior, mas tem um detalhe que é importante ser observado.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6636a29f4ce398165cb99f5d7ffad86b/href">https://medium.com/media/6636a29f4ce398165cb99f5d7ffad86b/href</a></iframe><p>Nesse arquivo configuramos a porta na qual a aplicação <em>consumer</em> será executada, definimos as conexões com a nossa instância do RabbitMQ e por fim, mas não menos importante, definimos de onde nossa aplicação irá consumir as mensagens. Na aplicação anterior, configuramos que o <em>destination </em>do <em>output</em> seria o <em>&quot;simple-message&quot;, </em>e agora configuramos que o <em>destination </em>do <em>input</em> será também o <em>&quot;simple-message&quot;. </em>Tudo isso faz bastante sentindo se pensarmos que a saída <em>(output)</em> do nosso <em>producer</em> deve ser a entrada <em>(input) </em>do nosso <em>consumer.</em></p><p>E para terminar, precisamos escreve um pouco de código.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69d83494f8ee7d9fecaafac50c9ad6a8/href">https://medium.com/media/69d83494f8ee7d9fecaafac50c9ad6a8/href</a></iframe><p>Mais uma vez usaremos <em>bindings</em> pré-definidos pelo Cloud Stream. Anotamos a classe da aplicação com @EnableBinding(Sink.class) informando que estamos utilizando o <em>binding </em>Sink. Para finalizar, precisamos apenas criar um método com a anotação @StreamListener(Sink.INPUT). Isso indica que nosso método estará ouvindo o Message Broker através do <em>binding </em>Sink. A configuração que fizemos no arquivo application.properties indica que o nosso binding INPUT deverá buscar as mensagens em <em>&quot;simple-message&quot;, </em>que é o nosso exchange. E isso é tudo, nosso <em>consumer </em>já está pronto ler as mensagens enviadas ao Message Broker. Mais uma vez, não precisamos utilizar nada específico do <em>RabbitMQ,</em> estamos utilizando apenas classes do Cloud Stream.</p><p>Agora podemos ver o fluxo completo, como a mensagem sai do nosso <em>producer, </em>vai para o <em>RabbitMQ </em>e então é lida pelo nosso <em>consumer. </em>Para começar nossos testes, vamos iniciar a aplicação <em>producer </em>e a <em>consumer. </em>Com as duas aplicações de pé, olhando os logs no console da aplicação <em>consumer </em>podemos ver que as nossas mensagens enviadas pelo <em>producer</em> estão sendo recebidas no <em>consumer</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aqzFpt2xGO-QcWz1i06Pug.png" /><figcaption>Logs da aplicação spring-cloud-producer-simple</figcaption></figure><p>E para confirmar que as mensagens estão passando pelo RabbitMQ, vamos analisar o Dashboard do Message Broker, na aba de <em>exchange,</em> que é onde o <em>producer </em>envia as mensagens e onde o <em>consumer</em> irá recuperá-las.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Jy8_RJU5GNGdwCDosPDKw.png" /><figcaption>Dashboard do RabbitMQ exibindo a aba &quot;Exchanges&quot;</figcaption></figure><p>Observe agora que nosso <em>exchange &quot;simple-message&quot; </em>agora possui valores nos campos <em>&quot;message rate in&quot; </em>e também em <em>&quot;message rate out&quot;. </em>Isso obviamente indica que o <em>exchange </em>está recebendo e também enviando mensagens. Sabemos que nosso <em>producer </em>envia mensagens para o <em>exchange, </em>no entanto o nosso <em>consumer</em> não acessa diretamente o <em>exchange.</em></p><p>No RabbitMQ as mensagens que chegam a um <em>exchange </em>são direcionadas para <em>Queues </em>através de bindings, para que então sejam consumidas<em>. </em>Uma ou mais <em>queues</em> podem ser vinculadas para receber as mensagens de um <em>exchange.</em> Note que não precisamos configurar nada disso nas nossas aplicações. O Spring Cloud já se responsabilizou por criar o <em>exchange </em>para onde o <em>producer </em>envia nossas mensagens e também criou uma <em>queue </em>que recebe as mensagens do nosso <em>exchange.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GhXNU-IFb09ngUCuT6COdw.png" /><figcaption>Queue criada pelo Spring Cloud</figcaption></figure><p>Na aba <em>&quot;Queues&quot; </em>podemos verificar que foi criada uma queue associada ao exchange <em>&quot;simple-message&quot;. </em>Clicando nesta queue podemos obter mais informações importantes sobre a mesma.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v5j6Vxa5GkZzsDUt9Ig5BA.png" /><figcaption>Informações sobre uma Queue</figcaption></figure><p>Esta visão do Dashboard nos traz informações importantes sobre a <em>queue </em>criada. Nela podemos ver a taxa de mensagens transferidas além dos <em>consumers </em>e <em>bindings </em>associados com essa <em>queue.</em> Note que temos um <em>consumer, </em>que é nossa aplicação <em>spring-cloud-consumer-simple </em>consumindo a <em>queue </em>através de um <em>channel.</em> Além disso, temos os <em>bindings </em>dessa <em>queue. </em>No caso da imagem acima, nossa <em>queue </em>possui apenas um <em>binding, </em>que está vinculando-a com o <em>exchange &quot;simple-message&quot;.</em></p><p>E assim terminamos essa versão introdutória ao Spring Cloud Stream. Vimos que é possível utilizar o Spring Cloud Stream para facilitar o uso de um Message Broker sem precisar utilizar libs/código de um vendor específico. Isso proporciona uma independência de <em>vendors, </em>facilitando uma posterior mudança ou integração de outros <em>vendors </em>com um esforço muito menor.</p><p>Por enquanto, é isso!</p><p>Dúvidas, sugestões e feedbacks nos comentários.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/242/1*jV6AqKbfn2ehmdU_-Rc16w.jpeg" /></figure><h3>Pós-créditos</h3><p>Mas não para por aí!</p><p>Vimos apenas um exemplo (bastante) simples, mas em breve trarei outros exemplos mais interessantes e complexos utilizando o Spring Cloud Stream!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*iMu2MnTuW_qMTn5iIo25lQ.jpeg" /></figure><p><a href="https://medium.com/@jvoliveiran/spring-cloud-stream-simplificando-o-uso-de-message-broker-parte-2-e82d02e1371c"><strong>Link para a segunda parte aqui</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71f1731f5f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>