<?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 Eder Leite on Medium]]></title>
        <description><![CDATA[Stories by Eder Leite on Medium]]></description>
        <link>https://medium.com/@edermfl?source=rss-2abe7b633be3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*kohWvsBiUjz-izLY.</url>
            <title>Stories by Eder Leite on Medium</title>
            <link>https://medium.com/@edermfl?source=rss-2abe7b633be3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 10:10:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@edermfl/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[Paralelismo com GPars]]></title>
            <link>https://medium.com/synchro-tec/paralelismo-com-gpars-602a0344de4b?source=rss-2abe7b633be3------2</link>
            <guid isPermaLink="false">https://medium.com/p/602a0344de4b</guid>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[paralelismo]]></category>
            <category><![CDATA[groovy]]></category>
            <category><![CDATA[gpars]]></category>
            <dc:creator><![CDATA[Eder Leite]]></dc:creator>
            <pubDate>Tue, 10 Jan 2017 11:49:52 GMT</pubDate>
            <atom:updated>2017-01-10T11:49:52.073Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*KbOD69NDBsjwEAEgl_-WNQ.jpeg" /></figure><p>Fala galera, tudo certo?</p><p>Tempos atrás, estava atendendo um chamado onde usuário relatava que ao fazer a integração de dados do sistema origem para o nosso sistema, eventualmente, geravam criticas de validação incorretamente, críticas que não condiz ao verdadeiro estado do registro.</p><p>Depois de alguns dias analisando, debugando código, tentando entender o que estava acontecendo, encontrei o problema. Para encurtar o “causo”, o problema ocorria devido ao paralelismo utilizado pelo processo de integração de dados.</p><p>Este processo usava um utilitário que mantinha, por um curto espaço de tempo, estado em seus atributos, fazendo com que uma thread usa-se dados de outra thread, causando assim o problema.</p><blockquote><strong>Nota:</strong> Ao usar paralelismo, tome muito cuidado com objetos estáticos ou singleton que mantem estados em seus atributos, isso pode te dar uma bela dor de cabeça.</blockquote><p>Dado o inusitado fato, tivemos a necessidade de se criar um teste para garantir que isso não mais iria ocorrer. Mas como simular várias threads executando o mesmo código ao mesmo tempo?</p><p>É para responder essas e outras perguntas que o <a href="http://www.gpars.org/guide/guide/introduction.html"><strong>GPars Framework</strong></a> foi criado.</p><p>GPars é uma biblioteca de código aberto para Java e Groovy para resolver problemas de concorrência e paralelismo e lhe dá uma série de abstrações de alto nível para escrever e posteriormente executar código simultâneo e paralelo.</p><p>Algumas das features são:</p><ul><li>Map/Reduce;</li><li>Fork/Join;</li><li>Asynchronous Closures;</li><li>Actors;</li><li>Agents;</li><li>Dataflow Concurrency;</li><li>Other Concepts.</li></ul><p>Já usamos o GPars em outras partes do sistema, assim usei-o também no teste.</p><p>Meu teste ficou assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6c7a2353f88c2de7d6a4ec2afa637d1c/href">https://medium.com/media/6c7a2353f88c2de7d6a4ec2afa637d1c/href</a></iframe><blockquote>Após correção no Utilitário que mantinha estado, consegui com este teste garantir que o problema não correria em uma execução em paralelo.</blockquote><p>Na <strong>linha 5</strong>, através do GPars, criei um poll de execuções. Na <strong>linha 6</strong>, pedi para o GPars executar cada um dos códigos CFOPs da lista ([‘5101’, ‘5201’, ‘6101’, ‘6201’]) em paralelo, aqui foram criados 4 threads, uma para cada código, fazendo o loop dez mil vez, caso o código fosse diferente do esperado pelo menos uma vez o teste falha.</p><p>Nas <strong>linhas 13 e 14</strong>, foi acionado uma catch, para pegar eventuais exceções lançadas em uma das threads.</p><p>Vemos no exemplo a cima que é muito simples usar o GPars para executar “coisas” em paralelo, estão aproveite e use!</p><p>Abraços.</p><p><em>Originally published at </em><a href="https://edermfl.wordpress.com/2016/05/16/groovy-7-paralelizando-as-coisas/"><em>edermfl.wordpress.com</em></a><em> on Maio 16, 2016.</em></p><p><a href="https://edermfl.wordpress.com/2016/05/16/groovy-7-paralelizando-as-coisas/">Groovy #7: Paralelizando as coisas</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=602a0344de4b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/synchro-tec/paralelismo-com-gpars-602a0344de4b">Paralelismo com GPars</a> was originally published in <a href="https://medium.com/synchro-tec">SynchroTEC</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Thread Local]]></title>
            <link>https://medium.com/synchro-tec/thread-local-1f67ba2803fe?source=rss-2abe7b633be3------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f67ba2803fe</guid>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Eder Leite]]></dc:creator>
            <pubDate>Tue, 20 Dec 2016 23:03:00 GMT</pubDate>
            <atom:updated>2016-12-20T23:03:00.587Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FDnCsFeaB9cSbyE-Pj9BIw.jpeg" /></figure><p>Numa aplicação web em Java, em vários momentos é muito útil manter informações em um contexto maior que o request, mas também nem tão grande com a session ou application. Nessas situações o <em>Thread Local</em>, pode ajudar bastante.</p><h3>Mas o que é Thread Local?</h3><p><em>Thread Local</em> é utilizado para definir ciclo de vida dos objetos, trata-se de um tipo de escopo de acesso onde apenas a thread que está sendo executada tem acesso a esses objetos. Por tanto, se a thread foi criada dentro de um sessão de usuário, os objetos adicionados nela, estarão visíveis apenas nessa thread.</p><p>Seu escopo é parecido com o escopo de objetos estáticos. Objetos estáticos em Java são criados apenas uma vez e ficam disponíveis na memória até o fim da execução da JVM. Já na <em>Thread Local</em>, os objetos ficam na memória até o fim a execução da thread corrente.</p><p>Assim, é possível isolar objetos de uso “global” da thread nela mesma. Métodos executados nessa thread terão acesso ao objeto, como se fossem estáticos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/0*j59ICRG-0Lmx5v11." /><figcaption>Os esquema a cima mostra a o acesso dos objetos a informações tanto no thread local de cada thread, quanto ao acesso as informações estáticas da aplicação.</figcaption></figure><p>Ao criar um objeto estático, qualquer uma das threads terão acesso a ela. Já no <em>Thread Local</em>, apenas os objetos criados pela thread terão acesso.</p><h3>Onde usar?</h3><p><em>Thread Local</em> é muito usada em objetos <em>DAO</em>, para compartilhar a transação corrente entre as camadas de aplicação. Mas pode ser usada em qualquer lugar, onde necessite compartilhar recursos ou informações durante a execução da thread.</p><p>No projeto que trabalho aqui na Synchro, tínhamos problemas para compartilhar parâmetros de execução processos batch.</p><p>Um processo, executa um ou mais métodos, que por sua vez (podem) executam outros métodos encadeados. Nosso maior problema era os métodos da ponta (os últimos a ser executados), precisar de um parâmetro informado pelo processo (tela de parametrização), nesses casos, toda a cadeia de chamada desses métodos, necessitava compartilhar essa informação, com isso as assinaturas dos métodos ficaram complexas, com muitos parâmetros na assinatura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*7q3uF0OXfZvSa67x." /><figcaption>Esquema mostra a passagem de parâmetros do processo até o último método da chamada.</figcaption></figure><p>O processo chama o metodoA() do Objeto1, passando os parâmetros cnpj, ano e mês. Por sua vez o metodoA() chama metodoB() do Objeto 2, passando os mesmo parâmetros e metodoC() do Objeto 3, passando apenas cnpj. Por fim, o metodoB() chama o metodoD() e metodoE() do Objeto 4, repassando os parâmetros do processo.</p><p>Caso um dia fosse necessário informar um novo parâmetro no metodoE(), no mínimo teríamos que alterar a assinatura de três métodos apenas para levar o parâmetro necessário ao metodoE(). Trabalhoso!! Além disso, na figura a cima, o metodoB() do Objeto2, poderia estar recebendo os parâmetros apenas para reparar para os métodos do Objeto4.</p><p>Resolvermos o problema usando <em>Thread Local</em>. Criamos um gerenciador de contexto, capaz de guardar os parâmetros do processo. Em cada uma dos objetos/métodos foi possível recuperar os parâmetros sem a necessidade de passa-los na assinatura do método. Exemplo de uma <em>Thread Local</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d3248be1d36a030f838ce53b9c9ed0ad/href">https://medium.com/media/d3248be1d36a030f838ce53b9c9ed0ad/href</a></iframe><p>No processo, bastou criar um objeto do tipo <em>IParametrosProcesso</em> e seta-lo no <em>GerenciadorContexto</em>, dessa forma:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a2b9d5a4e939ec5aac429897e9b002e8/href">https://medium.com/media/a2b9d5a4e939ec5aac429897e9b002e8/href</a></iframe><p>Os métodos das classe que dependem dos parâmetros ficaram assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/16983477258ceab1b90746037daabe0c/href">https://medium.com/media/16983477258ceab1b90746037daabe0c/href</a></iframe><blockquote><strong>Importante:</strong> Ao finalizar a execução do processo, não esqueça de limpar o thread local, no gerenciador de contexto, chame o método <strong>clean</strong>. Isso faz-se necessário pois em um container JEE após finalizada a execução da thread, a mesma retorna ao pool, desta forma o GC não limpa automaticamente os dados, podendo causar vazamento de memória.</blockquote><p>Se gostaram dá uma curtida aí!</p><p>Valeu galera</p><p><em>Originally published at </em><a href="https://edermfl.wordpress.com/2016/02/04/thread-local/"><em>edermfl.wordpress.com</em></a><em> on February 4, 2016.</em></p><p><a href="https://edermfl.wordpress.com/2016/02/04/thread-local/">Thread Local</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f67ba2803fe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/synchro-tec/thread-local-1f67ba2803fe">Thread Local</a> was originally published in <a href="https://medium.com/synchro-tec">SynchroTEC</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Interface Fluente e StepBuilders]]></title>
            <link>https://medium.com/synchro-tec/interface-fluente-e-stepbuilders-c8b89a938dc8?source=rss-2abe7b633be3------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8b89a938dc8</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[backend]]></category>
            <dc:creator><![CDATA[Eder Leite]]></dc:creator>
            <pubDate>Tue, 05 Jan 2016 08:00:58 GMT</pubDate>
            <atom:updated>2016-11-23T18:22:28.777Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*OrDc6HJ1PUazg0vY." /></figure><h3>Interface Fluente</h3><p>Por que criar interfaces fluentes (<a href="http://en.wikipedia.org/wiki/Fluent_interface">Fluent Interfaces</a>)?</p><p>Simples, lembra do <a href="https://edermfl.wordpress.com/2015/12/15/construindo-objetos-atraves-de-builders/"><strong>Builder</strong></a>? Este padrão de projeto nos ajuda a escrever códigos menos complexos e intuitivos, minimizando os erros durante o desenvolvimento.</p><p>A interface fluente é muito parecida com o builder, é muito usada na criação de <strong>API</strong> e utilitários, fazendo com que o desenvolvedor seja guiado, auto explicando seu uso a cada passo.</p><p>Mas por onde começar? Suponha que tem a classe Nf possua alguns atributo e uma lista de ItemNf:</p><p>Para instanciarmos essa classe fazemos assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c1b79e1f3f0d9f615d470867afbd3839/href">https://medium.com/media/c1b79e1f3f0d9f615d470867afbd3839/href</a></iframe><p>Essa classe por ser pequena, não trás grande complexidade, olhando a forma de uso, mesmo verboso criar uma instancia de Nf é simples.<br> Refatoremos agora a classe Nf usado o padrão Interface fluente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f7ac7ab6b5213e3f50e1d40858d8e80/href">https://medium.com/media/8f7ac7ab6b5213e3f50e1d40858d8e80/href</a></iframe><p>Pouca coisa foi mudado certo? Vejamos o uso:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f6ef7d5681e916d0313e4adac763fbc3/href">https://medium.com/media/f6ef7d5681e916d0313e4adac763fbc3/href</a></iframe><p>O que acharam? Mais intuitivo? Essa é a grande vantagem a Interface Fluente, a forma de uso ficou bem mais clara, a própria classe explica, guia o desenvolvedor no seu uso.<br>Mas ainda existe um problema aqui, se usarmos os métodos na ordem errada nossa interface ficará não fluente. Exemplo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/919d6d963ba317d477e1917edc88ea7a/href">https://medium.com/media/919d6d963ba317d477e1917edc88ea7a/href</a></iframe><p>Esquisito né? A leitura já não está fluente, além disso, nada impede de esquecer o preenchimento do cliente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/38e2a1fcfa2d43a1a2aee9c606662aec/href">https://medium.com/media/38e2a1fcfa2d43a1a2aee9c606662aec/href</a></iframe><p>Para quem esses itens foram vendidos? Isso pode causar erro, caso o cliente seja obrigatório em uma NF.</p><h3>StepBuilders</h3><p>Para resolver esse problema, existe um outro padrão de projeto bem interessante, chamado <a href="http://rdafbn.blogspot.com.br/2012/07/step-builder-pattern_28.html">StepBuilders</a>.</p><p>Ele tem o objetivo de resolver problemas do builder tradicional e da interface fluente, tais como:</p><ul><li>Não guiar o usuário corretamente para criação de um objeto;</li><li>O usuário pode finalizar a construção do objeto a qualquer momento, chamando o método que finaliza a execução, mesmo sem todas as informações necessárias. Deixando o objeto em um estado incoerente</li></ul><p>O StepBuilder funciona simplesmente encadeando interfaces, cada uma representando um passo na criação de um objeto ou execução de uma ação.</p><p>Usando o mesmo exemplo da Nf, vejamos agora com fica nossa interface fluente implementando também o padrão StepBuilder:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2443dfc9ba733c7849b4250b8621fd2/href">https://medium.com/media/d2443dfc9ba733c7849b4250b8621fd2/href</a></iframe><p>O uso é bem parecido com a anterior, a diferença é que a IDE vai te ajudar e não errar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/99759c667dfb28009b5f49045bcd197b/href">https://medium.com/media/99759c667dfb28009b5f49045bcd197b/href</a></iframe><p>Caso você tente trocar a ordem dos métodos, o Java lançará um erro de compilação, algo parecido com isso:</p><pre>Error:(34, 25) java: D:\workspace\untitled\src\Nf.java:34: cannot find symbol<br>symbol  : method paraCliente(java.lang.String)<br>location: interface Nf.NumeroStep</pre><p>Eu gosto muito de escrever interfaces fluentes, principalmente na criação de utilitários. Assim que der falo sobre alguns utilitários que criei.</p><p>Se gostou deixe-me um comentário.</p><p>Abraços.</p><p><strong>Fontes:</strong></p><ul><li><a href="http://luizricardo.org/2013/08/construindo-objetos-de-forma-inteligente-builder-pattern-e-fluent-interfaces/">Construindo objetos de forma inteligente: Builder Pattern e Fluent Interfaces</a></li><li><a href="http://stefanteixeira.com.br/2015/09/30/design-patterns-para-melhorar-seus-testes-parte-2-stepbuilder/">Design Patterns para melhorar seus testes, Parte 2: StepBuilder</a></li></ul><p><em>Originally published at </em><a href="https://edermfl.wordpress.com/2016/01/05/interface-fluente-e-stepbuilders/"><em>edermfl.wordpress.com</em></a><em> on January 5, 2016.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8b89a938dc8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/synchro-tec/interface-fluente-e-stepbuilders-c8b89a938dc8">Interface Fluente e StepBuilders</a> was originally published in <a href="https://medium.com/synchro-tec">SynchroTEC</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>