<?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 Bruno Baruffi on Medium]]></title>
        <description><![CDATA[Stories by Bruno Baruffi on Medium]]></description>
        <link>https://medium.com/@brunobaruffi?source=rss-bd5f43a2ed22------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*NwfRY0U8zQAifA4mMDXAoA.jpeg</url>
            <title>Stories by Bruno Baruffi on Medium</title>
            <link>https://medium.com/@brunobaruffi?source=rss-bd5f43a2ed22------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:56:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@brunobaruffi/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[Construindo esteiras CI e CD completas Jenkins com Docker e Java]]></title>
            <link>https://medium.com/@brunobaruffi/agora-vejamos-como-progredir-no-jenkins-121db01eba70?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/121db01eba70</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[containers]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sat, 08 Nov 2025 22:43:50 GMT</pubDate>
            <atom:updated>2025-11-08T22:47:06.736Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Construindo esteiras CI e CD completas Jenkins com Docker e Java</strong></p><p>Neste ponto, vamos começar com o nosso objetivo. Pretendemos criar no Jankins as esteiras de CI e de CD, inicialmente juntas e depois separadamente. Estas esteiras irão compilar um projeto Java no Github, e depois subir um Docker na maquina hospedeiro com essa API.</p><p>Então vamos aos nossos problemas: <br>* O Jenkins esta rodando dentro de um Docker o que, por si só, gera um problema. Como rodar um Docker do servidor Java se o próprio Jankins já esta rodando em um Docker.<br>* Para compilar precisamos do Maven ou de outro compilador que não esta instalado no Jenkins e não pretendemos instalá-los.</p><p>Começaremos com o problema do Jankins: <strong>Como fazer o Jankins conseguir subir um Docker?</strong></p><p>O que acontece aqui é que, apesar de ser possível, é altamente não recomendado rodar um Docker dentro de outro Docker. Essa técnica é muito exigente no sentido de hardware, sem contar que causa uma serie de dificuldades de gestão de infraestrutura, travamentos e desperdício de memoria.</p><p>A Solução ideal é permitir que o Jenkins, uma maquina virtual, possa manipular o Docker de sua hospedeira, ou seja, quando executarmos comandos no Docker, estes comandos refletirão no na maquina hospedeira.</p><p>Para isso precisamos ajustar a forma com que inicializaremos o Docker do Jenkins, ou seja, a forma com que o Jenkins é criado na chamada.</p><p>Veja o comando abaixo:</p><pre>docker run -d --name jankis2 -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home -v /var/run/docker.sock:/var/run/docker.sock jenkins/jenkins:lts</pre><p>OBS: Não faça criticas a eu ter dado o nome errado para meu container… jankis2 foi brava…kkkkk.</p><p>Se for sua primeira execução do Jenkins, o procedimento de senha é necessário, observe o artigo anterior para saber como verificar tal senha.</p><p>Este comando é como qualquer outro de inicializar um container, suas características padrões incluem:<br><strong>-d :</strong> Garante a execução em modo background. <br><strong>-- name jankis2 :</strong> O nome do container… <br><strong>-p 8080:8080 -p 50000:50000 :</strong> Essas são as portas compartilhadas… Já explicamos sobre isso em outros artigos mas, basicamente, estamos pegando as portas 8080 e a 50000 e externando de nosso container para a maquina hospedeira, nos permitindo assim acessar os recursos que queremos.<br><strong>-v jenkins_home:/var/jenkins_home : </strong>Volume compartilhado. Este volume garante a permanência da pasta /var/jenkins_home, de dentro do container para a maquina hospedeira, garantindo assim acesso a esses arquivos quando necessário. Neste caso estamos falando da pasta onde o Jenkins mantem tudo que é configurado ou feito nele.<br><strong>-v /var/run/docker.sock:/var/run/docker.sock : </strong>Essa é nossa solução, estamos compartilhando a pasta docker.sock de nossa maquina hospedeira com o container do Jenkins. Essa pasta garante que, os comandos Docker utilizados dentro do container afetem o mundo de fora, na maquina hospedeira. <br><strong>jenkins/jenkins:lts : </strong>A imagem da aplicação que vamos subir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JS7IZmouxdnsAJQT0bRqQQ.png" /></figure><p>Com essa execução, temos um container pronto.</p><p>Agora, precisamos executar alguns comandos dentro do container, e o motivo é que a imagem oficial do Jenkins, não possui o Docker instalado, sem ela, os comandos não funcionarão.</p><p>O segundo motivo é a permissão. Por mais que tenhamos compartilhados os arquivos do Docker da maquina hospedeira, a maquina interna não tem permissão para editar ali, para isso damos a permissão necessária. Veja os comandos abaixo:</p><pre>docker exec -it -u root jankis2 bash  <br><br>apt-get udapte  <br><br>apt-get install docker.io <br><br>chmod 666 /var/run/docker.sock</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1e5-qNV97B3gvEavWWrdSA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*r6hpvlhE1ndXltPf5H3aRw.png" /></figure><p>Essa sequencia de comandos simples, garante a instalação do Docker, através dos comandos <strong>apt-get</strong> e a permissão necessária para a pasta, com o comando <strong>chmod</strong>.</p><p>Sobre a permissão, o leitor pode pensar que não parece ser a solução mais segura. De fato não é, porem esta solução agrega um bom custo beneficio, entrega o funcionamento com pouco prejuízo a segurança. Para soluções mais robustas seria necessário vários passos adicionais.</p><p>Agora vamos acessar nosso Jankins no navegador através da URL: localhost:8080.</p><p>Criando um pipeline unificado.</p><p>Vamos começar, como indica as duas imagens abaixo, criando uma nova tarefa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EcJRPqbuJExmm7KtLk8LrA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*ZGQ3SJsmTvTOy-r2M4Lqaw.png" /></figure><p>O preenchimento dos campos agora dependerá do objetivo da esteira criada, começamos dando uma simples descrição geral.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_QcNnYoHaqmZxztXxnsFXw.png" /></figure><p>Na sequencia, marcamos a caixa “Esta construção é parametrizada” escolhendo a opção “Parâmetro de texto”. Este processo é necessário para que o usuário da esteira, quando a executar, possa digitar algum parâmetro que será utilizado na esteira. No nosso caso, vamos criar o parâmetro “BRANCH”, seu objetivo é bem claro, permitir que a esteira rode para qualquer branch do projeto git.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*QucQtLohqLt5uYHS8DVrTg.png" /></figure><p>Agora vamos aos “Passos de Construção”, onde escolheremos “Executar shell”. Nesta escolha, podemos escrever qualquer comando de terminal Linux, estes comandos serão executados pela esteira quando chegar o momento dela rodar.</p><p>Vamos executar os comandos abaixo, estes comandos já contemplam o conceito de CI e CD. Vamos entender o que acontece mais a frente.</p><pre>docker kill teste-api || true <br>docker rm teste-api || true  <br>rm -rf testeAPI  <br>git clone -b ${BRANCH} https://github.com/brunobaruffi/testeAPI  <br>cd testeAPI  <br>docker run --rm -v jenkins_home:/usr/src/mymaven -w &quot;/usr/src/mymaven/workspace/Projeto API JAVA/testeAPI&quot; --user $(id -u) maven:3.9.4-eclipse-temurin-11 mvn clean package -DskipTests  <br>cd target  <br>docker run -d --rm --name teste-api -p 3001:8080 -v jenkins_home:/app eclipse-temurin:11-jre-focal java -jar &quot;/app/workspace/Projeto API JAVA/testeAPI/target/testeAPI-1.0-SNAPSHOT.jar&quot; </pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3yrrNKOAasicDOegv14ZQA.png" /></figure><p>Não vamos explicar os comandos linha a linha, apenas o conceito geral.</p><p>Os primeiros 3 comandos consistem na interrupção do container e remoção dos arquivos referentes ao projeto que estamos traçando, garantindo terreno limpo para trabalhar.</p><p>Em seguida é feito o download do projeto através de um comando git clone. Este download já é feito utilizando a branch que foi escolhida via parâmetro, através do<strong> ${BRANCH}</strong>.</p><p>Em seguida ele entra na pasta do projeto e executa um comando Docker. Este comando tem a função de fazer o build da aplicação, ou seja compilar ou preparar para ser executado. No nosso caso aqui é criar o arquivo .jar necessário para execução posterior. Como não possuímos o Maven, ferramenta necessária para fazer o build deste projeto, usaremos um container Docker que irá executar o comando de build e colocar o resultado na pasta compartilhada do projeto.</p><p>Por fim, e feito a execução do comando Docker referente a execução do projeto em si, um novo container é criado, chamando a aplicação já compilada na esteira anterior. Aqui vale uma observação. Este container irá executar a aplicação Java que esta configurada para rodar na porta 8080, o que é um problema, visto que ela vai subir no mesmo hospedeiro que o Jankins, que também esta na porta 8080. Por isso o comando possui um desvio. “-p 3001:8080” este desvio ira pegar a porta 8080 do container e direcionar para a porta 3001 da maquina hospedeira, uma porta livre e disponível para o serviço.</p><p>Com isso encerramos os comandos, mas fica um ponto de atenção, se notar bem, perceberá os arquivos originais do projeto foram baixados pelo Jankins, que esta dentro de um container, já o Maven, foi executado em outro container, e o Java também foi executado em outro container, por mais que as configurações do Docker do container do Jankins esteja utilizando o computador hospedeiro, ainda sim como eles compartilham esses arquivos?</p><p>Simples, todos os três comandos compartilham o mesmo <strong>docker volume</strong>, o ‘jenkins_home’. Este volume foi criado para conter todos os projetos feitos nas esteiras do Jankins, logo os arquivos estão lá também. Passando esse volume os arquivos vão de aplicação a aplicação, sendo passado e permitindo que todas tenham acesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*cq8VI9BmTAM9fhNsWoEVdw.png" /></figure><p>Vamos ao teste, após salvar vamos executar a esteira em “Construir com parâmetros”, passando a branch main como padrão de execução.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/1*UiC043b8ARk2Qw7tjpxIxA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*HwitTOt0jyLuDFUUjkyufQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BzdvdJZs5iFm77pqLqS6NQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*zgLWTp_fNZbxlvkmE226kg.png" /></figure><p>Agora vamos a segunda parte, dividiremos este projeto em duas esteiras, visto que, em um ambiente corporativo real, o ato de fazer o build é feito na esteira de CI e o de executar é feito por CD.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*3MWNFBadDKYUSUpPehk-UA.png" /></figure><p>Para isso, foram criadas duas novas esteiras, vamos abstrair esse processo, já vimos como é feito.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*apVgvVi9PC2RWdkfk7gN5Q.png" /></figure><p>Esta esteira irá precisar também do parâmetro “BRANCH” visto que ela ira puxar o projeto. Observe os comandos abaixo.</p><pre>rm -rf testeAPI<br>git clone -b ${BRANCH} https://github.com/brunobaruffi/testeAPI  <br>cd testeAPI  <br>docker run --rm -v jenkins_home:/usr/src/mymaven -w &quot;/usr/src/mymaven/workspace/JAVA CI/testeAPI&quot; --user $(id -u) maven:3.9.4-eclipse-temurin-11 mvn clean package -DskipTests  </pre><p>Podemos ver que, é basicamente um recorte dos comandos da esteira unificada, neste conjunto de comandos, a pasta testeAPI é removida, refeita através do git clone e depois é feito o build com um container do Maven.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aBPJGE4L6Wxw0gO6jB-bRQ.png" /></figure><p>Agora vamos a esteira de CD.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*g7GWYgLFiVtc8JUOTrtH5w.png" /></figure><p>Diferente da esteira anterior, nenhum parâmetro é necessário aqui.</p><pre>docker kill teste-api || true <br>docker rm teste-api || true <br>rm -rf testeAPI<br>cp -r &quot;/var/jenkins_home/workspace/JAVA CI/testeAPI&quot; &quot;/var/jenkins_home/workspace/JAVA CD/testeAPI&quot;<br>docker run -d --rm --name teste-api -p 3001:8080 -v jenkins_home:/app eclipse-temurin:11-jre-focal java -jar &quot;/app/workspace/JAVA CD/testeAPI/target/testeAPI-1.0-SNAPSHOT.jar&quot; </pre><p>Observamos novamente, é basicamente um recorte da esteira unificada anterior, com apenas uma diferença, o comando de copia. Este comando tem a função de pegar a pasta do projeto, presente dentro dos arquivos da esteira de CI e trazer para a pasta de trabalho da esteira de CD, com o objetivo de executar a copia, dando autonomia para que a esteira de CI possa deletar e fazer o build novamente sem se preocupar com o programa em execução.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E9aMr1FFKcPP9oDgX86Rlw.png" /></figure><p>Obtivemos o mesmo resultado, só que agora em duas esteiras separadas. O Objetivo disso é claro, dar autonomia e segurança aos processos, permitindo uma execução limpa e diminuição do tempo desligado do container da aplicação. Visto que o container da aplicação só é desligado quando um novo já esta pronto e preparado para uso.</p><p>Saliento que, esta é uma versão funcional porem simplificada, podemos construir centenas de esteiras diferentes para todo tipo de finalidade e podemos acrescentar quandos passos forem necessarios nessas esteiras, como validações de segurança, validações de qualidade do codigo, testes etc… Tenha em mente que Esteiras são um recurso valioso e de possibilidades infinitas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=121db01eba70" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Esteiras de produção Subindo um projeto do git no Render Parte 2]]></title>
            <link>https://medium.com/@brunobaruffi/esteiras-de-produ%C3%A7%C3%A3o-subindo-um-projeto-do-git-no-render-parte-2-c78555487eed?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/c78555487eed</guid>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[deploy]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[render]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sat, 25 Oct 2025 16:44:58 GMT</pubDate>
            <atom:updated>2025-10-25T16:44:58.601Z</atom:updated>
            <content:encoded><![CDATA[<p>Agora que entendemos como o Render funciona, vamos partir para a segunda parte, vamos interagir com o Render via Github utilizando o gitActions.</p><p>O gitActions é uma pipeline do Github que permite a execução de comandos, geralmente envolvendo o deploy da aplicação, atrelados a commits ou pullrequests.</p><p>Para nossa abordagem, vamos criar uma pipeline no Github que, atrelado a branch main e a cada commit feito nela, ela refaça o deploy no Render para garantir que sempre a ultima versão esteja online.</p><p>Para viabilizar isso, antes de irmos para o Github, vamos aproveitar a pipeline que criamos no Render no artigo anterior para nossa implementação. Neste sentido precisamos pegar duas informações muito importantes para colocar no no nosso script do gitActions, a <strong>Service_ID</strong> e a <strong>API_Key</strong>.</p><p>A Service_ID identifica qual o serviço que deve sofrer o pedido de deploy, já a API_Key, me da a permissão para isso.</p><p>Vamos lá, para obter a Service_ID, vamos a tela do serviço, pois esta lá:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mS1KXiq9sEC9vAtJYHDkag.png" /></figure><p>Bem facinho de achar.</p><p>Agora vamos a API_Key, essa é atrelada ao meu usuario, então vou para as configurações do usuario no canto superior direito da tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kkYM5wGfkMDgGx_QfkPmRQ.png" /></figure><p>Lá você deve abrir as “Account Settings”.</p><p>Uma vez com a pagina aberta, crie uma API_Key na guia de APIs_Keys na pagina que se abriu:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kaRr0waXlhi5REhRGBIFoA.png" /></figure><p>Podemos ter varias, como você pode ver, vou criar uma apenas para esse tutorial, depois vou excluir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*zRCRXx7wIoG7PzA-KM9srg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*ZwGDMkXXVrPcue0Ix0Q-Ig.png" /></figure><p>Agora, munido destas duas informações, vamos ao projeto no Github par implementar nossa esteira.</p><p><strong>No GitHub</strong></p><p>Antes de começar a programar o script de deploy, precisamos criar duas variáveis no repositório, para armazenar as chaves que pegamos no Render.</p><p>Estas chaves precisam estar no Script, porem se forem colocadas diretamente lá, qualquer pessoa que tenha acesso ao repositório pode pegar as chaves e fazer qualquer coisa com o ambiente, para isso criaremos as variáveis internamente no Github.</p><p>Para isso, em nosso repositório, vamos na guia “Settings” e lá dentro na guia “Environments”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TUcUGo-Z-uAVDuEB6aw3fg.png" /></figure><p>Nesta tela, clique em “New environment”, para criar um novo conjunto de variáveis, de uma nome e siga adiante.</p><p>Depois de dar o nome, você deve cair nesta tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NVj8UxeCSDArTDeugJkPdQ.png" /></figure><p>Nela, procure o botão “Add environment secret”. Aqui o objetivo é adicionar duas variaveis, uma contendo a primeira SERVICE_ID e a segunda contendo a API_SECRET.</p><p>Vamos criar as varíaveis com esses nomes: RENDER_API_KEY e RENDER_SERVICE_ID, atrelando as chaves a elas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/907/1*K95D6WTocRRxVj6RLhV4pA.png" /></figure><p>Faremos o mesmo com a RENDER_SERVICE_ID.</p><p>Tendo um resultado final:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*kHrEkgCNFBgwJJwgUYpPVQ.png" /></figure><p>Observe que, agora ninguém, nem mesmo você consegue recuperar essas informações, apenas substitui-las.</p><p>Vamos agora fazer a implementação do script. Para isso, este script precisa ser salvo em uma pasta especifica dentro do projeto, a pasta “.github/workflows”. Nosso arquivo será salvo com o nome: “deploy.yml”.</p><p>Este arquivo, vai conter as “configurações necessárias para executar o deploy no Render. Vamos ao Codigo:</p><pre>name: Deploy Node.js no Render<br><br>on:<br>  push:<br>    branches:<br>      - main<br><br>jobs:<br>  deploy:<br>    runs-on: ubuntu-latest<br><br>    steps:<br>      - name: Checkout código<br>        uses: actions/checkout@v4<br><br>      - name: Instalar dependências<br>        run: npm install express cors<br><br>      - name: Deploy no Render<br>        uses: johnbeynon/render-deploy-action@v0.0.8<br>        with:<br>          service-id: ${{ secrets.RENDER_SERVICE_ID }}<br>          api-key: ${{ secrets.RENDER_API_KEY }}</pre><p>Este pequeno script executa um passo a passo, como foi designado a fazer.</p><p>Na primeira parte, logo após darmos o nome a ele, ele define em que branch que ele vai ser executado, no nosso caso, a main.</p><p>Na sequencia vem os ‘jobs’ são os trabalhos que ele vai executar um a um. O primeiro cria um pequeno container Ubuntu para executar o que vier a seguir, na sequencia, temos os passos ‘steps’.</p><p>O que é importante para nos aqui, ele vai baixar o arquivo .js, vai executar aquele ‘npm install express cors’ que esta definido, e depois vai utilizar uma biblioteca pronta, a ‘render-deploy-action’ para apenas precisar passar as variáveis do render.</p><p>Observe que, passamos os nomes das variáveis, não seu conteúdo, assim mesmo que alguém possa ver este script ainda não pode executar sozinha.</p><p>Uma vez que este arquivo feito o commit, a esteira já entrará em execução, e sempre executara quando houver um commit na main. Para verificar as esteiras, vá na guia Actions na parte superior do projeto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bG12maY0fHRsi5Iz9rfJdA.png" /></figure><p>Podemos ver que foi sucesso, para verificar seu fluxo, podemos clicar na esteira e ver o que ela fez:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sMBKEWuZGqg2tQM-ECjf1w.png" /></figure><p>Para verificar se a esteira efetivamente funcionou, podemos olhar no Render. Ao entrar no dash do nosso projeto, nos deparamos com a seguinte tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_wbcz3LJahG2g-Xdk1eeUA.png" /></figure><p>Percebemos pelo horario que a esteira foi chamada corretamente, indicando que tudo foi executado com sucesso.</p><p>Com isso terminamos nosso processo de deploy no Render, no futuro viremos com Jankins.</p><p>Obrigado e até.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c78555487eed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Esteiras de produção Subindo um projeto do git no Render Parte 1]]></title>
            <link>https://medium.com/@brunobaruffi/esteiras-de-produ%C3%A7%C3%A3o-subindo-um-projeto-do-git-no-render-parte-1-75f8780426da?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/75f8780426da</guid>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[deploy]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[render]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sat, 25 Oct 2025 16:01:02 GMT</pubDate>
            <atom:updated>2025-10-25T16:01:02.379Z</atom:updated>
            <content:encoded><![CDATA[<p>Ola meu caros e minhas caras, hoje vamos começar nossos estudos sobre esterias de deploy e implementação na pratica.</p><p>Começaremos com as premissas.</p><p>O que queremos?</p><p>Bom, nosso objetivo é criar uma esteira de deploy para subir uma aplicação em nodeJS na nuvem do <a href="http://www.render.com/">www.render.com</a>. Mas antes, vamos falar sobre o Render.</p><p>O Render é um sistema de nuvens que possui um recurso bem interessante, consegue subir aplicações JS ou Docker do dockerHub gratuitamente, claro que com recursos bem restritos.</p><p>Este artigo será dividido em duas partes, a primeira é a configuração de uma esteira do Render que faz tudo para nós, sem nenhum automação do no Github, já na segunda parte automatizaremos o Github para chamar o deploy no Render.</p><p>Primeiro passo, devemos nos cadastrar no Render, vou me abster de falar do processo de cadastro pois é o padrão de todo cadastro, recomendo logar utilizando o github, pois facilita muito o processo.</p><p>Uma vez cadastrado, você deve dar de cara um uma tela assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AULZzjEI8BMqAcQ3BT3omg.png" /></figure><p>Em minha tela, como pode ver, já existe um projeto de teste, o ‘My project” é provável que na de pessoas que recém criaram a conta não tenha nada.</p><p>Ótimo, agora vamos criar um projeto de deploy, para isso vamos clicar naquele “Create new Project” ali no centro da tela.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RMO9HAbzRX311i3IH6hAvw.png" /></figure><p>Neste ponto, temos um projeto, podemos agora criar varios serviços dentro deste projeto. Vamos começar nosso trabalho clicando no botão preto ali em baixo, o “Create new service”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ai6ekrQhg9mdOQObhfGmAA.png" /></figure><p>Podemos ver que estão disponíveis uma serie de tipos de serviços, cada um possui características diferentes. Para nosso exemplo, vamos fazer o mais clássico, o WebService. Pois ele garante a subida de uma API, que é o que faremos aqui.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qwLSEfClaAvNQZSMBBBBYw.png" /></figure><p>A criação do Web Service agora vai ser atrelada ao git. Caso você tenha efetuado o login utilizando o Github como ferramenta de login, aqui você pode usar o ‘Git Provider’ e importar seu projeto, sendo ele privado ou publico. Caso seu projeto seja publico, pode utilizar o “Public Git Repository”, como feito na imagem, para atrelar o projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jnPS0HEnEniShpMSuG8JYQ.png" /></figure><p>Podemos ver que temos uma serie de configurações disponiveis, cada uma pode ser facilmente entendida lendo suas descrições, porem para maior entendimento, vamos ver as mais criticas.</p><p><strong>Language: </strong>Linguagem utilizada para build<br><strong>Branch: </strong>Qual branch vai ser pega para executar o processo de deploy.<br><strong>Build Command:</strong> Qual comando vai ser executado para rodar a compilação<br><strong>Start Command:</strong> Qual comando executa o programa.</p><p>Estes últimos dois, o Build Command e o Start Command, precisam ser ajustados para contemplar a execução de nosso projeto js.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ZgRoG9KCjOgxWWIFbzPcA.png" /></figure><p>Neste pondo, tenha atenção, para meu projeto, estes são os comandos necessários para ele executar, o primeiro faz a instalação, cria os arquivos requeridos e etc… Já para subir minha API, o comando apenas executa via node.</p><p>ATENÇÃO: Estes são comandos para este exemplo, para seu código, você precisa colocar aqui o que for necessário para criar o build e subir.</p><p>Um ultimo ponto de atenção é na escolha final:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AJGDdwFn40dIgQhe9Q95lw.png" /></figure><p>Escolhi o grátis, e recomendo que faça o mesmo.</p><p>Existem muitos outros detalhes que podem ser configurados, variaveis de ambiente, condições especiais etc… Para nosso exemplo esta de bom tamanho.</p><p>Vamos clicar agora em “Deploy Service”, botão preto ao fim do formulário.</p><p>Ao clicar no botão, chegamos a este resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-xy_SQZSsxBdCQF4YCNYDQ.png" /></figure><p>Atenção: Este processo de deploy demora um pouco, principalmente no final quando é enviado o link do serviço.</p><p>Uma vez carregado, clique no link e você será direcionado o serviço rodando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NR1wqzpBU9RmjKJM5uZ3XA.png" /></figure><p>Outro ponto de atenção, se estiver utilizando minha API de teste, precisa acrescentar o /alunos no final da execução.</p><p>Uma ultima observação, é possivel fazer o redeploy ou qualquer outra gestão desta API diretamente na mesma tela no botão “Manual Deploy”, como lista a tela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TMpcNDS8JLCpbG9HMTazvA.png" /></figure><p>Caso um novo commit aconteça, apenas refazendo o deploy com o ultimo commit bastará para garantir que a nova versão suba para o ambiente.</p><p>Com isso termino esta parte 1, na parte 2 faremos o deploy a partir do Github, programando para ele fazer o deploy sempre que um novo commit for executado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75f8780426da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Utilizando Docker para rodar seu projeto Java]]></title>
            <link>https://medium.com/@brunobaruffi/utilizando-docker-para-rodar-seu-projeto-java-8c9290eee197?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c9290eee197</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[dockerfiles]]></category>
            <category><![CDATA[programação]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sun, 05 Oct 2025 23:03:13 GMT</pubDate>
            <atom:updated>2025-10-05T23:03:13.713Z</atom:updated>
            <content:encoded><![CDATA[<p>Olá leitores, hoje nosso registro é sobre Docker, em especial como rodar um projeto Java em uma chamada Docker.</p><p><strong>Vamos começar com o Java</strong></p><p>Para que possamos executar nosso projeto Java dentro do Docker precisamos começar com o entendimento de como criar o “executável” dentro do Java.</p><p>Não é o objetivo aqui explorar as nuances do Java, logo vamos direto ao ponto, precisamos do arquivo .jar de nosso projeto, que é o equivalente compilado do código e também de uma configuração especifica.</p><p>Pra começar, estamos usando o Maven e lá temos o arquivo pom.xml, onde fazemos nossas customizações do projeto, adicionamos dependências etc. Neste local, configuraremos o build (geração do arquivo ‘.jar’) para que o mesmo saiba onde esta o ponto inicial do nosso projeto.</p><pre>&lt;project&gt;<br>&lt;!-- outras coisas --&gt;<br>    &lt;build&gt;<br>        &lt;plugins&gt;<br>            &lt;plugin&gt;<br>                &lt;groupId&gt;org.apache.maven.plugins&lt;/groupId&gt;<br>                &lt;artifactId&gt;maven-jar-plugin&lt;/artifactId&gt;<br>                &lt;version&gt;3.3.0&lt;/version&gt;<br>                &lt;configuration&gt;<br>                    &lt;archive&gt;<br>                        &lt;manifest&gt;<br>                            &lt;addClasspath&gt;true&lt;/addClasspath&gt;<br>                            &lt;mainClass&gt;org.example.Main&lt;/mainClass&gt;<br>                        &lt;/manifest&gt;<br>                    &lt;/archive&gt;<br>                &lt;/configuration&gt;<br>            &lt;/plugin&gt;<br>        &lt;/plugins&gt;<br>    &lt;/build&gt;<br>&lt;/project&gt;</pre><p>No código acima, temos a configuração, onde é dito que dentro do ‘org.example.main’ esta nossa classe onde existe um ‘main’ ou seja, onde existe o código que deve ser executado quando o programa for chamado externamente.</p><p>Uma atenção a alguns detalhes, como a versão do Maven utilizada, aquela é a versão que já estava na minha maquina, podendo, no geral, ser utilizada a versão mais recente.</p><p>Um segundo ponto é o endereço da classe Main, presente dentro do &lt;manifest&gt;. Neste local deve ser colocado o endereço da sua classe “Main” (que não precisa ter esse nome, apenas o método ‘main’ que você julgar ser o método principal), então tenha atenção na hora de preencher esse campo com o seu endereço correto. Como na imagem abaixo, você pode conferir o endereço pelo que estiver escrito no ‘package’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/1*Clxb6KVYZNuhsv_v15WH0g.png" /></figure><p>Com este processo ponto, você precisa gerar o arquivo ‘.jar’ e para isso, pode ser utilizada a ide que estiver programando ou a linha de comando para executar uma instalação com o Maven. O comando é:</p><pre>mvn clean install</pre><p>Este comando pode ser executado no próprio terminal ou diretamente na ide, como visto aqui no Intellij:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EdNhcEsrI_7xtwLsakYLIw.png" /></figure><p>Após a execução bem sucedida do processo, uma nova pasta ira aparecer em seu projeto, a pasta ‘target’ e nela encontraremos o arquivo que precisamos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/487/1*jQeYUyRAWnQxuHvyqGDDMQ.png" /></figure><p>Irei copiar este arquivo e mover para uma pasta mais conveniente e renomear ele para ‘projeto.jar’. A pasta em questão não importa, então vai para a documents do meu usuário.</p><p>Com isso temos um programa que precisamos.</p><p><strong>Vamos a execução do Docker.</strong></p><p>Presumindo que você já tenha visto meus posts anteriores sobre Docker, entende que, na pratica, a ideia é subir uma virtualização para executar nosso comando.</p><p>Vejamos o comando:</p><pre>docker run --rm -it -v &quot;C:\Users\bruno\Documents\app:/app&quot; -w /app openjdk:21 java -jar projeto.jar</pre><p>Este comando, pode ser dividido em seus parâmetros:</p><ul><li><strong>— rm</strong> : cuja função e deletar a virtualização assim que ela for encerrada.</li><li><strong>-it</strong> : deixa interativo, ou seja, o terminal que esta executando este comando vai mostrar o resultado.</li><li><strong>-v</strong> : é o volume, no geral usado para levar pastas ou volumes docker para dentro de uma aplicação. Neste exemplo esta levando a pasta ‘app’ onde nosso projeto esta para dentro da pasta ‘/app’ dentro da maquina virtual.</li><li><strong>-w</strong> : coloca o terminal de comando da maquina virtual dentro da pasta ‘/app’.</li><li><strong>openjdk:21</strong> : invoca a imagem do openjdk na versão 21, uma maquina virtual pré-pronta que possui o Java 21 funcionando.</li><li><strong>java -jar projeto.jar</strong> : chamamos o comando que queremos executar, no caso o comando para rodar nosso projeto.</li></ul><p>Vejamos o resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DDk5jnVkgcP9PQTpLMzBtA.png" /></figure><p>Com isso temos a execução de nosso projeto, porem podemos melhorar e configurar um dockerfile para criar uma imagem deste projeto do zero.</p><p>Criando um dockerfile para nosso projeto.</p><p>Num artigo posterior, trataremos dos meandros de como funciona um dockerfile, para agora vamos demonstrar a solução que encontramos para nosso projeto.</p><p>Devemos criar um arquivo de nome ‘dockerfile’ na mesma pasta onde encontra-se nosso projeto. Este arquivo não deve possuir extensão, e seu conteúdo deve ser:</p><pre>FROM openjdk:21<br><br>WORKDIR /app<br><br>COPY projeto.jar projeto.jar<br><br>CMD [&quot;java&quot;, &quot;-jar&quot;, &quot;projeto.jar&quot;]</pre><p>Não entraremos em detalhes sobre o funcionamento de cada comando dockerfile neste momento porem, para o entendimento deste arquivo, podemos dizer que:</p><p>A clausula <strong>FROM </strong>define a imagem base. A <strong>WORKDIR </strong>define a pasta onde qualquer comando posterior será executado. A <strong>COPY </strong>copia um arquivo externo para dentro da imagem, no nosso exemplo copiando o projeto.jar que esta na mesma pasta do arquivo ‘dockerfile’ para a pasta ‘/app’ com o nome de projeto.jar. Por fim o comando <strong>CMD </strong>que executa o comando principal desta maquina, sendo ele o responsável por chamar o programa em execução.</p><p>A pasta dede ficar parecida com isso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*SXnyqfTt351idyn-zx7UwQ.png" /></figure><p>Seguindo adiante vamos criar nossa imagem baseando-se no arquivo e para isso executamos o seguinte comando dentro da pasta do projeto:</p><pre>docker build -t nossoapp .</pre><p>Este comando vai criar uma imagem chamada ‘nossoapp’.</p><p>Veja o resultado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*BPb2lOCauWsw5AKmVK25eQ.png" /></figure><p>Com isso terminamos nossa explicação, espero ter ajudado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c9290eee197" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desvendando o Padrão de Projeto — Builder]]></title>
            <link>https://medium.com/@brunobaruffi/desvendando-o-padr%C3%A3o-de-projeto-builder-feb584eda515?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/feb584eda515</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[builder-pattern]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Thu, 03 Apr 2025 03:15:22 GMT</pubDate>
            <atom:updated>2025-04-03T03:29:12.520Z</atom:updated>
            <content:encoded><![CDATA[<h3>Desvendando o Padrão de Projeto — Builder</h3><p>Boa pessoal! Hoje vamos de padrão Builder.</p><p>O padrão Builder é utilizado para montagem de componentes complexos, ou seja, quando precisamos montar um por exemplo um objeto, podemos fazer com ele de forma simples e pratica.</p><p>Vejamos um comparativo de montagem de um objeto Aluno:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/617/1*17XI5UjH36rHegJ94qWHyA.png" /></figure><p>O Segredo do padrão builder surge no crescimento dos componentes, conforme o objeto fica maior, possuir um builder implementado faz muita diferença na velocidade de montagem do objeto e na facilidade, visto que podemos automatizar todo esse processo.</p><p>Vamos ao código:</p><p>Começamos com a classe Aluno, onde criaremos nosso objeto e onde o builder e programado.</p><p><strong>Aluno.java</strong></p><pre>public class Aluno {<br>   private String nome;<br>   private String telefone;<br>   private Integer anoCadastro;<br><br><br>   private Aluno(AlunoBuilder alunoBuilder) {<br>       this.nome = alunoBuilder.nome;<br>       this.telefone = alunoBuilder.telefone;<br>       this.anoCadastro = alunoBuilder.anoCadastro;<br>   }<br><br><br>   @Override<br>   public String toString() {<br>       return &quot;Aluno{&quot; +<br>               &quot;nome=&#39;&quot; + nome + &#39;\&#39;&#39; +<br>               &quot;, telefone=&#39;&quot; + telefone + &#39;\&#39;&#39; +<br>               &quot;, anoCadastro=&quot; + anoCadastro +<br>               &#39;}&#39;;<br>   }<br><br><br>  //gets e sets<br><br><br>   public static class AlunoBuilder{<br>       private String nome;<br>       private String telefone;<br>       private Integer anoCadastro;<br><br><br>       public AlunoBuilder nome(String nome){<br>           this.nome = nome;<br>           return this;<br>       }<br>       public AlunoBuilder telefone(String telefone){<br>           this.telefone = telefone;<br>           return this;<br>       }<br>       public AlunoBuilder anoCadastro(Integer ano){<br>           this.anoCadastro = ano;<br>           return this;<br>       }<br><br><br>       public Aluno build(){<br>           return new Aluno(this);<br>       }<br>   }<br>}</pre><p><strong>Classe dentro de classe.</strong></p><p>Primeiramente percebemos que temos uma classe dentro da outra. Isso é possível apesar de na maioria das vezes não ser muito usado. Neste caso, criamos a classe de buider dentro da classe do nosso objeto, além de ser mais organizado, permite acesso às variáveis do objeto sem os gets e sets, o que facilita a programação, porém não é uma necessidade, você pode separar as classes.</p><p><strong>Os métodos.</strong></p><p>Dentro desta classe AlunoBuilder, percebemos que ela funciona parecido com os sets, porém elas retornam o próprio objeto, visto a linha que tem o ‘return this’. Ele está retornando ele mesmo, ou seja, ele mesmo depois de preencher a informação que desejamos. Fazendo isso, podemos ir chamando método a método sem a necessidade de pular linha já que ele sempre retorna a si mesmo.</p><p><strong>Build e classe privada.</strong></p><p>Por fim percebemos o método build. Este método tem a função de converter essa classe AlunoBuilder em uma classe Aluno, como podemos ver, o construtor da classe Aluno está privado e recebe apenas um AlunoBuilder para ser preenchido. Sendo assim, não existe outra maneira de criar uma classe Aluno sem ser pelo builder.</p><p>Por fim agora só nos resta uma chamada de teste, vejamos nosso main.</p><p><strong>Main.java:</strong></p><pre>public class Main {<br>   public static void main(String[] args) {<br><br><br>       Aluno novoAluno = new Aluno.AlunoBuilder()<br>               .nome(&quot;Bruno&quot;)<br>               .telefone(&quot;123123123&quot;)<br>               .anoCadastro(2000)<br>               .build();<br>       System.out.println(novoAluno.toString());<br><br><br>   }<br>}</pre><p>Percebemos como fica mais simples criar as classes, e mesmo se as mesmas forem bem complexas com subClasses, que geralmente exigirá mais cuidado para criação, tudo pode ser abstraído na criação das classes builder, fazendo a criação bem fácil e rápida.</p><p><strong>Vejamos o resultado:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/589/0*61KXNk49PD6Ew-ib" /></figure><p>Espero que tenha ficado claro, vejo vocês na próxima.</p><p><strong>Segue abaixo o link do projeto do GIT:</strong></p><p><a href="https://github.com/brunobaruffi/DesignPatternsJavaEstudo/tree/main/Singleton">https://github.com/brunobaruffi/DesignPatternsJavaEstudo/</a></p><p><strong>Texto original:</strong></p><p><a href="https://docs.google.com/document/d/1RwYf26l3TmwYq1Mo3xyaRh_wKSVab4b8H4nDLwxiRnY/edit?usp=sharing">https://docs.google.com/document/d/1un6LjJN1jSNs9WxE5r1HWiOMmNzs7hBAPLUgxMLpLZ0/edit?usp=sharing</a></p><p><strong>Bibliografia recomendada:</strong></p><p><a href="https://refactoring.guru/design-patterns/builder">https://refactoring.guru/design-patterns/singleton</a></p><p><strong>Lista de Design Patterns:</strong></p><p><a href="https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee">https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*Dr0EfZCEY6XAGN1mQcF4MA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=feb584eda515" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blockhcain, implementação simples em java parte 1.]]></title>
            <link>https://medium.com/@brunobaruffi/blockhcain-implementa%C3%A7%C3%A3o-simples-em-java-parte-1-9d0a02c08d2c?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d0a02c08d2c</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[poc]]></category>
            <category><![CDATA[blockchain-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sun, 10 Nov 2024 21:20:14 GMT</pubDate>
            <atom:updated>2024-11-10T21:20:14.540Z</atom:updated>
            <content:encoded><![CDATA[<p>Olá senhores, hoje vamos criar um novo projeto, ou melhor, começar um novo estudo, a criação de uma blockchain. Não vamos nos alongar muito nos conceitos primários sobre o que é seremos bem rápidos neste aspecto para podermos ir diretamente para a parte prática.</p><p>O que é uma Blockchain.</p><p>Na prática, é um grande livro de registros onde, em cada página, é anotada alguma informação, no caso de das coins como o Bitcoin, as transações financeiras e os destinos das moedas são os registros presentes.</p><p>Em suma, uma blockchain é uma corrente de blocos, onde cada bloco é essa folha do livro de registros.</p><p>Para garantir o funcionamento deste processo e sua integridade, é utilizado chaves criptográficas que registram os blocos, e registram a posição dele nesta cadeia de blocos, o responsável por esse processo é o minerador.</p><p>Como dito anteriormente, não vou me alongar nos conceitos teóricos neste artigo, pode ser que, no futuro, escreva algo sobre, mas em resumo podemos dizer:</p><p><strong>Bloco</strong>: O que será registrado, ele é criado pelos mineradores e registrado na blockchain para permanecer imutável.</p><p><strong>Blockchain</strong>: Sequência de blocos que é mantida por nós.</p><p><strong>Nós</strong>: Locais físicos que contém as muitas cópias da blockchain.</p><p><strong>Mineradores</strong>: Aqueles responsáveis por minerar os blocos, ou seja, montar eles e garantir que a criptografia atenda a dificuldade que a rede exige.</p><p><strong>Dificuldade da rede</strong>: Controle imposto na rede para garantir que a criptografia e a criação de nós seja feita em um tempo previsível e gerar uma concorrência entre os mineradores.</p><p>Com isso, temos um foco, nosso projeto será extremamente básico, um POC (prova de conceito) bem sucinto, apenas para demonstrar o funcionamento com apenas um minerador e um nó. Não criaremos a infra necessária para que haja concorrência e nem múltiplos nós (isso ficará para a parte 2).</p><p>Vamos utilizar o bom e velho Java 17, não por qualquer peculiaridade, (é o que está mais fácil aqui na minha máquina) com Spring, visto que utilizaremos as API’s dele para nos comunicar (gosto de APIs). Lembrando que essa é uma implementação de muitas possíveis.</p><p>Sendo um projeto Spring, vou colocar aqui embaixo pom.xml, para dar uma noção das importações feitas:</p><p>pom.xml (apenas as dependências)</p><pre>&lt;dependencies&gt;<br>   &lt;dependency&gt;<br>      &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>      &lt;artifactId&gt;spring-boot-starter-web&lt;/artifactId&gt;<br>   &lt;/dependency&gt;<br><br><br>   &lt;dependency&gt;<br>      &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>      &lt;artifactId&gt;spring-boot-devtools&lt;/artifactId&gt;<br>      &lt;scope&gt;runtime&lt;/scope&gt;<br>      &lt;optional&gt;true&lt;/optional&gt;<br>   &lt;/dependency&gt;<br>   &lt;dependency&gt;<br>      &lt;groupId&gt;org.projectlombok&lt;/groupId&gt;<br>      &lt;artifactId&gt;lombok&lt;/artifactId&gt;<br>      &lt;optional&gt;true&lt;/optional&gt;<br>   &lt;/dependency&gt;<br>   &lt;dependency&gt;<br>      &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;<br>      &lt;artifactId&gt;spring-boot-starter-test&lt;/artifactId&gt;<br>      &lt;scope&gt;test&lt;/scope&gt;<br>   &lt;/dependency&gt;<br>&lt;/dependencies&gt;</pre><p>Agora vamos aos pontos importantes, faremos 3 classes, uma para o bloco, uma para o minerador e uma para a blockchain. Por fim criaremos a api correspondente ao nó.</p><p>Começamos com o bloco, chamaremos de block.java, criarei dentro de uma pasta chamada ‘services’:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/0*6fRXJixeD-4zRJNz" /></figure><p>Vamos ao código da primeira classe:</p><p>Block.java</p><pre>public class Block {<br>   private int index; // índice do bloco na cadeia<br>   private long timestamp; // timestamp de criação<br>   private String data; // dados armazenados no bloco (pode ser uma transação, por exemplo)<br>   private String previousHash; // hash do bloco anterior, garantindo encadeamento<br>   private String hash; // hash do bloco atual, definido na criação do bloco<br><br><br>   public Block(int index, long timestamp, String data, String previousHash) {<br>       this.index = index;<br>       this.timestamp = timestamp;<br>       this.data = data;<br>       this.previousHash = previousHash;<br>       this.hash = calculateHash();<br>   }<br><br><br>   // Método para calcular o hash com base nas informações do bloco<br>   public String calculateHash() {<br>       String input = index + Long.toString(timestamp) + data + previousHash;<br>       return applySHA256(input); // Função auxiliar para calcular o hash (definida abaixo)<br>   }<br><br><br>   // Método para aplicar o algoritmo SHA-256 (algoritmo de hash criptográfico)<br>   private String applySHA256(String input) {<br>       try {<br>           MessageDigest digest = MessageDigest.getInstance(&quot;SHA-256&quot;);<br>           byte[] hashBytes = digest.digest(input.getBytes(&quot;UTF-8&quot;));<br>           StringBuilder hexString = new StringBuilder();<br>           for (byte b : hashBytes) {<br>               hexString.append(String.format(&quot;%02x&quot;, b));<br>           }<br>           return hexString.toString();<br>       } catch (Exception e) {<br>           throw new RuntimeException(e);<br>       }<br>   }<br><br><br>//gets end sets<br>}</pre><p>Este objeto contém as seguintes propriedades:</p><p>index: A posição numérica de referência deste bloco na blockchain, na prática o último bloco da blockchain mais 1.</p><ul><li><strong>timestamp</strong>: Data e hora que a criação deste bloco ocorreu.</li><li><strong>data</strong>: Os dados a serem salvos, na prática as informações sejam quais forem.</li><li><strong>previousHash</strong>: O hash do bloco anterior.</li><li><strong>hash</strong>: A nova hash, que é gerada no momento da criação do bloco e atualizada até que a mesma seja aceita pela dificuldade.</li></ul><p>Já os métodos presentes nesta classe, com exceção dos gets e sets, temos:</p><p><strong>calculatehash</strong>: Um método que, apenas junta todas as informações das propriedades do bloco, ou seja todas as variáveis que compõem o bloco e aplica o método que irá criar uma hash.</p><p><strong>applySHA256</strong>: Método destrinchado do método acima, ele apenas tem a função técnica de aplicar o algoritmo de SHA256, muito utilizado para criação de chaves hash.</p><p>Indo para a próxima classe, a Minerador.class:</p><pre>package com.blockchain.services;<br><br><br>public class Minerador {<br>   private int dificuldade;<br><br><br>   public Minerador(int dificuldade) {<br>       this.dificuldade = dificuldade;<br>   }<br><br><br>   // Método de mineração que resolve o &quot;problema&quot; baseado na dificuldade<br>   public void mineBlock(Block block) {<br>       String target = new String(new char[dificuldade]).replace(&#39;\0&#39;, &#39;0&#39;); // alvo (string de zeros)<br><br><br>       while (!block.getHash().substring(0, dificuldade).equals(target)) {<br>           block.setTimestamp(System.currentTimeMillis()); // atualiza o timestamp<br>           block.setHash(block.calculateHash()); // recalcula o hash até o alvo ser atingido<br>       }<br>       System.out.println(&quot;Bloco minerado: &quot; + block.getHash());<br>   }<br><br><br>//gets and sets<br>}</pre><p>Este código, até mais simples que o anterior, podemos ver apenas uma propriedade, a dificuldade, que tem como função dizer ao minerador qual o nível de dificuldade que ele vai encarar no processo de mineração do bloco.</p><p>Já em relação aos métodos, com exceção dos gets e sets, temos o construtor da classe indicando que ela deve possuir a dificuldade setada logo no início de sua criação e possuímos apenas um método, o mineBlock.</p><p>Este método faz o que o nome diz, minera o bloco, em essência, ele cria uma variável chamada ‘target’ que é o parâmetro de mineração correto e cria uma estrutura de repetição ‘while’ que vai ficar se repetindo e chamando a função ‘calculateHash’ lá do bloco até que a hash satisfaça o ‘target’.</p><p>Um pouco confuso é verdade, mas imagina que sempre que você chama o ‘calculateHash, você está trocando o timestamp, ou seja, em essência, gera uma nova hash visto que não é mais o mesmo bloco que o anterior. E essa nova hash deve começar com um número definido (pela dificuldade) de zeros.</p><p>Imagine que, ao gerar o primeiro hash, saiu algo assim: <strong>‘32f2f2cvdfvdfv232vvfb553’ </strong>e a dificuldade estipulada é 3, ou seja, se a hash não começar com ‘000’ ela não é válida. Depois de um tempo, trocando o timestamp, eventualmente aparece uma hash ‘<strong>000561vfdvf5fvfr21vf5</strong>’ que será aceita.</p><p>Em blockchains mais complexas, utiliza-se outra variável além do timestamp para variar o conteúdo do bloco, a variável ‘nonce’ (abreviação de “number only used once” ou “número usado apenas uma vez”), porém em nosso exemplo o timestamp está de bom tamanho.</p><p>Indo para a última classe de serviço, temos a blockchain.java:</p><pre>package com.blockchain.services;<br><br><br>import java.util.ArrayList;<br>import java.util.List;<br><br><br>public class Blockchain {<br>   private List&lt;Block&gt; chain;<br><br><br>   public Blockchain() {<br>       chain = new ArrayList&lt;&gt;();<br>       chain.add(createGenesisBlock()); // Gera o bloco inicial (genesis block)<br>   }<br><br><br>   public List&lt;Block&gt; getChain() {<br>       return chain;<br>   }<br><br><br>   public void setChain(List&lt;Block&gt; chain) {<br>       this.chain = chain;<br>   }<br><br><br>   // Cria o bloco inicial<br>   private Block createGenesisBlock() {<br>       return new Block(0, System.currentTimeMillis(), &quot;Genesis Block&quot;, &quot;0&quot;);<br>   }<br><br><br>   // Retorna o último bloco da cadeia<br>   public Block getLatestBlock() {<br>       return chain.get(chain.size() - 1);<br>   }<br><br><br>   // Adiciona um novo bloco à cadeia, após calcular o hash e validá-lo<br>   public void addBlock(Block newBlock) {<br><br><br>       newBlock.setPreviousHash(getLatestBlock().getHash());<br>       newBlock.setHash(newBlock.calculateHash());<br>       chain.add(newBlock);<br>   }<br><br><br>   // Valida a integridade da blockchain<br>   public boolean isChainValid() {<br>       for (int i = 1; i &lt; chain.size(); i++) {<br>           Block currentBlock = chain.get(i);<br>           Block previousBlock = chain.get(i - 1);<br><br><br>           // Verifica se o hash foi alterado<br>           if (!currentBlock.getHash().equals(currentBlock.calculateHash())) {<br>               return false;<br>           }<br>           // Verifica se o bloco atual aponta corretamente para o anterior<br>           if (!currentBlock.getPreviousHash().equals(previousBlock.getHash())) {<br>               return false;<br>           }<br>       }<br>       return true;<br>   }<br>}</pre><p>Temos apenas uma única propriedade nesta classe, a chain que é, em resumo, uma lista de blocos, ou seja, uma lista de objetos Block criados anteriormente.</p><p>Já seus métodos, com exceção dos gets e sets, temos:</p><p><strong>o construtor</strong>: possui apenas duas funções, inicializar a lista ‘chain’ e executar o método abaixo, o createGenesisBlock, para criar o primeiro bloco.</p><p><strong>createGenesisBlock</strong>: Este método cria o bloco zero, aquele que é o primeiro da chain, este bloco não precisa respeitar a dificuldade da rede, e nem possui uma hash anterior, logo ele tem uma criação diferenciada. Na prática ele cria um bloco novo e adiciona a lista.</p><p>getLastBlock: Retorna um int, contendo o tamanho atual da lista, logo ele me retorna o total de blocos existentes hoje na blockchain.</p><p><strong>addBlock</strong>: Basicamente adiciona o bloco novo e calculado diretamente na chain. Este método cabe grandes melhorias de segurança, porém como estamos em uma POC que executa tudo sozinha, não havendo outros mineradores, não há necessidade disso.</p><p><strong>isChainValid</strong>:Este método valida toda a lista, verificando todos os blocos adicionados e se os mesmos estão com as hash e previousHash corretas como deve ser.</p><p>Com isso, resta apenas a classe Node.java, nossa API:</p><pre>package com.blockchain.controller;<br><br><br>import com.blockchain.services.Block;<br>import com.blockchain.services.Blockchain;<br>import com.blockchain.services.Minerador;<br>import org.springframework.web.bind.annotation.*;<br><br><br>import java.util.List;<br><br><br>@RestController<br>@RequestMapping(&quot;/node&quot;)<br>public class Node {<br>   private Blockchain blockchain;<br><br><br>   public Node() {<br>       blockchain = new Blockchain();<br>   }<br><br><br>   @PostMapping(&quot;/addBlock&quot;)<br>   public String addBlock(@RequestBody String data) {<br>       Block newBlock = new Block(blockchain.getLatestBlock().getIndex() + 1, System.currentTimeMillis(), data, blockchain.getLatestBlock().getHash());<br>       Minerador minerador = new Minerador(4); // Dificuldade 4 (ajustável)<br>       minerador.mineBlock(newBlock);<br>       blockchain.addBlock(newBlock);<br>       return &quot;Novo bloco adicionado!&quot;;<br>   }<br><br><br>   @GetMapping(&quot;/isValid&quot;)<br>   public String isValid() {<br>       return blockchain.isChainValid() ? &quot;Blockchain é válida!&quot; : &quot;Blockchain está corrompida!&quot;;<br>   }<br><br><br>   @GetMapping(&quot;/blockchain&quot;)<br>   public List&lt;Block&gt; getBlockchain() {<br>       return blockchain.getChain(); // Retorna a lista completa de blocos<br>   }<br>}</pre><p>Esta API cria três endpoints, são eles:</p><p><strong>addBlock (POST)</strong>: Basicamente recebe o data, ou seja a informação a ser minerada, cria um novo bloco e envia para o minerador junto a dificuldade, como podemos ver no nosso exemplo foi setado o número 4, dependendo do computador isso é bastante. (Cabe muitas melhorias de programação aqui)</p><p><strong>isValid(GET)</strong>: Executa o método de validação da chain, para garantir integridade a qualquer momento.</p><p><strong>blockchain(GET):</strong> Retorna toda a lista de blocos, ou seja retorna a blockchain inteira na tela.</p><p>Vejamos em execução:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xHuMeI_4RwJ1IOfU" /></figure><p>Adicionou este bloco, demorou por volta de uns 5 minutos para processar (devia ter colocado 3 na dificuldade).</p><p>Vejamos como ficou a chain com este bloco:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TvXpDsyXdf4gEtpH" /></figure><p>O retorno:</p><pre>[<br>    {<br>        &quot;index&quot;: 0,<br>        &quot;timestamp&quot;: 1731272646084,<br>        &quot;data&quot;: &quot;Genesis Block&quot;,<br>        &quot;previousHash&quot;: &quot;0&quot;,<br>        &quot;hash&quot;: &quot;95c4a610b742be55d3fcfe94b4159f5ce6fb51e7383fca8fc45379f23c237d81&quot;<br>    },<br>    {<br>        &quot;index&quot;: 1,<br>        &quot;timestamp&quot;: 1731272850422,<br>        &quot;data&quot;: &quot;{\r\n  \&quot;data\&quot;: \&quot;Transação 1 - Envio de 50 moedas de Alice para Bob\&quot;\r\n}&quot;,<br>        &quot;previousHash&quot;: &quot;95c4a610b742be55d3fcfe94b4159f5ce6fb51e7383fca8fc45379f23c237d81&quot;,<br>        &quot;hash&quot;: &quot;00003758124fce6475b3abed8f5f8a5903a9419a5d969913d5ce5e3c68d82370&quot;<br>    }<br>]</pre><p>Funcionou perfeitamente, vale ressaltar o hash do nosso bloco, vejam que ele começa com ‘0000’ como deve ser.</p><p>Nos vemos nos próximos posts onde deixaremos essa carinha ainda mais interessante.</p><p>Git do projeto: <a href="https://github.com/brunobaruffi/blockchain">https://github.com/brunobaruffi/blockchain</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d0a02c08d2c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Iniciando estudos sobre MongoDB. Emulando no Docker e preparad]]></title>
            <link>https://medium.com/@brunobaruffi/iniciando-estudos-sobre-mongodb-emulando-no-docker-e-preparad-529ef04262b7?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/529ef04262b7</guid>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[banco-de-dados]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[nosql]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sun, 10 Nov 2024 17:45:28 GMT</pubDate>
            <atom:updated>2024-11-10T17:45:28.447Z</atom:updated>
            <content:encoded><![CDATA[<h3>Iniciando estudos sobre MongoDB. Emulando no Docker e preparando ambiente.</h3><p>Bancos de dados Não relacional (MongoDB), criando uma infraestrutura e primeiros comandos para estudo.</p><p>Bom, hoje vamos começar a criar uma infraestrutura que nos permita a instalação simples e prática de um banco de dados não relacional virtualizado utilizando docker, assim podemos fazer nossos estudos sobre ele com calma e tranquilidade.</p><p>Vamos começar com a instalação do ambiente Docker. Estaremos utilizando um ambiente linux, no futuro falamos sobre o ambiente Windows.</p><pre>sudo apt install docker.io</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wDoRy8pEmIyPQMfg" /></figure><p>Com a instalação garantida, seguiremos os procedimentos já abordados em outro tópico aqui neste blog sobre o uso do Docker.</p><p>Vamos lá.</p><p>Vamos criar um volume de armazenamento, para garantir um local na máquina hospedeira para nossa simulação, assim podemos reiniciar a virtual sempre e recriar que a mesma não perderá os bancos que criarmos.</p><pre>sudo docker volume create arqsmongo</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/0*c6WWIygkFPnpwV3T" /></figure><p>Agora vamos criar uma rede que, no futuro, caso queiramos integrar aplicações a este banco via docker possamos com facilidade.</p><pre>sudo docker network create nossarede</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/0*S41q0G5ds_dlVbb4" /></figure><p>Vamos ao comando de criação dessa infraestrutura:</p><pre>sudo docker run -d -v &quot;/arqsmongo:/data/db&quot; - rm - name nossomongo -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=1234 -p &quot;27017:27017&quot; - network nossarede mongo:4.0</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*17GHxgH2SSqy9SZs" /></figure><p>Não vamos explicar o passo a passo deste comando, visto que o mesmo já é explicado na postagem anterior sobre docker, porém vale ressaltar que, com este comando, colocamos na nossa máquina hospedeira um espelhamento da porta 27017 para que a máquina que hospeda o docker, possa refletir essa porta e possamos nos comunicar com ela.</p><p>OBS: Foi utilizado o mongo:4.0 devido a um problema de infraestrutura nesta máquina que estou fazendo os experimentos, caso esteja com uma máquina mais moderna, apenas não preencha a versão que obterá a versão mais moderna do container.</p><p>Agora podemos conferir se a máquina está online:</p><pre>sudo docker ps -a</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Nv085UjivLRq0oKO" /></figure><p>tudo ok.</p><p>Agora vamos instalar um cliente para conectar no nosso MongoDB.</p><p>Instalando o cliente.</p><p>Optei pelo Studio3t, devido a sua simplicidade e facilidade em configurar e instalar.</p><p>Para isso vamos ao site oficial e baixamos a versão atual para download.</p><p><a href="http://www.studio3t.com/">www.studio3t.com</a></p><p>Ao acessar você deve baixar a ferramenta, como indica a imagem:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4CYqo9YRPgCNFq_F" /></figure><p>Ao terminar o download e verificar a pasta, vemos o seguinte arquivo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Hf--5zar1IEV9VSW" /></figure><p>Este é o instalador, para dar fazer a instalação você deve seguir 2 passos.</p><p>O primeiro e clicar duas vezes, isso irá criar um novo arquivo ao lado “.sh”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dOer9amlPLNS6aLC" /></figure><p>Estes arquivos “.sh” são shellScripts, ou seja o equivalente do linux ao “.bat” arquivos de comando de terminal que devem ser executados na ordem que estão la. Claro que não faremos isso na mão. Clique com o botão direito na pasta e acesse um novo terminal nesta pasta e digite ./studio-3t-linux-x64.sh :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/0*eV_I50obWzKoX4ym" /></figure><p>Este comando vai te direcionar para o instalador do programa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/0*P8raU_HSjCIsS0yL" /></figure><p>Apenas siga os passos da tela até o final e você chegará aqui:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/0*IhrXRyOtnP-MK9RR" /></figure><p>Siga os procedimentos que a tela indicar, o que inclui o cadastro do site do fabricante do software. Sim é chato mas não tem jeito. Ao terminar você deve chegar aqui:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dGziGl7CKiScyJvD" /></figure><p>Vamos agora a configuração da conexão.</p><p>Começamos clicando em “Connect” no canto superior esquerdo e depois em “new Connection”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nCWl44asctidSAmT" /></figure><p>Na sequencia, clique em configuração manual como indica a imagem:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/0*N8FkWbuCEko1g38n" /></figure><p>Na area de conexão, não precisaremos modificar muita coisa, apenas colocar o login e senha do nosso servidor. Começamos dando um nome para nossa conexão no campo superior, e depois clicamos em “Authentication”, como indica a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VWl9V92Rg1w1I6Fc" /></figure><p>Repare na imagem, já preenchemos os campos de login e senha, e também o de autenticação do banco com o nosso usuário. Atenção também ao modo de autenticação, na versão 4.0 que estamos usando aqui o Legacy atende, porém em versões mais modernas deve ser verificado qual delas é mais adequada.</p><p>Na sequência, clicamos no botão “Test Connection” na parte inferior esquerda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/0*fJOR2SG1KkU9vXrx" /></figure><p>Logo após essa confirmação de funcionamento, podemos salvar a conexão no botão à esquerda.</p><p>Com a conexão salva, podemos simplesmente conectar nela e obtermos um terminal valido.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dqwnj3o-Wn6FjSNx" /></figure><p>Vamos finalizar criando uma collection e testando uma inserções.</p><p>Abrimos o banco “Admin” e criamos uma nova collection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/0*B7W9s50r91LzM0hM" /></figure><p>Criaremos uma collection chamada “teste”.</p><p>Depois de criar uma colleciton, clicamos no botão “Intellishell”, na parte superior do programa para obter a seguinte janela:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kaVYsHHZA3N99Ox6" /></figure><p>Com isso, temos acesso ao terminal para uso direto da collection através dos comandos estudados.</p><p>Num próximo artigo falaremos sobre as operações que podemos executar nesta aba.</p><p>Obrigado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=529ef04262b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desvendando o Padrão de Projeto — Bridge]]></title>
            <link>https://medium.com/@brunobaruffi/desvendando-o-padr%C3%A3o-de-projeto-bridge-50492ba3fa0b?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/50492ba3fa0b</guid>
            <category><![CDATA[orientação-a-objeto]]></category>
            <category><![CDATA[bridge]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[programação]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Sun, 02 Jun 2024 19:12:59 GMT</pubDate>
            <atom:updated>2024-06-02T19:12:59.530Z</atom:updated>
            <content:encoded><![CDATA[<h3>Desvendando o Padrão de Projeto — Bridge</h3><p>É um design estrutural focado em organização de código orientado a objetos.</p><p>Indo direto ao ponto, seu principal uso é quando temos dois ou mais conjuntos diferentes de classes ligadas e queremos que as mesmas possuam ligações controladas entre si. Confuso eu sei… Vamos a um exemplo:</p><p>Vamos imaginar dois conjuntos de classes, um para gerar documentos e outro para enviar documentos. Cada uma das sub-classes de gerar documento pode enviar o documento por cada uma das sub-classes de enviar documento. Veja a imagem abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/0*M_x-lEYmhhYJ9E_r" /><figcaption>Ilustração de relacionamento Bridge (autor)</figcaption></figure><p>Neste exemplo, percebe-se as classes descritas, e a premissa é, eu posso criar um objeto RelatorioXLS com a implementação de EnvioEmail ou EnvioFTP, e o mesmo vale para relatorioPDF.</p><p><strong>Exemplo</strong>: RelatorioXLS-&gt;EnvioEmail ou RelatorioPDF-&gt;EnvioFTP…</p><p>Essa implementação permite que eu amplie, se necessário, as formas de envio ou os tipos de relatório facilmente, sem me preocupar com o processo de envio, ou aumentar os processos de envio sem me preocupar com os relatórios em si.</p><p>Vamos para a implementação.</p><p>Vou utilizar o modelo que estamos utilizando ultimamente de API Spring, porém o método é e universal.</p><p>Começamos a definir, irei fazer a classe Relatorio como uma classe abstrata e a classe ImplementacaoEnvio como uma interface, é possível fazer invertido ou de outra maneira, mas acredito que assim fica mais didático.</p><p>Relatorio.java</p><pre>abstract class Relatorio {<br>   protected ImplementadorEnvio implementador;<br><br><br>   protected Relatorio(ImplementadorEnvio implementador) {<br>       this.implementador = implementador;<br>   }<br><br>   public abstract void gerar(String conteudo);j</pre><p>ImplementacaoEnvio.java</p><pre>public interface ImplementadorEnvio {<br>   void enviar(String arquivo);<br>}</pre><p>Foi escolhido fazer desta forma pois, a classe abstrata pode possuir algum código, e no caso, a mesma possui como seu parâmetro comum, a própria interface do ImplementadorEnvio. Até é possível fazer isso com uma interface mas não considero uma boa prática.</p><p>O motivo para a classe abstrata Relatorio conter a interface ImplementadorEnvio é justamente possibilitar que, indiferente do tipo de envio escolhido, a interface funcione normalmente.</p><p>Vamos às extensões da classe abstrata Relatorio.</p><p>RelatorioXLS.java</p><pre>public class RelatorioXLS extends Relatorio{<br>   public RelatorioXLS(ImplementadorEnvio implementador) {<br>       super(implementador);<br>   }<br><br><br>   @Override<br>   public void gerar(String conteudo) {<br>       String arquivo = &quot;relatorio.xls&quot;;<br>       System.out.println(&quot;Gerando relatório xls com o conteúdo: &quot; + conteudo);<br>       implementador.enviar(arquivo);<br>   }<br>}</pre><p>RelatoioPDF.java</p><pre>public class RelatorioPDF extends Relatorio{<br>   public RelatorioPDF(ImplementadorEnvio implementador) {<br>       super(implementador);<br>   }<br><br><br>   @Override<br>   public void gerar(String conteudo) {<br>       String arquivo = &quot;relatorio.pdf&quot;;<br>       System.out.println(&quot;Gerando relatório PDF com o conteúdo: &quot; + conteudo);<br>       implementador.enviar(arquivo);<br>   }<br>}</pre><p>A lógica do processo, seria chamada na no método ‘gerar’, porém a chave para a Bridge funcionar está no construtor.</p><p>Vemos que, o construtor das duas classes, apenas recebe como parâmetro uma instância da classe interface ImplementadorEnvio, que pode ser de qualquer uma das implementações dela, e utiliza um ‘super’ nela. Esse método super serve para enviar essa variável para o construtor da classe extendida dela, que no caso é a abstrata Relatorio.</p><p>Este processo obriga a toda classe que estende Relatorio, a enviar o método de envio do relatório no ato da criação da instância, nunca deixando esta informação de lado.</p><p>Agora vamos seguir para as implementações da classe ImplementadorEnvio:</p><p>EnvioFTP.java</p><pre>public class EnvioFTP implements ImplementadorEnvio {<br><br><br>   @Override<br>   public void enviar(String arquivo) {<br>       System.out.println(&quot;Enviando &quot; + arquivo + &quot; por FTP.&quot;);<br>   }<br>}</pre><p>EnvioEmail.java</p><pre>public class EnvioEmail implements ImplementadorEnvio {<br><br><br>   @Override<br>   public void enviar(String arquivo) {<br>       System.out.println(&quot;Enviando &quot; + arquivo + &quot; por email.&quot;);<br>   }<br>}</pre><p>Muito mais simples que as anteriores, elas apenas implementam o ImplementadorEnvio e criam o método de negócio “enviar” que teria a lógica de negócio para o envio do arquivo.</p><p>Se olharmos atentamente as extensões da classe abstrata Relatorio, podemos ver que o método enviar, da interface ImplementadorEnvio é chamado, e dependendo da implementação que for usada, o método enviar correto será executado.</p><p>Agora podemos ir diretamente a chamada do metodo, ou seja o Controller que gera o endpoint de que será testado.</p><p>BridgeController.java</p><pre>@RestController<br>@RequestMapping(&quot;api/bridge&quot;)<br>public class BridgeController {<br><br><br>   @GetMapping(value = &quot;relatorio/{relatorio}/{envio}&quot;)<br>   @ResponseStatus(HttpStatus.ACCEPTED)<br>   public String strategy(@PathVariable String relatorio, @PathVariable String envio){<br><br><br>       switch (relatorio){<br>           case &quot;XLS&quot;:<br>               switch ((envio)){<br>                   case &quot;EMAIL&quot;:<br>                       RelatorioXLS relatorioXLSEmail = new RelatorioXLS(new EnvioEmail());<br>                       relatorioXLSEmail.gerar(&quot;Conteúdo do relatório XLS - Enviado via Email&quot;);<br>                       return &quot;Conteúdo do relatório XLS - Enviado via Email&quot;;<br><br><br>                   case &quot;FTP&quot;:<br>                       RelatorioXLS relatorioXLSFTP = new RelatorioXLS(new EnvioFTP());<br>                       relatorioXLSFTP.gerar(&quot;Conteúdo do relatório XLS - Enviado via FTP&quot;);<br>                       return &quot;Conteúdo do relatório XLS - Enviado via FTP&quot;;<br><br><br>               }<br><br><br>           case &quot;PDF&quot;:<br>               switch ((envio)){<br>                   case &quot;EMAIL&quot;:<br>                       RelatorioPDF relatorioPDFEmail = new RelatorioPDF(new EnvioEmail());<br>                       relatorioPDFEmail.gerar(&quot;Conteúdo do relatório PDF - Enviado via Email&quot;);<br>                       return &quot;Conteúdo do relatório PDF - Enviado via Email&quot;;<br><br><br>                   case &quot;FTP&quot;:<br>                       RelatorioPDF relatorioPDFFTP = new RelatorioPDF(new EnvioFTP());<br>                       relatorioPDFFTP.gerar(&quot;Conteúdo do relatório PDF - Enviado via FTP&quot;);<br>                       return &quot;Conteúdo do relatório PDF - Enviado via FTP&quot;;<br><br><br>               }<br>       }<br>       return &quot;FALHA&quot;;<br>   }<br>}</pre><p>Esse é o jeito mais didático de entender o processo… Vemos que, via URL vira dois parametros, ‘relatorio’ e ‘envio’. Estes dois parametros são testados via Switch Case e, dependendo do valor, é instanciado o metodo correto.</p><p>Vamos pegar uma das linhas de chamada para analisar com mais calma:</p><pre>RelatorioPDF relatorioPDFEmail = new RelatorioPDF(new EnvioEmail());</pre><p>Olhando esta chamada, percebemos bem o que esta acontecendo. O objetivo dela é, chamar o relatório PDF e enviar via email. Podemos ver que, como previsto, é passado via parâmetro o tipo de envio em forma de classe, e na criação da linha, criamos a classe RelatorioPDF, que tem como extensão a classe abstrata Relatorio.</p><p>Teoricamente está concluído, mas vamos fazer uma melhoria. A chamada ficou muito confusa com case dentro de case. Vamos aplicar uma estratégia (Strategy) simplificada, usando Enums. (Técnica mais bem explicada no artigo sobre Strategy).</p><p>Para isso vamos criar um enum para os tipos de envio:</p><p>EnvioEnum.java</p><pre>public enum EnvioEnum {<br>   EMAIL {<br>       @Override<br>       public ImplementadorEnvio obterImplementador(){<br>           return new EnvioEmail();<br>       }<br>   },<br>   FTP{<br>       @Override<br>       public ImplementadorEnvio obterImplementador(){<br>           return new EnvioFTP();<br>       }<br>   };<br><br><br>   public abstract ImplementadorEnvio obterImplementador();<br>}</pre><p>Este enum possui os dois tipos de envio, e para cada um, ele retorna a implementação de ImplementadorEnvio que agente quer. Para mais detalhes do funcionamento deste enum, va no artigo sobre o Strategy.</p><p>Agora com o Enum em mãos, vamos mudar a classe de chamada:</p><p>BridgeController.java</p><pre>@RestController<br>@RequestMapping(&quot;api/bridge&quot;)<br>public class BridgeController {<br><br><br>   @GetMapping(value = &quot;relatorio/{relatorio}/{envio}&quot;)<br>   @ResponseStatus(HttpStatus.ACCEPTED)<br>   public String strategy(@PathVariable String relatorio, @PathVariable String envio){<br><br><br>       switch (relatorio){<br>           case &quot;XLS&quot;:<br>               RelatorioXLS relatorioXLSFTP = new RelatorioXLS(EnvioEnum.valueOf(envio).obterImplementador());<br>               relatorioXLSFTP.gerar(&quot;Conteúdo do relatório XLS - Enviado via &quot; + envio);<br>               return &quot;Conteúdo do relatório XLS - Enviado via &quot; + envio;<br>           case &quot;PDF&quot;:<br>               RelatorioPDF relatorioPDFEmail = new RelatorioPDF(EnvioEnum.valueOf(envio).obterImplementador());<br>               relatorioPDFEmail.gerar(&quot;Conteúdo do relatório PDF - Enviado via &quot; + envio);<br>               return &quot;Conteúdo do relatório PDF - Enviado via &quot; + envio;<br>       }<br>       return &quot;FALHA&quot;;<br>   }<br>}</pre><p>Decidi aplicar a técnica apenas no envio, mas podemos aplicar no relatório também se for conveniente.</p><p>O funcionamento é o mesmo, mas observemos mais atentamente um dos cases:</p><pre>RelatorioPDF relatorioPDFEmail = new RelatorioPDF(EnvioEnum.valueOf(envio).obterImplementador());<br>               relatorioPDFEmail.gerar(&quot;Conteúdo do relatório PDF - Enviado via &quot; + envio);<br>               return &quot;Conteúdo do relatório PDF - Enviado via &quot; + envio;</pre><p>Vemos que, no lugar da chamada dura da implementação da chamada do envio, chamamos este objeto via Enum, passando como índice a string ‘envio’ recebida via parâmetro.</p><p>Vejamos a execução disso no navegador:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/0*BN-o_VV3E2OtO4wT" /><figcaption>Teste 1 (autor)</figcaption></figure><p>ou</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/0*t0WCQ_w-4JQ2iXPu" /><figcaption>Teste 2(autor)</figcaption></figure><p>Espero que tenha ficado claro, gostaria de finalizar dizendo que, esta técnica não é simples e é normal ter dificuldade com ela.</p><p><strong>Segue abaixo o link do projeto do GIT:</strong></p><p><a href="https://github.com/brunobaruffi/DesignPatternsJavaEstudo/tree/main/Bridge/untitled3">https://github.com/brunobaruffi/DesignPatternsJavaEstudo/tree/main/Bridge/untitled3</a></p><p><strong>Bibliografia recomendada:</strong></p><p><a href="https://refactoring.guru/design-patterns/bridge">https://refactoring.guru/design-patterns/bridge</a></p><p><strong>Lista de Design Patterns:</strong></p><p><a href="https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee">https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50492ba3fa0b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desvendando o Padrão de Projeto — Strategy]]></title>
            <link>https://medium.com/@brunobaruffi/desvendando-o-padr%C3%A3o-de-projeto-strategy-7cfd128470d5?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/7cfd128470d5</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[português]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Mon, 20 Nov 2023 01:43:29 GMT</pubDate>
            <atom:updated>2023-11-20T01:44:40.113Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Desvendando o Padrão de Projeto — Strategy</strong></h3><p>Os padrões de design, e em particular o padrão Strategy, desempenham um papel crucial no desenvolvimento de software, proporcionando uma abordagem flexível e modular para resolver problemas específicos. O padrão Strategy é fundamental ao permitir que uma classe altere seu comportamento, seja ele algoritmo, estratégia ou método, sem alterar a estrutura da classe. Essa flexibilidade é essencial em situações em que diferentes algoritmos podem ser aplicados a um problema específico ou quando a lógica de execução precisa ser trocada dinamicamente. Ao utilizar o padrão Strategy, os desenvolvedores conseguem promover a reutilização de código, facilitar a manutenção e melhorar a legibilidade, tornando o software mais robusto e adaptável às mudanças.</p><p>Além disso, a aplicação do padrão Strategy contribui significativamente para a coesão e o desacoplamento do código. Isso significa que as classes podem ser modificadas independentemente umas das outras, o que resulta em um sistema mais fácil de entender e manter. A separação das responsabilidades em classes distintas simplifica a implementação de novos algoritmos, promovendo a escalabilidade e a evolução do software ao longo do tempo. Essa abordagem modular também facilita a introdução de novas estratégias, o que é particularmente valioso em ambientes de desenvolvimento ágil, onde a capacidade de adaptação rápida é essencial.</p><p>Outro ponto crucial é a melhoria na testabilidade do código proporcionada pelo padrão Strategy. Ao isolar algoritmos e estratégias em classes separadas, torna-se mais fácil criar testes unitários específicos para cada componente. Isso não apenas simplifica a identificação e resolução de bugs, mas também aumenta a confiança no código, uma vez que cada estratégia pode ser testada independentemente. A combinação desses benefícios faz com que o padrão Strategy seja uma ferramenta valiosa no kit de desenvolvedores, promovendo a criação de software mais flexível, sustentável e resiliente às mudanças.</p><p>Na prática, a tudo funciona criando várias implementações para a mesma interface, assim desacoplando o código do fluxo principal e facilitando a criação de novos fluxos sem necessariamente haver grandes alterações de fluxo.</p><p><strong>Indo para nosso exemplo.</strong></p><p>Em nosso exemplo teremos um payload de entrada definindo um valor de compra e sua forma de pagamento e utilizaremos o Strategy para processar de forma diferente o pagamento.</p><p>Para este caso, foi utilizado estratégia de programação diretamente associado ao ENUM, visto que isso viabiliza a não utilização de Ifs.</p><p>Vamos começar criando a interface EstrategiaPagamento, sendo ela o coração do Estategy.</p><p>service.EstrategiaPagamento.java</p><pre>public interface EstrategiaPagamento {<br>   String pagar(Compra compra);<br>}</pre><p>Neste exemplo temos a interface geral, ela possui apenas um método em nosso exemplo, porém poderia possuir uma série de métodos.</p><p>Em seguida, precisamos criar as implementações dessa interface, criaremos uma implementação para cada forma de pagamento.</p><p>service.impl.PagamentoDebito.java</p><pre>public class PagamentoDebito implements EstrategiaPagamento {<br>   @Override<br>   public String pagar(Compra compra) {<br>       //...processos<br>       return &quot;Pagou no Debito &quot; + compra.getValor();<br>   }<br>}</pre><p>service.impl.PagamentoCredito.java</p><pre>public class PagamentoCredito implements EstrategiaPagamento {<br>   @Override<br>   public String pagar(Compra compra) {<br>       //...processos<br>       return &quot;Pagou no crédito &quot; + compra.getValor();<br>   }<br>}</pre><p>Como podemos ver, as implementações possuem o mesmo método, o ‘pagar’. Neste método é criado os processos para efetivar os pagamentos debito ou credito, que em nosso exemplo é apenas uma String.</p><p>Ainda nesta linha de raciocínio, temos o objeto ‘Compra’. Este objeto é o que vamos chamar de Context.</p><p>Os Context ou Contextos são classes possuem os dados necessários para a transmissão e também a chamada para a interface de pagamento. Vejamos:</p><p>context.Compra.java</p><pre>public class Compra {<br>   BigDecimal valor;<br><br><br>   public Compra(BigDecimal valor){<br>       this.valor = valor;<br>   }<br><br><br>   public BigDecimal getValor() {<br>       return valor;<br>   }<br><br><br>   public String processarCompra(EstrategiaPagamento estrategiaPagamento){<br>       return estrategiaPagamento.pagar(this);<br>   }</pre><p>Podemos ver a criação da variável ‘valor’ e seu get e por fim um método que recebe a implementação ‘estrategiaPagamento’ como parâmetro e externa o resultado da chamada do método ‘pagar’.</p><p>Nesta linha de raciocínio, tudo que precisamos fazer é enviar pela classe ‘Compra’, o pedido para processar a compra enviando qual implementação você deseja.</p><p>Vejamos agora o enum, onde essa chamada é dividida:</p><p>enums.FormaPagamentoEnum.java</p><pre>public enum FormaPagamentoEnum {<br>   DEBITO {<br>       @Override<br>       public EstrategiaPagamento criarEstrategia() {<br>           return new PagamentoDebito();<br>       }<br>   },<br>   CREDITO {<br>       @Override<br>       public EstrategiaPagamento criarEstrategia() {<br>           return new PagamentoCredito();<br>       }<br>   };<br><br><br>   public abstract EstrategiaPagamento criarEstrategia();<br>}</pre><p>Sendo assim, vemos que para cada opção dentro do enum temos um método possível associado a um método abstrato chamado ‘criarEstrategia’. Na prática, este método abstrato é substituído pelo método dentro da opção escolhida do enum quando o mesmo é chamado.</p><p>Se observarmos bem os métodos ‘criarEstrategia’ vemos que eles retornam as implementações de ‘EstrategiaPagamento‘ de acordo com a opção do enum.</p><p>Fazendo desta forma, toda vez que criarmos uma nova forma de pagamento, criamos a implementação aqui e retornamos a nova implementação da ‘EstrategiaPagamento’.</p><p>Antes de seguirmos adiante, vamos criar um DTO, que na pratica é apenas uma classe que para conversão do JSON que será enviado na entrada para dentro da API.</p><p>dto.PagamentoDTO.java</p><pre>public class PagamentoDTO {<br>   BigDecimal valor;<br>   FormaPagamentoEnum formaPagamentoEnum;<br><br><br>  // gets e sets.<br>}</pre><p>Agora vamos a chamada da API para executar esta estrategia.</p><p>controller.strategyController.java</p><pre>RestController<br>@RequestMapping(&quot;api/strategy&quot;)<br>public class strategyController {<br>   @PostMapping(value = &quot;pagar&quot;)<br>   @ResponseStatus(HttpStatus.ACCEPTED)<br>   public String strategy(@RequestBody PagamentoDTO pedidoPagamento){<br>       Compra compra = new Compra(pedidoPagamento.getValor());<br><br><br>       EstrategiaPagamento estrategiaPagamento = pedidoPagamento.getFormaPagamento().criarEstrategia();<br>       return compra.processarCompra(estrategiaPagamento);<br>   }<br>}</pre><p>Vendo este endpoint, podemos ver o mesmo recebe o “PagamentoDTO”.</p><p>No fluxo do código é criada uma instância de “Compra” já trazendo em seu construtor o valor que será pago.</p><p>Agora é necessário a instância da ‘estrategiaPagamento’, neste ponto a forma de pagamento escolhida é levada em consideração. Podemos visualizar que, a criação da variável ‘estrategiaPagamento’ é o retorno daquele método ‘criarEstrategia’ feita dentro do próprio Enum.</p><p>Por fim, a instância de Compra que possuímos executa o ‘processarCompra’ levando a estratégia criada pelo Enum.</p><p>Vejamos como ficou no PostMan:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/1*6BuDHsamvHn3_TwA9WNRrw.png" /></figure><p>Com isso terminamos o conceito básico de ‘Strategy’, existem muitas outras formas de criar esta implementação e a mesma mostra seu valor conforme cresce o código.</p><p>Espero ter ajudado.</p><p><strong>Segue abaixo o link do projeto do GIT:</strong></p><p><a href="https://github.com/brunobaruffi/DesignPatternsJavaEstudo/tree/main/Strategy">https://github.com/brunobaruffi/DesignPatternsJavaEstudo/tree/main/Strategy</a></p><p><strong>Texto original:</strong></p><p><a href="https://docs.google.com/document/d/1sTIWOxmfSr54pOc5A3HyGW5iBiYPHTPpZYqNyrLr7QY/edit?usp=sharing">https://docs.google.com/document/d/1sTIWOxmfSr54pOc5A3HyGW5iBiYPHTPpZYqNyrLr7QY/edit?usp=sharing</a></p><p><strong>Bibliografia recomendada:</strong></p><p><a href="https://refactoring.guru/pt-br/design-patterns/strategy">https://refactoring.guru/pt-br/design-patterns/strategy</a></p><p><strong>Lista de Design Patterns:</strong></p><p><a href="https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee">https://medium.com/@brunobaruffi/list/design-patterns-7ea702b1ceee</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7cfd128470d5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Desvendando o Mundo dos Design Patterns]]></title>
            <link>https://medium.com/@brunobaruffi/desvendando-o-mundo-dos-design-patterns-d136ae1f2606?source=rss-bd5f43a2ed22------2</link>
            <guid isPermaLink="false">https://medium.com/p/d136ae1f2606</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[design-patterns]]></category>
            <dc:creator><![CDATA[Bruno Baruffi]]></dc:creator>
            <pubDate>Thu, 16 Nov 2023 01:19:16 GMT</pubDate>
            <atom:updated>2023-11-16T01:21:04.618Z</atom:updated>
            <content:encoded><![CDATA[<p>Quando se avança no mundo do desenvolvimento de software, iremos encontrar desafios complexos que, em via de regra, possuem muitas soluções possíveis. Nesta situação, qual solução escolher? Qual é a mais performática e adequada a escalabilidade ou manutenção do software?</p><p>Tendo isso em vista, os Design Patterns (Padrões de Projeto) emergem como uma ferramenta valiosa para arquitetar sistemas eficientes, escaláveis e de fácil manutenção. Esses padrões representam soluções testadas e comprovadas para problemas recorrentes, servindo como um guia para desenvolvedores na busca por boas práticas e estruturas de código coesas.</p><p>Os Design Patterns abrangem uma variedade de algoritmos, cada um direcionado a um tipo específico de desafio. Um exemplo é o conhecido Padrão de Projeto Singleton, que garante a existência de apenas uma instância de uma classe, controlando o acesso global a ela. Ideal para situações em que recursos únicos, como conexões com banco de dados, precisam ser gerenciados de maneira eficiente.</p><p><strong>Histórico</strong></p><p>O conceito de Design Patterns, ou Padrões de Projeto, teve sua origem na década de 1970, com Christopher Alexander, um arquiteto, que lançou a semente desse conceito em seu livro “A Pattern Language” (1977). O mesmo tinha interesse em identificar soluções reutilizáveis para problemas comuns na arquitetura, e suas ideias serviram de inspiração para a aplicação de padrões na engenharia de software.</p><p>Na década de 1990, Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, conhecidos como “Gang of Four” (GoF), consolidaram o conceito de Design Patterns em seu livro “Design Patterns: Elements of Reusable Object-Oriented Software” (1994). Esse livro apresentou os 23 padrões que abordam problemas recorrentes em design de software.</p><p>Estes algoritmos foram categorizados em três grupos: Padrões de Criação, Padrões Estruturais e Padrões Comportamentais.</p><p><strong>Categorias</strong></p><ol><li>Padrões de Criação:</li></ol><p>Esta categoria concentra-se na criação de objetos de maneira eficiente e flexível. O Padrão Singleton, por exemplo, garante que apenas uma instância de uma classe seja criada, útil para gerenciar recursos globais. O Padrão Factory Method delega a criação de objetos para subclasses, permitindo a adaptação dinâmica do processo de criação.</p><p>2. Padrões Estruturais:</p><p>Os Padrões Estruturais se preocupam com a composição de classes e objetos para formar estruturas maiores. O Padrão Adapter, por exemplo, permite que interfaces incompatíveis trabalhem juntas, enquanto o Padrão Decorator adiciona responsabilidades a objetos de forma dinâmica, sem alterar sua estrutura.</p><p>3. Padrões Comportamentais:</p><p>Essa categoria lida com a comunicação e colaboração entre objetos. O Padrão Observer, por exemplo, estabelece uma relação de dependência entre objetos, permitindo que um objeto notifique outros sobre mudanças de estado. O Padrão Strategy define uma família de algoritmos, encapsulando-os e tornando-os intercambiáveis.</p><p>Desde então, estes conceitos têm sido amplamente adotados na engenharia de software. Com a comunidade de desenvolvedores endossando sua importância para promover boas práticas de design, reutilização de código e melhorar a compreensão e manutenção de sistemas complexos.</p><p>Além dos padrões apresentados pelo GoF, a comunidade continuou a buscar e documentar novos padrões de design que auxiliam em uma variedade de problemas como o:</p><p>4. Padrões de Arquitetura:</p><p>Esses padrões abordam questões de alto nível relacionadas à organização e interconexão de sistemas. Um exemplo é o Padrão MVC (Model-View-Controller) separa a lógica de apresentação e interação do usuário, promovendo a modularidade e a manutenção mais fácil.</p><p>5. Padrões de Concorrência:</p><p>Essa categoria se concentra na execução simultânea de partes de um sistema. Por exemplo, o Padrão Mutex ajuda a evitar conflitos de acesso concorrente a recursos compartilhados, enquanto o Padrão Producer-Consumer gerencia a comunicação entre produtores e consumidores de dados concorrentes.</p><p>Resumindo, os Design Patterns são conhecimentos poderosos que capacitam os desenvolvedores a enfrentar desafios de maneira eficaz, orientada e testada. Ao absorver esses padrões, os profissionais não apenas melhoram seus códigos, mas também criam uma compreensão maior dos princípios de orientado a objetos e algoritmos.</p><p>No decorrer desta lista, irei postar conteúdos com análises e exemplos de cada um deles utilizando API’s Java Spring.</p><p>Texto Original:</p><p><a href="https://docs.google.com/document/d/15NCXs5sPbJON8ukiPX6oKlo1NjFfg7JXDlC3D1NKgOM/edit?usp=sharing">https://docs.google.com/document/d/15NCXs5sPbJON8ukiPX6oKlo1NjFfg7JXDlC3D1NKgOM/edit?usp=sharing</a></p><p>Bibliografia de apoio:</p><p><a href="https://refactoring.guru/design-patterns">https://refactoring.guru/design-patterns</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d136ae1f2606" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>