<?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 Pedro Gabriel Da Rocha Matos on Medium]]></title>
        <description><![CDATA[Stories by Pedro Gabriel Da Rocha Matos on Medium]]></description>
        <link>https://medium.com/@pedrogabrielrochamatos?source=rss-27a4aa3dfe92------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*z76dyxkHyXx9KyGp</url>
            <title>Stories by Pedro Gabriel Da Rocha Matos on Medium</title>
            <link>https://medium.com/@pedrogabrielrochamatos?source=rss-27a4aa3dfe92------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:32:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pedrogabrielrochamatos/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[Automatize o Mapeamento de Objetos em Java com Dozer Bean Mapper]]></title>
            <link>https://medium.com/@pedrogabrielrochamatos/automatize-o-mapeamento-de-objetos-em-java-com-dozer-bean-mapper-b839681dd849?source=rss-27a4aa3dfe92------2</link>
            <guid isPermaLink="false">https://medium.com/p/b839681dd849</guid>
            <category><![CDATA[dozer]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[mapeamento]]></category>
            <dc:creator><![CDATA[Pedro Gabriel Da Rocha Matos]]></dc:creator>
            <pubDate>Fri, 11 Jul 2025 15:15:32 GMT</pubDate>
            <atom:updated>2025-07-11T15:15:32.502Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução</h3><p>Se você já precisou converter entidades para DTOs em projetos Java, sabe o quanto o processo pode ser repetitivo e propenso a erros. O Dozer Bean Mapper é uma biblioteca open source que automatiza o mapeamento entre objetos, tornando o código mais limpo e fácil de manter. Neste artigo, você vai aprender o que é o Dozer, como utilizá-lo, seus trade-offs e verá exemplos reais de implementação e testes.</p><h3>O que é o Dozer Bean Mapper?</h3><p>O Dozer é uma biblioteca Java que copia recursivamente dados de um objeto para outro, de acordo com o nome dos atributos das classes. Ele suporta conversão automática de tipos compatíveis, mapeamento de listas e customização via XML ou API. O objetivo é facilitar a conversão entre entidades e DTOs, reduzindo o risco de bugs e inconsistências.</p><h3>Por que usar um mapper?</h3><p>Em arquiteturas em camadas, é comum separar entidades de domínio (Entities) dos objetos de transferência de dados (DTOs). O mapeamento manual é custoso, repetitivo e sujeito a falhas humanas. Com o Dozer, o processo é automatizado e seguro, tornando o desenvolvimento mais ágil e confiável.</p><h3>Alternativas ao Dozer</h3><ul><li>MapStruct: Gera código em tempo de compilação, sendo mais performático, porém menos flexível para mapeamentos dinâmicos.</li><li>ModelMapper: Abordagem similar ao Dozer, mas com sintaxe e configuração diferentes.</li></ul><h3>Como usar o Dozer Bean Mapper</h3><h3>1. Adicione a dependência ao seu projeto</h3><pre>&lt;dependency&gt;<br>  &lt;groupId&gt;com.github.dozermapper&lt;/groupId&gt;<br>  &lt;artifactId&gt;dozer-core&lt;/artifactId&gt;<br>  &lt;version&gt;7.0.0&lt;/version&gt;<br>&lt;/dependency&gt;</pre><h3>2. Crie suas classes de origem e destino</h3><pre>public class Pessoa {<br>    private String name;<br>    private int idade;<br>    // getters e setters<br>}<br>public class PessoaDTO {<br>    private String name;<br>    private Integer idade;<br>    // getters e setters<br>}</pre><h3>3. Implemente um mapper genérico</h3><pre>import org.dozer.Mapper;<br>import org.dozer.DozerBeanMapperBuilder;<br><br>public class ObjectMapper {<br>    private ObjectMapper() {}<br>    private static Mapper mapper = DozerBeanMapperBuilder.buildDefault();<br>    public static &lt;O, D&gt; D parseObject(final O origin, final Class&lt;D&gt; destination) {<br>        if (origin == null) return null;<br>        return mapper.map(origin, destination);<br>    }<br>    public static &lt;O, D&gt; List&lt;D&gt; parseListObjects(final List&lt;O&gt; origin, final Class&lt;D&gt; destination) {<br>        List&lt;D&gt; destinationList = new ArrayList&lt;&gt;();<br>        if (origin == null) return destinationList;<br>        for (O item : origin) {<br>            destinationList.add(mapper.map(item, destination));<br>        }<br>        return destinationList;<br>    }<br>}</pre><h3>4. Usando o Dozer na prática</h3><pre>Pessoa pessoa = new Pessoa(&quot;João&quot;, 30);<br>PessoaDTO pessoaDTO = ObjectMapper.parseObject(pessoa, PessoaDTO.class);<br>// pessoaDTO.getIdade() será 30 (Integer)</pre><p>O Dozer faz a conversão automática de tipos compatíveis, desde que os nomes dos atributos sejam iguais.</p><h3>Exemplo Real: Mapeando Entidade para DTO</h3><h3>Entidade</h3><pre>public class Usuario implements Serializable {<br>    private Long idUsuario;<br>    private String userName;<br>    private String senha;<br>    private Pessoa pessoa;<br>    private Role role;<br>    private Boolean accountNonExpired;<br>    private Boolean accountNonLocked;<br>    private Boolean credentialsNonExpired;<br>    private Boolean enabled;<br>    // getters e setters<br>}</pre><h3>DTO</h3><pre>public class UsuarioDTO {<br>    Long idUsuario;<br>    String userName;<br>    String senha;<br>    Long pessoaid;<br>    Role role;<br>    Boolean accountNonExpired;<br>    Boolean accountNonLocked;<br>    Boolean credentialsNonExpired;<br>    Boolean enabled;<br>    // getters e setters<br>}</pre><h3>Customizando o mapeamento com XML</h3><p>Quando os nomes dos atributos diferem, você pode usar um arquivo XML para configurar o mapeamento:</p><pre>&lt;mapping&gt;<br>  &lt;class-a&gt;Usuario&lt;/class-a&gt;<br>  &lt;class-b&gt;UsuarioDTO&lt;/class-b&gt;<br>  &lt;field&gt;<br>    &lt;a&gt;pessoa.id&lt;/a&gt;<br>    &lt;b&gt;pessoaid&lt;/b&gt;<br>  &lt;/field&gt;<br>&lt;/mapping&gt;</pre><p>Para usar o XML:</p><pre>Mapper mapper = DozerBeanMapperBuilder.create()<br>    .withMappingFiles(&quot;dozer-mapping.xml&quot;)<br>    .build();</pre><h3>Testando o mapeamento</h3><h3>Mock para testes</h3><pre>public class MockUsuario {<br>    public Usuario mockEntity(Integer number) {<br>        return Usuario.builder()<br>            .withIdUsuario(number.longValue())<br>            .withUserName(&quot;userName&quot; + number)<br>            .withSenha(&quot;senha&quot; + number)<br>            .withPessoa(null)<br>            .withRole(number % 2 == 0 ? Role.AGENTE_SAUDE : Role.ADMIN)<br>            .withAccountNonExpired(number % 2 == 0)<br>            .withAccountNonLocked(number % 2 == 0)<br>            .withCredentialsNonExpired(number % 2 == 0)<br>            .withEnabled(number % 2 == 0)<br>            .build();<br>    }<br>    public UsuarioDTO mockDto(Integer number) {<br>            return UsuarioDTO.builder()<br>                .withIdUsuario(number.longValue())<br>                .withUserName(&quot;userName&quot; + number)<br>                .withSenha(&quot;senha&quot; + number)<br>                .withRole(number % 2 == 0 ? Role.AGENTE_SAUDE : Role.ADMIN)<br>                .withAccountNonExpired(number % 2 == 0)<br>                .withAccountNonLocked(number % 2 == 0)<br>                .withCredentialsNonExpired(number % 2 == 0)<br>                .withEnabled(number % 2 == 0)<br>                .build();<br>     }<br>}</pre><h3>Exemplo de teste unitário</h3><pre>import static org.junit.jupiter.api.Assertions.*;<br><br>@Test<br>public void testUsuarioToUsuarioDTO() {<br>    Usuario usuario = mockUsuario.mockEntity(1);<br>    UsuarioDTO usuarioDTO = ObjectMapper.parseObject(usuario, UsuarioDTO.class);<br>    assertEquals(usuario.getUserName(), usuarioDTO.getUserName());<br>    assertEquals(usuario.getRole(), usuarioDTO.getRole());<br>    // Outros asserts conforme necessário<br>}</pre><h3>Trade-offs do Dozer</h3><p>Vantagens:</p><ul><li>Reduz código repetitivo</li><li>Conversão automática de tipos</li><li>Suporte a mapeamento recursivo e listas</li><li>Configuração via XML ou API</li></ul><p>Desvantagens:</p><ul><li>Pode impactar a performance em grandes volumes (usa reflexão)</li><li>Menos controle fino que mapeamento manual</li><li>Depuração pode ser mais complexa</li></ul><h3>Boas práticas</h3><ul><li>Reutilize a instância do Mapper: Não crie uma nova a cada mapeamento.</li><li>Configure mapeamentos complexos via XML para maior clareza.</li><li>Avalie alternativas como MapStruct se performance for crítica.</li></ul><h3>Conclusão</h3><p>O Dozer Bean Mapper é uma ferramenta poderosa para automatizar o mapeamento de objetos em Java, tornando o desenvolvimento mais ágil e seguro. Ideal para projetos onde o mapeamento manual se torna inviável, ele pode ser facilmente customizado e integrado. Para cenários de alta performance, considere alternativas como o MapStruct.</p><h3>Referências</h3><ul><li>Baeldung: Guia sobre Dozer Bean Mapper</li><li>Documentação oficial Dozer</li><li>HowToDoInJava: Exemplo prático de uso do Dozer</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b839681dd849" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como Pequenos Erros com Float e Double Podem Virar Grandes Prejuízos — E Como Evitar Isso com…]]></title>
            <link>https://medium.com/@pedrogabrielrochamatos/como-pequenos-erros-com-float-e-double-podem-virar-grandes-preju%C3%ADzos-e-como-evitar-isso-com-145b67ae3a18?source=rss-27a4aa3dfe92------2</link>
            <guid isPermaLink="false">https://medium.com/p/145b67ae3a18</guid>
            <category><![CDATA[float]]></category>
            <category><![CDATA[double]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[erros]]></category>
            <category><![CDATA[dev]]></category>
            <dc:creator><![CDATA[Pedro Gabriel Da Rocha Matos]]></dc:creator>
            <pubDate>Fri, 23 May 2025 14:26:12 GMT</pubDate>
            <atom:updated>2025-05-23T14:26:12.853Z</atom:updated>
            <content:encoded><![CDATA[<h3>Como Pequenos Erros com Float e Double Podem Virar Grandes Prejuízos — E Como Evitar Isso com BigDecimal em Java</h3><p><strong>Introdução</strong></p><p>Ao programar em Java, é comum encontrar situações em que operações aparentemente simples com números decimais não produzem o resultado esperado. Por exemplo, ao somar 0.7 com 0.1 usando os tipos float ou double, o resultado pode não ser exatamente 0.8. O mesmo ocorre com outras operações, como 0.1 + 0.2 (que não resulta exatamente em 0.3) ou 0.3–0.2. Em sistemas financeiros, onde milhões de operações precisam ser precisas, essas pequenas diferenças podem gerar prejuízos significativos para as instituições.</p><p><strong>Representação Binária Inexata</strong></p><p>Os tipos float e double representam números em base binária (base 2), seguindo o padrão IEEE 754. Isso significa que nem todos os valores decimais que escrevemos em base 10 podem ser representados exatamente em binário. Por exemplo, números como 0.1, 0.2 e 0.7 tornam-se dízimas periódicas em binário, assim como ocorre com 1/3 em decimal (0.333…).</p><p>No caso do 0.1, sua representação binária é algo como 0.00011001100110011…, com o padrão 0011 se repetindo infinitamente. Como os tipos float e double têm um número limitado de bits para armazenar esses números, eles precisam truncar ou arredondar a representação, introduzindo pequenas imprecisões.</p><p><strong>Acúmulo de Erros</strong></p><p>Cada vez que uma operação aritmética é realizada com números de ponto flutuante, essas pequenas imprecisões podem se acumular. Em sistemas que realizam milhões de operações, como bancos ou plataformas de pagamento, o acúmulo desses erros pode resultar em diferenças financeiras notáveis e inaceitáveis.</p><p>Quando dizemos que o acúmulo desses erros pode resultar em diferenças financeiras notáveis e inaceitáveis, queremos dizer o seguinte:</p><p>Notáveis: As diferenças deixam de ser meramente frações de centavos e passam a ser valores perceptíveis, como centavos, reais ou até quantias maiores, dependendo do volume de operações. Por exemplo, em um banco que processa milhões de transações, um erro de apenas R$ 0,01 por operação pode rapidamente se transformar em milhares de reais de diferença. Esses valores são facilmente percebidos em extratos, balanços e auditorias, impactando diretamente os resultados financeiros e a confiança dos clientes.</p><p>Inaceitáveis: Em sistemas financeiros, qualquer diferença, por menor que seja, é considerada inaceitável porque pode causar prejuízos, conflitos legais, perda de credibilidade e até sanções regulatórias. O setor financeiro exige precisão absoluta, pois cada centavo precisa ser corretamente registrado e movimentado. Portanto, permitir que pequenas imprecisões matemáticas alterem o valor final de saldos ou transações é algo que não pode ser tolerado nesse contexto.</p><p><strong>Comparação de Valores</strong></p><p>Outro problema importante é a comparação de valores. Comparar dois floats ou doubles para igualdade (por exemplo, if (valor1 == valor2)) é arriscado, pois mesmo que matematicamente os valores devessem ser iguais, suas representações binárias podem ser ligeiramente diferentes devido a essas imprecisões. Por isso, recomenda-se sempre comparar se a diferença entre os valores é menor que um pequeno limite (epsilon), e não se são exatamente iguais.</p><p><strong>Como Resolver esse Problema em Java?</strong></p><p>A solução para cálculos precisos com valores decimais em Java é utilizar a classe <em>java.math.BigDecimal</em>. Diferente dos tipos primitivos, o BigDecimal trabalha com precisão arbitrária e armazena os valores em base decimal, evitando os problemas de conversão e arredondamento dos tipos binários.</p><p><strong>Principais Cuidados ao Usar BigDecimal</strong></p><p>- Criação dos Objetos: Sempre crie <em>BigDecimal </em>a partir de uma String para garantir a exatidão do valor. <br> <br><em> java<br> BigDecimal v1 = new BigDecimal(“0.7”);<br> BigDecimal v2 = new BigDecimal(“0.1”);</em><br> <br> Evite: <em>new BigDecimal(0.7) </em>// Pode ser impreciso!</p><p>- Operações Aritméticas: Utilize os métodos da classe para somar (add), subtrair (subtract), multiplicar (multiply) e dividir (divide). <br> Para divisão, é importante definir a escala (número de casas decimais) e o modo de arredondamento para evitar exceções:<br> <br><em> java<br> BigDecimal resultado = v1.divide(v2, 2, RoundingMode.HALF_UP);</em></p><p>- Comparação: Use o método<em> compareTo()</em> para comparar valores:<br><em> — bd1.compareTo(bd2) == 0: valores iguais<br> — bd1.compareTo(bd2) &gt; 0: bd1 maior que bd2<br> — bd1.compareTo(bd2) &lt; 0: bd1 menor que bd2</em></p><p>- Controle de Casas Decimais: O método <em>setScale()</em> permite definir o número de casas decimais e o modo de arredondamento mais adequado, como <em>RoundingMode.HALF_UP</em> (arredondamento comercial) ou <em>RoundingMode.DOWN</em> (truncamento).</p><p><strong>Conclusão</strong></p><p>A imprecisão dos tipos float e double para representar valores decimais é uma limitação inerente à forma como os computadores armazenam números em binário. Para aplicações que exigem alta precisão, como sistemas financeiros, o uso da classe <em>BigDecimal</em> é fundamental para garantir resultados corretos e confiáveis, eliminando os problemas de arredondamento e representação presentes nos tipos primitivos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=145b67ae3a18" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Autenticação e Autorização: O Básico que Todo Desenvolvedor Precisa Saber — Conceitos, Diferenças…]]></title>
            <link>https://medium.com/@pedrogabrielrochamatos/autentica%C3%A7%C3%A3o-e-autoriza%C3%A7%C3%A3o-o-b%C3%A1sico-que-todo-desenvolvedor-precisa-saber-conceitos-diferen%C3%A7as-5ae1f217d427?source=rss-27a4aa3dfe92------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ae1f217d427</guid>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[dev]]></category>
            <category><![CDATA[autenticação]]></category>
            <category><![CDATA[authorization]]></category>
            <category><![CDATA[autorização]]></category>
            <dc:creator><![CDATA[Pedro Gabriel Da Rocha Matos]]></dc:creator>
            <pubDate>Sat, 26 Apr 2025 21:00:48 GMT</pubDate>
            <atom:updated>2025-04-26T21:00:48.974Z</atom:updated>
            <content:encoded><![CDATA[<h3>Autenticação e Autorização: O Básico que Todo Desenvolvedor Precisa Saber — Conceitos, Diferenças e Exemplos Práticos</h3><h3>Introdução</h3><p>No desenvolvimento de software, autenticação e autorização são conceitos fundamentais para a segurança das aplicações. Nós, desenvolvedores, frequentemente nos deparamos com esses termos e, por vezes, acabamos confundindo-os conceitualmente. Por isso, é essencial aprimorar o entendimento sobre ambos, pois essa distinção é a base dos controles de acesso modernos e atua como uma barreira crucial contra ameaças digitais, fraudes e vazamentos de dados.</p><p>Compreender claramente o que é autenticação e o que é autorização vai além de um exercício teórico: é uma prática indispensável para proteger sistemas, dados e a privacidade dos usuários. Ou seja, ignorar ou confundir esses conceitos pode resultar em falhas graves de segurança, como permitir que usuários não autorizados acessem informações sensíveis ou conceder permissões excessivas a usuários comuns. Ataques cibernéticos frequentemente exploram brechas nessas etapas, seja obtendo credenciais de autenticação ou explorando permissões mal configuradas para causar danos significativos. Além disso, a autenticação e a autorização são a primeira linha de defesa contra o acesso indevido a dados confidenciais, sendo essenciais para manter a integridade, a privacidade e a conformidade regulatória das aplicações.</p><p>Portanto, dominar a diferença entre autenticação e autorização permite implementar políticas de acesso robustas, identificar rapidamente vulnerabilidades e responder de forma eficiente a ameaças, fortalecendo toda a infraestrutura de segurança da organização. Para deixar esses conceitos ainda mais claros, ao final deste estudo, trarei uma questão de um concurso público de 2025 sobre um dos tópicos, reforçando a importância prática desse conhecimento para o dia a dia do desenvolvedor.</p><h3><strong>Autenticação</strong></h3><p>Primeiramente, a autenticação é o procedimento de segurança que verifica a identidade ou a autenticidade de uma entidade em um sistema. Ou seja, o objetivo é confirmar as credenciais (geralmente usuário e senha) e garantir que quem está tentando o acesso é realmente a pessoa que afirma ser. De forma bastante simplificada, é o processo de provar que você é quem diz ser. A seguir, apresento um exemplo para tornar esse conceito mais claro.</p><p><em>Exemplo de autenticação:</em></p><p>Imagine que você quer acessar o WhatsApp em seu celular novo.</p><p>Ao abrir o aplicativo, o WhatsApp pede seu número de telefone e, em seguida, envia um código por SMS para você digitar.</p><p>O que está acontecendo?</p><p>O WhatsApp está verificando se você é realmente o dono daquele número de telefone, pedindo para você provar que tem acesso ao SMS.</p><p>Se você digitar o código correto:</p><p>Pronto! Você está autenticado. O WhatsApp agora sabe que é você mesmo tentando acessar sua conta.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GPchU0hr3kvkMyuke8ISAg.png" /></figure><p>Existem alguns tipos de autenticação, e vamos apresentar exemplos deles e explicá-los de forma breve a seguir:</p><p>● <strong>Tipos de Autenticação:</strong></p><p>・Senhas e PINS:</p><p>São os métodos mais tradicionais e amplamente utilizados. O usuário fornece uma senha ou PIN, que é comparado com o armazenado no sistema. Apesar de simples, são vulneráveis a ataques de força bruta e engenharia social, por isso recomenda-se o uso de senhas fortes e políticas de troca periódica.</p><p>・Biometria</p><p>Utiliza características físicas ou comportamentais únicas do usuário, como impressões digitais, reconhecimento facial, voz ou íris. O sistema captura e compara os dados biométricos com os previamente registrados. É mais conveniente e difícil de falsificar, mas exige cuidado com o armazenamento seguro dos dados biométricos.</p><p>・Tokens</p><p>Um token é um código temporário e exclusivo gerado para autenticar o usuário. Pode ser enviado via SMS, aplicativo autenticador ou dispositivo físico. O token é válido por tempo limitado e, após o uso, é invalidado, o que dificulta tentativas de reutilização ou interceptação.</p><p>・Autenticação de Dois fatores</p><p>Combina dois métodos diferentes de autenticação, geralmente algo que o usuário sabe (senha) e algo que possui (token, smartphone, biometria). Isso aumenta significativamente a segurança, pois, mesmo que um fator seja comprometido, o acesso ainda depende do outro.</p><p>・Autenticação baseada em certificado</p><p>Utiliza certificados digitais para autenticar usuários, dispositivos ou máquinas. O certificado, emitido por uma autoridade confiável, garante a identidade do solicitante antes de conceder acesso à rede ou sistema. É comum em ambientes corporativos e sistemas que exigem alta segurança.</p><p>・Autenticação por Sessão e Token JWT</p><p>O servidor gera um JSON Web Token (JWT) assinado, contendo informações do usuário. O token é armazenado no cliente e enviado em cada requisição. O servidor valida o token sem precisar manter o estado, tornando o método escalável e adequado para APIs e microsserviços.</p><p>・Autenticação por Sessão</p><p>Após o login, o servidor cria uma sessão para o usuário e armazena informações de autenticação no servidor. O usuário recebe um identificador de sessão, geralmente em um cookie. É eficiente, mas pode sobrecarregar servidores em sistemas com muitos usuários simultâneos.</p><p>・Cartões de proximidade e códigos QR</p><p>Permitem autenticação por meio de cartões RFID/NFC ou QR Codes, geralmente usados em controles de acesso físico. O usuário aproxima o cartão ou apresenta o QR Code, que é lido e validado pelo sistema, liberando o acesso conforme as permissões.</p><h3><strong>Autorização</strong></h3><p>Por outro lado, a autorização é o processo que ocorre após a autenticação e define quais serviços ou ações um usuário autenticado tem permissão para executar ou acessar dentro de um sistema. De forma resumida, é o ato de conceder a uma parte autenticada a permissão para realizar determinada ação. Para tornar o conceito ainda mais claro, veja o exemplo a seguir:</p><p><em>Exemplo de autorização:</em></p><p>Depois de fazer login no sistema da empresa, você tenta acessar a área de folha de pagamento para ver os salários de todos os funcionários.</p><p>O que acontece agora?</p><p>O sistema vai verificar se você tem permissão para acessar essas informações.</p><p>Se você for um funcionário comum:</p><p>Você não está autorizado a ver os salários dos outros colegas. O sistema mostra uma mensagem dizendo que o acesso é negado.</p><p>Se você for do setor de RH ou gerente:</p><p>Você está autorizado a acessar e visualizar as informações de salário, porque sua função permite isso.</p><p>Resumo:</p><p>A autorização é o que define o que cada pessoa pode ver ou fazer dentro do sistema, de acordo com seu cargo ou função na empresa.</p><p>● <strong>Tipos de Autorização:</strong></p><p>・Controle de acesso baseado em função ou papel (RBAC — Role-Based Access Control):</p><p>As permissões são atribuídas a funções (ou papéis), e os usuários recebem funções conforme sua posição ou responsabilidade. Por exemplo, um usuário com papel de “administrador” pode acessar e modificar recursos, enquanto um “usuário comum” tem acesso restrito. O RBAC facilita o gerenciamento de permissões e segue o princípio do privilégio mínimo, reduzindo riscos de acesso indevido.</p><p>・Controle de Acesso Baseado em Atributo (ABAC — Attribute-Based Access Control):</p><p>O acesso é concedido com base em atributos do usuário (idade, cargo, localização), do recurso (tipo, sensibilidade) e do contexto (horário, dispositivo, local). O ABAC permite políticas de acesso mais granulares e dinâmicas, adaptando-se a cenários complexos, como limitar o acesso a dados sensíveis apenas durante o expediente ou a partir de determinadas localizações.</p><p>・Controle de Acesso obrigatório (MAC — Mandatory Access Control):</p><p>As regras de acesso são definidas por um administrador central e valem para todos os usuários. Nesse tipo de sistema, as permissões são baseadas em níveis de acesso ou em classificações de confiança. Em linhas gerais, os sistemas MAC são menos detalhados que o RBAC e o ABAC. Além disso, os próprios usuários não conseguem mudar essas regras. Muitos sistemas operacionais usam o MAC para decidir quais programas podem acessar arquivos e informações importantes do sistema, protegendo dados sensíveis contra acessos não autorizados.</p><p>・Controle de Acesso Discricionário (DAC — Discretionary Access Control):</p><p>É um modelo de controle de acesso mais flexível, no qual o proprietário do recurso (como um arquivo ou pasta) tem o poder de decidir quem pode acessar e o que pode fazer com aquele recurso. O proprietário pode conceder, modificar ou revogar permissões a outros usuários conforme desejar. Geralmente, o DAC utiliza listas de controle de acesso (ACLs), onde o dono do recurso define quais usuários ou grupos têm permissão para ler, escrever, modificar ou executar aquele recurso.</p><h3>Diferenças entre Autenticação e Autorização</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*UBQussNJJ5751fPs2KZHtA.png" /></figure><p>Autenticação: “Quem é você?” (verifica identidade)</p><p>Autorização: “O que você pode fazer?” (verifica permissões)</p><h3>Conclusão</h3><p>Compreender e aplicar corretamente os conceitos de autenticação e autorização é fundamental para garantir a segurança das aplicações e proteger dados sensíveis contra acessos indevidos. A autenticação assegura que apenas usuários legítimos possam acessar o sistema, enquanto a autorização define quais recursos e ações cada usuário pode realizar. O domínio dessas práticas permite ao desenvolvedor implementar controles de acesso robustos, reduzindo riscos de falhas de segurança e contribuindo para a integridade e a confiabilidade dos sistemas. Por isso, investir no entendimento e na aplicação criteriosa desses conceitos é uma etapa indispensável para qualquer profissional de tecnologia da informação</p><h3>Questão de concurso</h3><p>Concurso para área de desenvolvimento do Banco BANESE 2025 em Aracaju.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w99BT5Ehn_axK3RlN08dzQ.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ae1f217d427" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Alta Coesão e Baixo Acoplamento: Fundamentos para Código de Qualidade e Manutenibilidade segundo…]]></title>
            <link>https://medium.com/@pedrogabrielrochamatos/alta-coes%C3%A3o-e-baixo-acoplamento-fundamentos-para-c%C3%B3digo-de-qualidade-e-manutenibilidade-segundo-950d3763694e?source=rss-27a4aa3dfe92------2</link>
            <guid isPermaLink="false">https://medium.com/p/950d3763694e</guid>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[refactoring]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Pedro Gabriel Da Rocha Matos]]></dc:creator>
            <pubDate>Thu, 17 Apr 2025 16:51:40 GMT</pubDate>
            <atom:updated>2025-04-17T17:11:52.826Z</atom:updated>
            <content:encoded><![CDATA[<h3>Alta Coesão e Baixo Acoplamento: Fundamentos para Código de Qualidade e Manutenibilidade segundo Robert C. Martin</h3><p>Buscando aprimorar a qualidade e a manutenibilidade dos softwares em que atuo, venho estudando e aplicando conceitos fundamentais de melhores práticas na escrita e refatoração de código. Entre esses conceitos, destaco a importância da <strong>coesão </strong>e do <strong>acoplamento</strong>, amplamente discutidos em obras como Clean Code e Agile Software Development: Principles, Patterns, and Practices, ambos de Robert C. Martin.</p><p><strong>Coesão </strong><br>A coesão diz respeito à unidade funcional de um módulo, ou seja, o quanto seus elementos internos colaboram para um objetivo comum, facilitando a compreensão, manutenção e reutilização do código. Por exemplo, uma classe FileUtility dedicada exclusivamente a operações com arquivos é considerada altamente coesa, enquanto uma classe Utility que mistura métodos diversos, como SendEmail e CalculateTax, perde esse foco.</p><p>Segundo Robert C. Martin em Clean Code, manter alta coesão está diretamente relacionado ao Princípio da Responsabilidade Única (SRP), que afirma que cada classe ou função deve ter apenas uma responsabilidade bem definida. Quando uma classe ou método executa múltiplas tarefas ou lida com diferentes níveis de abstração, ela se torna difícil de entender, testar e manter. Um exemplo citado no livro é a classe GerenciadorDePedidos, que gerencia pedidos e gera relatórios, violando o SRP ao acumular mais de uma responsabilidade. O ideal, segundo Martin, é dividir essas responsabilidades em classes separadas, cada uma com um propósito claro.</p><p>Além disso, Martin observa que métodos coesos tendem a fazer referência a mais atributos da própria classe, pois estão fortemente ligados ao domínio daquela responsabilidade. Isso é reforçado em discussões sobre coesão de dados, onde métodos de uma classe devem operar majoritariamente sobre os dados internos dessa mesma classe, e não sobre dados externos.</p><p><strong>Segue um exemplo de código com baixa coesão:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BSwD6Yn5wexeAG27jdmdRA.png" /></figure><p>A classe <em>Utility</em> agrupa métodos que não têm relação direta entre si: envio de e-mails, cálculo de impostos e geração de relatórios. Cada método pertence a um domínio diferente, tornando a classe difícil de entender, manter e evoluir, exatamente como Robert C. Martin alerta em Clean Code.</p><p><strong>Segue um exemplo de código com alta coesão:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SeOvl99z1JhDcwNsWNV97Q.png" /></figure><p>A classe <em>ReportGenerator </em>é responsável apenas por operações relacionadas à geração de relatórios. Todos os métodos estão alinhados a um único propósito, facilitando a compreensão, manutenção e evolução da classe, conforme recomendado por Martin ao aplicar o Princípio da Responsabilidade Única (SRP).</p><p>Em resumo, para alcançar alta coesão, são fundamentais em três pontos:</p><p>- Garantir que cada classe e método tenha uma única responsabilidade clara (SRP).</p><p>- Agrupar métodos e atributos que operam sobre os mesmos dados ou contribuem para a mesma funcionalidade.</p><p>- Manter classes pequenas e focadas, facilitando manutenção, testes e evolução do sistema.</p><p><strong>Acomplamento</strong></p><p>Por outro lado, temos o conceito de acoplamento que é a medida do grau de dependência ou interconexão entre módulos, classes ou componentes de um sistema de software. Em outras palavras, acoplamento indica o quanto um módulo conhece ou depende de outros módulos para funcionar corretamente. Quanto mais um módulo depende de detalhes internos de outro, mais fortemente acoplados eles estão. O objetivo em projetos de software é sempre buscar baixo acoplamento, pois isso facilita a manutenção, o entendimento e a reutilização do código.</p><p>Geralmente um sistema com alto acoplamento apresenta os seguintes problemas:</p><p>- Mudanças em um módulo frequentemente exigem alterações em outros módulos dependentes.</p><p>- Dificulta o entendimento e a manutenção do sistema, pois os módulos não funcionam de forma independente.</p><p>- Reduz a possibilidade de reutilização de módulos em outros contextos, já que eles dependem fortemente de outros componentes.</p><p>Em contrapartida o baixo acoplamento traz benefícios como:</p><p>- Mudanças em um módulo têm pouco ou nenhum impacto nos demais.</p><p>- Facilita a testabilidade e a manutenção.</p><p>- Melhora a reutilização de código</p><p><strong>Principais diferenças entre acoplamento e coesão:</strong></p><p>O Acoplamento está relacionado à dependência externa: quanto menos um módulo depende de outros, melhor. O ideal é que os módulos possam ser modificados, testados e reutilizados de forma independente.</p><p>Já a coesão está relacionada à unidade interna: quanto mais as responsabilidades de um módulo estiverem alinhadas a um único propósito, melhor. Um módulo coeso é mais fácil de entender, manter e evoluir.</p><p>Esses conceitos são essenciais para quem busca elevar o padrão de qualidade e manutenibilidade do código em projetos de software, e estão amplamente fundamentados nas obras de Robert C. Martin, que reforça a importância de alta coesão e baixo acoplamento para a construção de sistemas flexíveis, organizados e sustentáveis.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=950d3763694e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>