<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Guilherme Ramos Mendes on Medium]]></title>
        <description><![CDATA[Stories by Guilherme Ramos Mendes on Medium]]></description>
        <link>https://medium.com/@guilherme-rmendes95?source=rss-b86c6ac07fd8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*pfItpNQTELdqbGpWv0EBLA.jpeg</url>
            <title>Stories by Guilherme Ramos Mendes on Medium</title>
            <link>https://medium.com/@guilherme-rmendes95?source=rss-b86c6ac07fd8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 18:48:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@guilherme-rmendes95/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[Autenticação e Autorização + JWT — .NET]]></title>
            <link>https://guilherme-rmendes95.medium.com/autentica%C3%A7%C3%A3o-e-autoriza%C3%A7%C3%A3o-jwt-net-409b191ba20c?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/409b191ba20c</guid>
            <category><![CDATA[autenticação]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[jwt]]></category>
            <category><![CDATA[autorização]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Mon, 30 Jan 2023 01:18:21 GMT</pubDate>
            <atom:updated>2023-01-30T04:25:40.305Z</atom:updated>
            <content:encoded><![CDATA[<h3>Autenticação e Autorização + JWT — .NET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*MpUcbNE1TFLlvBX4T3cAwQ.png" /></figure><p>Neste artigo irei abordar o conceito de autenticação e autorização, e mostrar também uma implementação simples de como aplica-lo na prática em sua aplicação. O conceito de autenticação e autorização se extende para qualquer tipo de linguagem, apenas a implementação que aqui ficará estrita ao .NET.</p><h3>Autenticação</h3><p>A autenticação é utilizada para garantir quem você é, em palavras técnicas, ela se certifica que o usuário que está acessando a API está cadastrado.</p><h3>Autorização</h3><p>A autorização é a confirmação das suas permissões para acessar os recursos expostos pela API. Geralmente, estas permissões são concedidas de acordo com o perfil que o usuário possui.</p><h3>Roles, Claims and Policies (Perfis, Reivindicações, e Políticas)</h3><h4>Roles</h4><p>As roles ou perfis, são a especificação da função que o usuário possui: Gerente, Administrador, Aluno e etc. Tudo depende do contexto da aplicação e qual é o negócio da qual ela está inserida.</p><h4>Claims</h4><p>As claims ou afirmações, são uma forma de conceder os acessos baseados em dados imperativos como por exemplo uma data de aniversário.</p><h4>Policies</h4><p>As policies ou políticas trabalham para restringir o acesso a recursos específicos de uma API. Elas podem utilizar as roles e as claims para isto.</p><h3>JWT — Json Web Token</h3><p>O JWT é um padrão para autenticação utilizado geralmente na comunicação entre um cliente e um servidor. O Token carrega informações a respeito do usuário que está autenticado na API. O JWT é um código base64 que pode ser assinado usando um segredo ou um par de chaves pública ou privada. Para ir mais a fundo, visite a <a href="https://www.rfc-editor.org/rfc/rfc7519"><strong>RFC7519</strong></a><strong>.</strong></p><h3>Código</h3><p>Agora que sabemos um pouco mais sobre Autenticação, Autorização e JWT… Vamos por a mão na massa!</p><h4>Creating Web Api Project (Criando o projeto Web Api)</h4><p>Vamos criar nossa aplicação utilizando o .NET CLI, para isso execute os seguintes comandos no terminal dentro do diretório desejado.</p><pre>dotnet new webapi -o Auth<br>cd Auth<br>dotnet restore<br>dotnet add package Microsoft.AspNetCore.Authentication //Adding necessary packages<br>dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer //Adding necessary packages</pre><p>Agora que temos nossa aplicação criada, abra ela em qualquer editor de sua preferência.</p><h4>Configuração da Autenticação e Autorização</h4><p>A classe<strong> Program.cs</strong> é responsável por toda a configuração da aplicação. Nas versões mais recentes do .NET ele concentra toda a implementação que era feita na classe <strong>Startup.cs.</strong></p><p>Será nessa classe que iremos realizar a configuração da Autenticação e Autorização.</p><p>Para que a configuração não fique espalhada dentro da classe <strong>Program.cs</strong>, irei criar um método de extensão para concentrar toda a implementação da Autenticação.</p><p>Para isso irei criar uma pasta dentro do projeto chamada “Configuration” e então dentro dela, criarei uma classe chamada <strong>AuthenticationCofiguration.cs.</strong></p><p>Dentro dessa classe, irei implementar um método estático que ira extender a configuração da interface <strong>IServiceCollection</strong>.</p><pre>namespace Auth.Api.Configurations;<br><br>using System.Text;<br>using Auth.Shared;<br>using Microsoft.AspNetCore.Authentication;<br>using Microsoft.AspNetCore.Authentication.JwtBearer;<br>using Microsoft.IdentityModel.Tokens;<br><br>public static class AuthenticationConfiguration<br>{<br>    public static void ConfigureAuthentication(this IServiceCollection services)<br>    {<br>        AuthenticationBuilder authenticationBuilder = services.AddAuthentication(x =&gt;<br>        {<br>            x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;<br>            x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;<br>        });<br><br>        authenticationBuilder.ConfigureJwtBearer();<br>    }<br><br>    private static void ConfigureJwtBearer(this AuthenticationBuilder authenticationBuilder)<br>    {<br>        byte[] key = Encoding.ASCII.GetBytes(Settings.Secret);<br>        authenticationBuilder.AddJwtBearer(x =&gt;<br>            {<br>                x.RequireHttpsMetadata = false;<br>                x.SaveToken = true;<br>                x.TokenValidationParameters = new TokenValidationParameters<br>                {<br>                    ValidateIssuerSigningKey = true,<br>                    IssuerSigningKey = new SymmetricSecurityKey(key),<br>                    ValidateIssuer = false,<br>                    ValidateAudience = false<br>                };<br>            });<br>    }<br>}</pre><p>Algumas coisa importantes sobre a implementação:</p><ul><li>O método AddAuthentication realiza a configuração dos esquemas de autenticação e na sequencia, utilizamos a classe AuthenticationBuilder para realizar a configuração do JWT.</li><li>O método de extensão para a classe AuthenticationBuilder configura a chave que será utilizada para assinar o token e configura as validações que vão ser feitas em cima do token nas requisições aos recursos que precisam de autenticação.</li><li>A classe estática Settings.cs possui um segredo do tipo string. Neste exemplo estou utilizando um Guid sem os hífens, mas fique a vontade para criar uma chave pública ou privada para assinar o token.</li></ul><h4>Repositório de usuários fake</h4><p>Vamos criar um repositório de usuário fake, para que possamos recuperar os dados do usuário de acordo com o nome e senha. Ele será utilizado na geração do token e no fluxo de autenticação.</p><pre>namespace Auth.Domain.User.Models;<br><br>public class User<br>{<br>    public int Id { get; set; }<br>    public string? Username { get; set; }<br>    public string? Password { get; set; }<br>    public string? Role { get; set; }<br>}</pre><pre>namespace Auth.Domain.User.Repository;<br><br>using Auth.Domain.User.Models;<br><br>public interface IUserRepository<br>{<br>    Task&lt;User&gt; Get(string username, string password);<br>}</pre><pre>using Auth.Domain.User.Models;<br>using Auth.Domain.User.Repository;<br><br>namespace Auth.Infrastructure.Data.Repository;<br><br>public class UserRepository : IUserRepository<br>{<br>    private readonly IList&lt;User&gt; _users;<br><br>    public UserRepository()<br>    {<br>        _users = new List&lt;User&gt;();<br>        _users.Add(new User { Id = 1, Username = &quot;manager&quot;, Password = &quot;passw@rd&quot;, Role = &quot;manager&quot; });<br>        _users.Add(new User { Id = 2, Username = &quot;employee&quot;, Password = &quot;passw@rd&quot;, Role = &quot;employee&quot; });<br>    }<br><br>    public async Task&lt;User&gt; Get(string username, string password)<br>    {<br>        return await Task.Run(() =&gt;<br>         {<br>             return _users.Where(x =&gt; x.Username.ToLower().Equals(username.ToLower())<br>                      &amp;&amp; x.Password.Equals(password.ToLower()))<br>                      .FirstOrDefault();<br>         });<br>    }<br>}</pre><h4>Gerando o token</h4><p>Para gerar o token vamos criar uma interface e uma classe de serviço, vou chama-las de ITokenService e Token Service.</p><pre>namespace Auth.Domain.Token.Models;<br><br>public class AccessToken<br>{<br>    public AccessToken(string token, string username, string role)<br>    {<br>        Token = token;<br>        Username = username;<br>        Role = role;<br>    }<br><br>    public string Token { get; private set; }<br>    public string Username { get; private set; }<br>    public string Role { get; private set; }<br>}</pre><pre>namespace Auth.Domain.Token.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br><br>public interface ITokenService<br>{<br>    AccessToken GenerateToken(User user);<br>}</pre><pre>namespace Auth.Domain.Token.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br>using Auth.Shared;<br>using System.Security.Claims;<br>using System.Text;<br>using Microsoft.IdentityModel.Tokens;<br>using System.IdentityModel.Tokens.Jwt;<br><br>public class TokenService : ITokenService<br>{<br>    private const int _HOURS_TO_EXPIRE_TOKEN = 2;<br><br>    public AccessToken GenerateToken(User user)<br>    {<br>        JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();<br>        byte[] key = Encoding.ASCII.GetBytes(Settings.Secret);<br>        SecurityTokenDescriptor tokenSpecificationDescriptor = DescribeTokenSpecification(user, key);<br>        SecurityToken securityToken = tokenHandler.CreateToken(tokenSpecificationDescriptor);<br>        string token = tokenHandler.WriteToken(securityToken);<br>        return new AccessToken(token, user.Username, user.Role);<br>    }<br><br>    private SecurityTokenDescriptor DescribeTokenSpecification(User user, byte[] key)<br>    {<br>        SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor<br>        {<br>            Subject = ConfigureClaimsIdentity(user),<br>            Expires = DateTime.UtcNow.AddHours(_HOURS_TO_EXPIRE_TOKEN),<br>            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)<br>        };<br>        return tokenDescriptor;<br>    }<br><br>    private ClaimsIdentity ConfigureClaimsIdentity(User user)<br>    {<br>        ClaimsIdentity claimsIdentity = new ClaimsIdentity(new Claim[]<br>                {<br>                    new Claim(ClaimTypes.Name, user.Username.ToString()),<br>                    new Claim(ClaimTypes.Role, user.Role.ToString())<br>                });<br>        return claimsIdentity;<br>    }<br>}</pre><p>Algumas coisa importantes sobre a implementação:</p><ul><li>A classe JwtSecurityTokenHandler é responsável pela escrita do token</li><li>A classe SecurityTokenDescriptor concentra todas as informações que irão compor o token</li></ul><h4>Criando o fluxo de autenticação do usuário</h4><p>Para que possamos autenticar o usuário de acordo com suas credenciais e depois devolver o token, precisamos criar o fluxo de autenticação. Irei criar uma interface e uma classe de serviço chamadas IUserService e UserService.</p><pre>namespace Auth.Domain.User.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br><br>public interface IUserService<br>{<br>    Task&lt;AccessToken&gt; AuthenticateUser(User user);<br>}</pre><pre>namespace Auth.Domain.User.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.Token.Services;<br>using Auth.Domain.User.Repository;<br>using Auth.Domain.User.Models;<br><br>public class UserService : IUserService<br>{<br>    private readonly ITokenService _tokenService;<br>    private readonly IUserRepository _userRepository;<br><br>    public UserService(IUserRepository userRepository, ITokenService tokenService)<br>    {<br>        _userRepository = userRepository;<br>        _tokenService = tokenService;<br>    }<br><br>    public async Task&lt;AccessToken&gt; AuthenticateUser(User userData)<br>    {<br>        User user = await _userRepository.Get(userData.Username, userData.Password);<br>        AccessToken acessToken = _tokenService.GenerateToken(user);<br>        return acessToken;<br>    }<br>}</pre><h4>Controller Endpoints</h4><p>Vamos criar uma classe controller que irá receber as chamadas para login e também iremos expor uma chamada que precise estar autenticado.</p><pre>namespace Auth.Api.Controllers;<br><br>using Auth.Domain.User.Models;<br>using Auth.Domain.User.Services;<br>using Microsoft.AspNetCore.Authorization;<br>using Microsoft.AspNetCore.Mvc;<br><br>[ApiController]<br>[Route(&quot;v1/auth&quot;)]<br>public class AuthController : ControllerBase<br>{<br>    private readonly IUserService _userService;<br><br>    public AuthController(IUserService userService)<br>    {<br>        _userService = userService;<br>    }<br><br>    [HttpPost]<br>    [Route(&quot;login&quot;)]<br>    [AllowAnonymous]<br>    public async Task&lt;ActionResult&lt;dynamic&gt;&gt; Authenticate([FromBody] User user)<br>    {<br>        return await _userService.AuthenticateUser(user);<br>    }<br><br>    [HttpGet]<br>    [Authorize]<br>    [Route(&quot;authenticated&quot;)]<br>    public string Authenticated() =&gt; String.Format(&quot;Authenticated - {0}&quot;, User?.Identity?.Name);<br>}</pre><p>Algumas coisa importantes sobre a implementação:</p><ul><li>A anotação [AllowAnonymous] permite a requisição ao endpoint de &quot;/login&quot; sem precisar passar por autenticação</li><li>A anotação [Authorize] força que a request tenha o token de autenticação, caso ele não seja passado, não é possível acessar o recurso da API.</li></ul><h4>Classe Program configurada</h4><p>Ao final de todas as configurações, nossa classe program vai estar assim</p><pre>using Auth.Api.Configurations;<br><br>var builder = WebApplication.CreateBuilder(args);<br><br>builder.Services.AddControllers();<br><br>builder.Services.AddEndpointsApiExplorer();<br>builder.Services.AddSwaggerGen();<br><br>// Chamada aos métodos de extensão que criamos<br>builder.Services.ConfigureAuthentication();<br><br>/* Chamada ao método de extensão criado em um outro projeto <br>do tipo classlib, para configurar o container de Injeção de Dependências.*/<br>builder.Services.ConfigureDependencyInjection();<br><br>var app = builder.Build();<br><br>if (app.Environment.IsDevelopment())<br>{<br>    app.UseSwagger();<br>    app.UseSwaggerUI();<br>}<br><br>app.UseHttpsRedirection();<br><br>app.UseRouting();<br><br>app.UseCors(x =&gt;<br>x.AllowAnyOrigin()<br>.AllowAnyMethod()<br>.AllowAnyHeader());<br><br>/* A configuração precisa seguir esta ordem, primeiro <br>Authentication e depois Authorization*/<br>app.UseAuthentication();<br>app.UseAuthorization();<br><br>app.MapControllers();<br><br>app.Run();</pre><h3>Teste</h3><p>Vamos executar a aplicação e utilizar o postman para testar o endpoint de &quot;/login&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jmwH8phCBO2lI6bZC8xBng.png" /></figure><p>Vamos pegar o token gerado e passa-lo na aba &quot;Authorization&quot; no postman como Bearer Token e enviar uma request ao endpoint &quot;/authenticated&quot;.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aZaT-_xvY2z2ZCZ_zgTAVA.png" /></figure><p>Ao enviar a requisição, recebemos HTTP Status 200.</p><p>Se decodificarmos o token, iremos obter a seguinte informação</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X7mwnUlAVh1y_6pXrdXTrQ.png" /></figure><p>Note que as claims que foram configuradas na geração do token estão presentes na seção de payload.</p><p>Utilizei o site jwt.io para realizar a decodificação do token</p><p><a href="https://jwt.io/">JSON Web Tokens - jwt.io</a></p><h3>Github</h3><p>Encurtei muitos detalhes da implementação, a ideia do artigo foi para apenas mostrar o racicínio por trás do mecanismo de autenticação e atutorização utilizando JWT. Se você quiser ver mais detalhes, baixe o repositório do código no github =)</p><p><a href="https://github.com/guilhermerm-dev/Auth">GitHub - guilhermerm-dev/Auth</a></p><p>Espero que tenha gostado!</p><p>Até a próxima!!!</p><p><strong><em>In God I Trust</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=409b191ba20c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Authentication and Authorization + JWT — .NET]]></title>
            <link>https://guilherme-rmendes95.medium.com/authentication-and-authorization-jwt-net-cf4cb5ab1fcc?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf4cb5ab1fcc</guid>
            <category><![CDATA[jwt-token]]></category>
            <category><![CDATA[authentication]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[jwt]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Mon, 30 Jan 2023 01:17:42 GMT</pubDate>
            <atom:updated>2023-01-30T04:28:05.118Z</atom:updated>
            <content:encoded><![CDATA[<h3>Authentication and Authorization + JWT — .NET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*MpUcbNE1TFLlvBX4T3cAwQ.png" /></figure><p>In this article i i&#39;ll introduce you the concepts behind the authentication and authorization, and i&#39;ll show you one simple implementation of how to apply this on practice in you application. The concepts of authentication and authorization extends to any type of language, but here i&#39;ll just only use the .NET to do that.</p><h3>Authentication</h3><p>The authentication is used to certify who are you, in tech words, authentication certify that user who accessing the API is already registered.</p><h3><strong>Authorization</strong></h3><p>The authorization is used to confirm which are your permissions to access the API resources. Generally, the permissions are granted by user&#39;s role.</p><h3>Roles, Claims and Policies (Perfis, Reivindicações, e Políticas)</h3><h4>Roles</h4><p>Roles are the specification of user&#39;s action in the system. All depends the business rules of application.</p><h4>Claims</h4><p>The claims are used to grant access based on imperative data, for example the date of birth.</p><h4>Policies</h4><p>The policies work to restrict the access to API resources. They can use roles and claims to do that.</p><h3>JWT — Json Web Token</h3><p>The JWT is an authentication standard often used on client and server communication. The token storage data about the user who&#39;s authenticated in API. JWT is an base64 code that can be signed using a secret or public/private keys. To more deep information, see more in <a href="https://www.rfc-editor.org/rfc/rfc7519"><strong>RFC7519</strong></a><strong>.</strong></p><h3>Code</h3><p>Now that we know a little about Authentication, Authorization and JWT… Let&#39;s hand&#39;s on!</p><h4>Creating Web Api Project (Criando o projeto Web Api)</h4><p>Let&#39;s create our web api using the .NET CLI to do that execute the following commands in terminal. Choose any directory of you preference.</p><pre>dotnet new webapi -o Auth<br>cd Auth<br>dotnet restore<br>dotnet add package Microsoft.AspNetCore.Authentication //Adding necessary packages<br>dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer //Adding necessary packages</pre><p>Now that we have our application created, open it in any editor of your preference.</p><h4>Authentication and Authorization Configuration</h4><p>The <strong>Program.cs</strong> class is responsible for configure our Web Api. In the recents versions of .NET, the <strong>Startup.cs</strong> class was removed and all of the content that was in there was moved to the <strong>Program.cs</strong> class.</p><p>Will be in this class that we&#39;ll configure the Authentication and Authorization.</p><p>So that the configuration won&#39;t be spreaded in Program.cs class, i&#39;ll create an extension method to concentrate all Authentication implementation.</p><p>So then i&#39;ll create a new folder called &quot;Configuration&quot; and inside her i&#39;ll create a new class called <strong>AuthenticationConfiguration.cs</strong></p><p>In this class, i&#39;ll create an static method that will extend the interface <strong>IServiceCollection</strong> configuration.</p><pre>namespace Auth.Api.Configurations;<br><br>using System.Text;<br>using Auth.Shared;<br>using Microsoft.AspNetCore.Authentication;<br>using Microsoft.AspNetCore.Authentication.JwtBearer;<br>using Microsoft.IdentityModel.Tokens;<br><br>public static class AuthenticationConfiguration<br>{<br>    public static void ConfigureAuthentication(this IServiceCollection services)<br>    {<br>        AuthenticationBuilder authenticationBuilder = services.AddAuthentication(x =&gt;<br>        {<br>            x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;<br>            x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;<br>        });<br><br>        authenticationBuilder.ConfigureJwtBearer();<br>    }<br><br>    private static void ConfigureJwtBearer(this AuthenticationBuilder authenticationBuilder)<br>    {<br>        byte[] key = Encoding.ASCII.GetBytes(Settings.Secret);<br>        authenticationBuilder.AddJwtBearer(x =&gt;<br>            {<br>                x.RequireHttpsMetadata = false;<br>                x.SaveToken = true;<br>                x.TokenValidationParameters = new TokenValidationParameters<br>                {<br>                    ValidateIssuerSigningKey = true,<br>                    IssuerSigningKey = new SymmetricSecurityKey(key),<br>                    ValidateIssuer = false,<br>                    ValidateAudience = false<br>                };<br>            });<br>    }<br>}</pre><p>Some things important about the implementation:</p><ul><li>The AddAuthentication method configure the Authentication schema and then we use the AuthenticationBuilder class to configure JWT.</li><li>The AuthenticationBuilder class extension method configure the key that be used to sign the token and configure all validations that will be checked on token when the API receive the requests to the resources that use authentication.</li><li>The static class Settings.cs has one secret of type string. In this example i&#39;m using a Guid without hyphens, but feel free to create an public/private key to sign the token.</li></ul><h4>Fake User Repository</h4><p>Let&#39;s create an fake user repository that we can use it to retrieve user data. The fake repository will be used in the generating token flow.</p><pre>namespace Auth.Domain.User.Models;<br><br>public class User<br>{<br>    public int Id { get; set; }<br>    public string? Username { get; set; }<br>    public string? Password { get; set; }<br>    public string? Role { get; set; }<br>}</pre><pre>namespace Auth.Domain.User.Repository;<br><br>using Auth.Domain.User.Models;<br><br>public interface IUserRepository<br>{<br>    Task&lt;User&gt; Get(string username, string password);<br>}</pre><pre>using Auth.Domain.User.Models;<br>using Auth.Domain.User.Repository;<br><br>namespace Auth.Infrastructure.Data.Repository;<br><br>public class UserRepository : IUserRepository<br>{<br>    private readonly IList&lt;User&gt; _users;<br><br>    public UserRepository()<br>    {<br>        _users = new List&lt;User&gt;();<br>        _users.Add(new User { Id = 1, Username = &quot;manager&quot;, Password = &quot;passw@rd&quot;, Role = &quot;manager&quot; });<br>        _users.Add(new User { Id = 2, Username = &quot;employee&quot;, Password = &quot;passw@rd&quot;, Role = &quot;employee&quot; });<br>    }<br><br>    public async Task&lt;User&gt; Get(string username, string password)<br>    {<br>        return await Task.Run(() =&gt;<br>         {<br>             return _users.Where(x =&gt; x.Username.ToLower().Equals(username.ToLower())<br>                      &amp;&amp; x.Password.Equals(password.ToLower()))<br>                      .FirstOrDefault();<br>         });<br>    }<br>}</pre><h4>Generating Token</h4><p>To generate the token, let&#39;s create an interface and service class, i&#39;ll call them ITokenService and TokenService.</p><pre>namespace Auth.Domain.Token.Models;<br><br>public class AccessToken<br>{<br>    public AccessToken(string token, string username, string role)<br>    {<br>        Token = token;<br>        Username = username;<br>        Role = role;<br>    }<br><br>    public string Token { get; private set; }<br>    public string Username { get; private set; }<br>    public string Role { get; private set; }<br>}</pre><pre>namespace Auth.Domain.Token.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br><br>public interface ITokenService<br>{<br>    AccessToken GenerateToken(User user);<br>}</pre><pre>namespace Auth.Domain.Token.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br>using Auth.Shared;<br>using System.Security.Claims;<br>using System.Text;<br>using Microsoft.IdentityModel.Tokens;<br>using System.IdentityModel.Tokens.Jwt;<br><br>public class TokenService : ITokenService<br>{<br>    private const int _HOURS_TO_EXPIRE_TOKEN = 2;<br><br>    public AccessToken GenerateToken(User user)<br>    {<br>        JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();<br>        byte[] key = Encoding.ASCII.GetBytes(Settings.Secret);<br>        SecurityTokenDescriptor tokenSpecificationDescriptor = DescribeTokenSpecification(user, key);<br>        SecurityToken securityToken = tokenHandler.CreateToken(tokenSpecificationDescriptor);<br>        string token = tokenHandler.WriteToken(securityToken);<br>        return new AccessToken(token, user.Username, user.Role);<br>    }<br><br>    private SecurityTokenDescriptor DescribeTokenSpecification(User user, byte[] key)<br>    {<br>        SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor<br>        {<br>            Subject = ConfigureClaimsIdentity(user),<br>            Expires = DateTime.UtcNow.AddHours(_HOURS_TO_EXPIRE_TOKEN),<br>            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)<br>        };<br>        return tokenDescriptor;<br>    }<br><br>    private ClaimsIdentity ConfigureClaimsIdentity(User user)<br>    {<br>        ClaimsIdentity claimsIdentity = new ClaimsIdentity(new Claim[]<br>                {<br>                    new Claim(ClaimTypes.Name, user.Username.ToString()),<br>                    new Claim(ClaimTypes.Role, user.Role.ToString())<br>                });<br>        return claimsIdentity;<br>    }<br>}</pre><p>Some things important about the implementation:</p><ul><li>The class JwtSecurityTokenHandler is responsible for write the token.</li><li>The class SecurityTokenDescriptor contains all data that will be encrypted on token.</li></ul><h4>Creating User Authentication Flow</h4><p>So that we can authenticate the user using your credentials and give him an token, we need to create the authentication flow. So that i&#39;ll create an interface and a service class and call them IUserService and UserService.</p><pre>namespace Auth.Domain.User.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.User.Models;<br><br>public interface IUserService<br>{<br>    Task&lt;AccessToken&gt; AuthenticateUser(User user);<br>}</pre><pre>namespace Auth.Domain.User.Services;<br><br>using Auth.Domain.Token.Models;<br>using Auth.Domain.Token.Services;<br>using Auth.Domain.User.Repository;<br>using Auth.Domain.User.Models;<br><br>public class UserService : IUserService<br>{<br>    private readonly ITokenService _tokenService;<br>    private readonly IUserRepository _userRepository;<br><br>    public UserService(IUserRepository userRepository, ITokenService tokenService)<br>    {<br>        _userRepository = userRepository;<br>        _tokenService = tokenService;<br>    }<br><br>    public async Task&lt;AccessToken&gt; AuthenticateUser(User userData)<br>    {<br>        User user = await _userRepository.Get(userData.Username, userData.Password);<br>        AccessToken acessToken = _tokenService.GenerateToken(user);<br>        return acessToken;<br>    }<br>}</pre><h4>Controller Endpoints</h4><p>Let&#39;s create an controller class that will receive the requests to login user and also we&#39;ll expose and endpoint that the user must be authenticated.</p><pre>namespace Auth.Api.Controllers;<br><br>using Auth.Domain.User.Models;<br>using Auth.Domain.User.Services;<br>using Microsoft.AspNetCore.Authorization;<br>using Microsoft.AspNetCore.Mvc;<br><br>[ApiController]<br>[Route(&quot;v1/auth&quot;)]<br>public class AuthController : ControllerBase<br>{<br>    private readonly IUserService _userService;<br><br>    public AuthController(IUserService userService)<br>    {<br>        _userService = userService;<br>    }<br><br>    [HttpPost]<br>    [Route(&quot;login&quot;)]<br>    [AllowAnonymous]<br>    public async Task&lt;ActionResult&lt;dynamic&gt;&gt; Authenticate([FromBody] User user)<br>    {<br>        return await _userService.AuthenticateUser(user);<br>    }<br><br>    [HttpGet]<br>    [Authorize]<br>    [Route(&quot;authenticated&quot;)]<br>    public string Authenticated() =&gt; String.Format(&quot;Authenticated - {0}&quot;, User?.Identity?.Name);<br>}</pre><p>Some things important about the implementation:</p><ul><li>The annotation [AllowAnonymous] enable the endpoint to receive requests without auth.</li><li>The annotation [Authorize] forces the user to pass the auth token in http request.</li></ul><h4>Program class configured</h4><p>At the end of all configurations, our Program class will be like that</p><pre>using Auth.Api.Configurations;<br><br>var builder = WebApplication.CreateBuilder(args);<br><br>builder.Services.AddControllers();<br><br>builder.Services.AddEndpointsApiExplorer();<br>builder.Services.AddSwaggerGen();<br><br>// Call to extension method that we created.<br>builder.Services.ConfigureAuthentication();<br><br>/* Call to extension method in another classlib project <br>to configure the DI container.*/<br>builder.Services.ConfigureDependencyInjection();<br><br><br>var app = builder.Build();<br><br>if (app.Environment.IsDevelopment())<br>{<br>    app.UseSwagger();<br>    app.UseSwaggerUI();<br>}<br><br>app.UseHttpsRedirection();<br><br>app.UseRouting();<br><br>app.UseCors(x =&gt;<br>x.AllowAnyOrigin()<br>.AllowAnyMethod()<br>.AllowAnyHeader());<br><br>/* The configuration must follow this order, <br>first authentication and then authorization */<br>app.UseAuthentication();<br>app.UseAuthorization();<br><br>app.MapControllers();<br><br>app.Run();</pre><h3>Test</h3><p>Let&#39;s execute our application and use the postman to test the &quot;/login&quot; endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jmwH8phCBO2lI6bZC8xBng.png" /></figure><p>Now we must get the generated token and put him in the Authorization tab in postman and send the request to &quot;/authenticated&quot; endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aZaT-_xvY2z2ZCZ_zgTAVA.png" /></figure><p>And then we&#39;ll get HTTP Status 200.</p><p>If we decode the token we&#39;ll see something like this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X7mwnUlAVh1y_6pXrdXTrQ.png" /></figure><p>Notice that the claims that were configured at token generation are present in the payload section.</p><p>I used the jwt.io website to decode the token</p><p><a href="https://jwt.io/">JSON Web Tokens - jwt.io</a></p><h3>Github</h3><p>I hid some details of all implementation to not be a boring reading, so if you are interested in all code, see more in my github and feel free to clone the repo.</p><p><a href="https://github.com/guilhermerm-dev/Auth">GitHub - guilhermerm-dev/Auth</a></p><p>I hope that you have enjoyed!</p><p>See ya!</p><p><strong><em>In God I Trust</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf4cb5ab1fcc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CCP — Princípio do Fechamento Comum]]></title>
            <link>https://guilherme-rmendes95.medium.com/ccp-princ%C3%ADpio-do-fechamento-comum-4cbc58432926?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cbc58432926</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Thu, 29 Sep 2022 12:01:01 GMT</pubDate>
            <atom:updated>2022-09-29T12:01:01.721Z</atom:updated>
            <content:encoded><![CDATA[<h3>CCP — Princípio do Fechamento Comum</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*S1aq4woL7yKf5t0hQti8iQ.jpeg" /></figure><p>No meio do desenvolvimento de software, por muitas vezes, ouvimos falar do princípio SOLID. O SOLID é o conjunto de princípios que norteia o desenvolvimento de software no que se refere a classes e métodos. Se fizermos uma alusão ao mundo da arquitetura, isso seria quase que os tijolos de uma construção. Agora quando lidamos com um escopo maior, como por exemplo o escopo de componentes, temos outros princípios. E estes princípios nos auxiliam no que podemos dizer ser a disposição do layout de nossas “salas” e “quartos” no mundo da arquitetura de software.</p><p>Que tal falarmos sobre o CCP (Princípio do Fechamento Comum)?</p><h3>O que é?</h3><p>O CCP nos diz para reunir os componente que mudam pela mesma razão no mesmo momento e separar em componentes diferentes as classes que mudam em momentos diferentes em razões diferentes. Quando realizamos mudanças em nosso código, queremos que essas mudanças ocorram em um componente ao invés de em vários, fazendo a aplicação deste princípio garantimos um isolamento de um componente e poupamos outros componentes de mudar em conjunto. O principio do CCP tem forte associação com o OCP e o SRP do SOLID.</p><p>A partir do momento que reunimos classes que compartilham da mesma razão, fechamos o componente, logo segue a mesma lógica do princípio OCP.</p><p>Já a relação com o SRP acontece porque assim como neste principio do SOLID, também separamos as classes que mudam por razões diferentes em componentes diferentes. A única diferença de um para o outro é que o escopo em que o CCP trabalha é mais amplo, é um escopo de componente, já o SRP trabalha com métodos.</p><h3>Benefícios de sua aplicação</h3><p>Com a aplicação do CCP garantimos um código mais coeso e fechado para alterações de alto impacto, pois organizamos as classes em componentes que compartilham da mesma razão e tendem a mudar no mesmo tempo e separamos as classes que mudam em tempos diferentes por razões diferentes.</p><h3>Conclusão</h3><p>A aplicabilidade deste princípio nos garante um código mais coeso e de fácil manutenção, além de evitar mudanças bruscas em muitos lugares da aplicação toda vez que for implementada uma feature nova. O escopo de aplicação deste princípio é a nível de componente e tem alta relevância quando se presa por um bom design de código.</p><p><strong><em>PS: O que os itens da imagem tem em comum? São itens de limpeza! Devem ficar juntos. Utilizamos o CCP para uma coisa mais ou menos parecida hehe.</em></strong></p><p>Espero que tenha gostado!</p><p>Até a próxima!!!</p><p><strong><em>In God I Trust</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cbc58432926" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[REP — Princípio da Equivalência do Reuso]]></title>
            <link>https://guilherme-rmendes95.medium.com/rep-princ%C3%ADpio-da-equival%C3%AAncia-do-reuso-daa730d2acaa?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/daa730d2acaa</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Tue, 13 Sep 2022 12:02:31 GMT</pubDate>
            <atom:updated>2022-09-13T12:32:16.800Z</atom:updated>
            <content:encoded><![CDATA[<h3>REP — Princípio da Equivalência do Reuso</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*ZFAHEab2lLctohuFevqi5w.png" /></figure><p>No meio do desenvolvimento de software, por muitas vezes, ouvimos falar do princípio SOLID. O SOLID é o conjunto de princípios que norteia o desenvolvimento de software no que se refere a classes e métodos. Se fizermos uma alusão ao mundo da arquitetura, isso seria quase que os tijolos de uma construção. Agora quando lidamos com um escopo maior, como por exemplo o escopo de componentes, temos outros princípios. E estes princípios nos auxiliam no que podemos dizer ser a disposição do layout de nossas “salas” e “quartos” no mundo da arquitetura de software.</p><p>Que tal falarmos sobre o REP (Princípio da Equivalência do Reuso)?</p><h3>O que é?</h3><p>O princípio da equivalência do reuso nos diz que classes e módulos formados em um componente devem pertencer a um grupo coeso. Isso significa que não se deve conter aleatoriedade na mistura das classes e módulos, mas sim deve haver um propósito que todas as classes compartilhem. Além disso, as classes e módulos agrupados em um componente devem ser passíveis de release.</p><p>Esse princípio trata muito da questão da facilidade da rastreabilidade por meio de um processo de release que um componente deve ter. Isso é de suma importância, pois hoje em dia temos muitos frameworks e pacotes que utilizamos e reutilizamos em nosso código. Em cada release liberada dessas bibliotecas de código, deve-se haver um sentido tanto para o autor quanto para os usuários.</p><p>Fica muito mais fácil quando sabemos o que é alterado em uma release e o que não é alterado, quais são suas compatibilidades com versões anteriores e quais são as suas incompatibilidades.</p><h3>Benefícios de sua aplicação</h3><p>Quando aplicado, o princípio garante a rastreabilidade das versões de alteração de um componente (conjunto de classes e módulos), além de garantir que o usuário use o que de fato faz sentido ser utilizado em seu código.</p><h3>Conclusão</h3><p>A utilização do princípio da equivalência do reuso nos auxilia a manter coesão no agrupamento de classes e módulos construídos, além de nos dar previsibilidade no que se refere a utilização de bibliotecas de códigos de terceiros, pois quando construída utilizando o princípio, conseguimos ter a granularidade do release e o que de fato foi alterado em determinada versão.</p><p>Espero que tenha gostado!</p><p>Até a próxima!!!</p><p><strong><em>In God I Trust</em></strong></p><h3>Referencias</h3><p><em>Livro Arquitetura Limpa / Clean Architecture, Robert C. Martin — Pg 104–105</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=daa730d2acaa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CRP — Princípio do Reuso Comum]]></title>
            <link>https://guilherme-rmendes95.medium.com/crp-princ%C3%ADpio-do-reuso-comum-baee965a3e26?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/baee965a3e26</guid>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Tue, 06 Sep 2022 12:03:19 GMT</pubDate>
            <atom:updated>2022-09-06T12:03:19.186Z</atom:updated>
            <content:encoded><![CDATA[<h3>CRP — Princípio do Reuso Comum</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*Ghxig8jEwx9hN8sPME6zuA.png" /></figure><p>No meio do desenvolvimento de software, por muitas vezes, ouvimos falar do princípio SOLID. O SOLID é o conjunto de princípios que norteia o desenvolvimento de software no que se refere a classes e métodos. Se fizermos uma alusão ao mundo da arquitetura, isso seria quase que os tijolos de uma construção. Agora quando lidamos com um escopo maior, como por exemplo o escopo de componentes, temos outros princípios. E estes princípios nos auxiliam no que podemos dizer ser a disposição do layout de nossas &quot;salas&quot; e &quot;quartos&quot; no mundo da arquitetura de software.</p><p>Que tal falarmos sobre o CRP (Princípio do Reuso Comum)?</p><h3>O que é?</h3><p>Quando construímos um componente de software, devemos decidir quais módulos e classes irão fazer parte dele. O princípio nos ajuda a decidir quais utilizar e quais não devemos.</p><p>O princípio CRP nos alerta muito sobre a questão das dependências geradas quando utilizamos um componente. Quando fazemos o uso do componente, teremos que de fato ter certeza que precisamos de tudo aquilo que ele depende e implementa — que é impossível depender de certas classes e não depender de outras. Isso tudo visando garantir uma regra excludente em relação a utilização de classes que não iremos precisar.</p><h3>Regra excludente</h3><p>Entrando mais profundamente no conceito, nos deparamos com o cenário das alterações que poderão impactar na implementação do componente: Sempre que um componente x usado for modificado, o componente y que faz o uso deste mesmo componente x muito provavelmente precisará de uma re-implementação. Esse cenário nos alerta o seguinte: Caso você não precise de tudo aquilo que o componente implementa, ele deve ser revisto.</p><h3>Benefícios de sua aplicação</h3><p>O benefício de sua aplicação se da na construção de componentes coesos que contém classes que fazem parte do mesmo escopo. E este escopo, por sua vez, possui dependências que não irão ser ignoradas, pois elas precisaram ser de fato implementadas pelo componente que as utiliza, não tendo código dependente excessivo.</p><h3>Conclusão</h3><p>O CRP tem sua aplicação na construção de componentes em níveis mais altos em nosso software, pois é colocado sobre um conjunto de classes. Ele nos ajuda a gerar componentes coesos e nos norteia em como construí-los. Resumido em uma frase ele nos diz o seguinte: &quot;Não dependa de coisas que você não precisa&quot;.</p><p>Espero que tenha gostado!</p><p>Até a próxima!!!</p><p><strong><em>In God I Trust</em></strong></p><h3>Referencias</h3><p><em>Livro Arquitetura Limpa / Clean Architecture, Robert C. Martin — Pg 107–108</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=baee965a3e26" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como que trabalhando em um time que não entrega um produto me tornei um desenvolvedor melhor?]]></title>
            <link>https://guilherme-rmendes95.medium.com/como-que-trabalhando-em-um-time-que-n%C3%A3o-entrega-um-produto-me-tornou-um-desenvolvedor-melhor-f9cff64d73a1?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9cff64d73a1</guid>
            <category><![CDATA[desenvolvedores]]></category>
            <category><![CDATA[carreira]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[carreira-profissional]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Sat, 03 Sep 2022 20:11:26 GMT</pubDate>
            <atom:updated>2022-09-05T01:09:45.366Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwS89tVNqBhAhaZ2RmD38A.png" /></figure><p>Este é o primeiro artigo em que não irei abordar conceitos técnicos diretamente. Desta vez resolvi compartilhar um pouco dos acontecimentos da minha carreira como desenvolvedor. Está pronto? Vamos lá!</p><p>Do meio para o final do ano de 2021 tive a experiência de trabalhar em um time que não tinha como principal objetivo a entrega, manutenção ou melhoria de um produto. O seu principal objetivo era entregar qualidade, mas afinal de contas o que é entregar qualidade?</p><p>Entre os vários meses que se passaram, nossa atuação ficou muito mais focada em disseminação de técnicas de desenvolvimento orientado a testes e construção de uma pipeline robusta que automatizaria a execução dos testes, que eram executados manualmente em todas as releases.<br>De pouco em pouco me vi cada vez mais distante do que eu realmente gosto de fazer, &quot;codar&quot;! E para todos aqueles que gostam da arte de desenhar e construir um software, é um pouco chato se distanciar disso. Por vezes me vi desanimado e descontente com o projeto, mas não deixei que isso atrapalhasse meu desempenho. Tentei fazer aquela máxima de: &quot;Ao invés de enxergar o copo meio vazio, tente enxergar ele meio cheio&quot;, verdade.</p><p>Busquei alternativas. Até que cheguei a conclusão mais clara de todas: &quot;Eu sou um desenvolvedor!&quot;. E o que isso significa? Significa que eu não preciso necessariamente ter uma demanda técnica para &quot;codar&quot; no meu dia a dia. Eu posso construir coisas para facilitar os processos e reduzir a carga cognitiva empregada em algumas atividades maçantes, e isso me tornou um desenvolvedor melhor, pois me ajudou e enxergar as oportunidades que antes não eram vistas claramente.</p><p>Não gosto de frases &quot;épicas&quot;, mas nós desenvolvedores temos um super poder: Conseguimos construir coisas incríveis com as nossas mãos e pensamentos, basta um computador, uma IDE, uma linguagem e um pouco de conhecimento. Sei que não é fácil, mas com o mínimo podemos fazer muita coisa!</p><p>Esta forma de pensar me trouxe muitas ideias e me ajudaram a ter uma performance melhor. Além de ter me motivado e me deixado por mais tempo atuando neste projeto. E apesar de não ser um projeto muito técnico, me trouxe uma gama de soft-skills que antes eu não possuía.</p><p>Hoje, ao meu ver, as soft-skills são de suma importância para um desenvolvedor. Devido a grande demanda por profissionais na área, isso se tornou um diferencial. Skill técnico se conquista, não tão facilmente, mas se conquista. Agora, por outro lado, as soft-skills precisam ser lapidadas e muitas vezes em contextos desafiadores que te forcem a sair da famosa &quot;caixinha&quot;. E isso também é uma forma de se adquirir &quot;senioridade&quot;.</p><p>Por fim deixo aqui meu conselho ou dica: Não desista se o contexto é desafiador ou te force a sair da zona de conforto. Nestes momentos é que surge a força interior e as melhores idéias. E claro, sempre avalie se aquilo de fato vai contribuir para sua carreira profissional. Nem todos os desafios serão fáceis e nem todos os lugares são os melhores para se trabalhar, mas saber ser resiliente e paciente em alguns momentos, é importante.</p><p>Obrigado por ler este texto e espero ter contribuído de alguma forma para sua carreira.</p><p>Até mais!!!</p><p><strong><em>In God I Trust</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9cff64d73a1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testes de integração de banco de dados — Java + Testcontainers]]></title>
            <link>https://guilherme-rmendes95.medium.com/testes-de-integra%C3%A7%C3%A3o-de-banco-de-dados-java-testcontainers-5d16552ff39b?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d16552ff39b</guid>
            <category><![CDATA[repository-test]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[integration-testing]]></category>
            <category><![CDATA[testcontainer]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Sat, 03 Sep 2022 02:01:48 GMT</pubDate>
            <atom:updated>2022-09-03T02:01:48.437Z</atom:updated>
            <content:encoded><![CDATA[<h3>Testes de integração de banco de dados — Java + Testcontainers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/1*mjyJMx4xAUxvy8M0d2DRbA.png" /></figure><p>Quando tocamos no assunto de testes, conseguimos fazer a co-relação ao aumento de qualidade e de confiabilidade de nossas aplicações.</p><p>Um software bem construído é composto de alguns conceitos de design de código e construção da arquitetura, dentro destes conceitos temos também a questão da segregação de responsabilidade dos componentes, classes e métodos. E por que não aplica-los em nossos testes também?</p><p>Uma das camadas da <strong>pirâmide de testes</strong>, é a camada composta pelos testes de integração. A responsabilidade dos testes de integração é testar as &quot;bordas&quot; do nosso software e as interações que são feitas com outros componentes, como por exemplo <strong>banco de dados</strong>.</p><p>Neste artigo iremos abordar os testes de integração com banco de dados e sua implementação utilizando a lib do <strong>Testcontainers.</strong></p><h3>Testcontainers</h3><p>O <strong>Testcontainers</strong> é uma lib java que manipula um container docker contendo uma instância de bancos de dados durante a execução dos testes de integração. Ela permite com que os testes implementados na camada de acesso a dados consigam realizar as ações básicas: Persistir, Recuperar, Deletar e Atualizar itens no banco de dados instanciado dentro do container docker. Para saber mais sobre a lib e suas configurações customizadas, acesse <a href="https://www.testcontainers.org/">https://www.testcontainers.org/</a>.</p><h3>Implementação</h3><p>A aplicação de exemplo foi implementada utilizando a versão 17 do java + versão 2.7.3 do Spring Boot, PostgreSQL e o Gradle.</p><p><strong>Dependências</strong></p><p>Para que seja necessário utilizar o Testcontainers, é preciso realizar inclusão das seguintes dependências no arquivo build.gradle:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6960911bec7f40435b17c112c10ab3f4/href">https://medium.com/media/6960911bec7f40435b17c112c10ab3f4/href</a></iframe><p>Estas dependências servem para utilizarmos o dialeto e o driver do Postgres via properties e para utilizar o Testcontainers durante a execução dos testes na camada de repositório de nossa aplicação.</p><p><strong>Classe de configuração do Testcontainers</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cd9480b473e07881fad90daaedf022c9/href">https://medium.com/media/cd9480b473e07881fad90daaedf022c9/href</a></iframe><p>Esta classe abstrata contém a configuração do <strong>Testcontainers</strong>. A classe fica responsável por inicializar o container docker com a imagem <strong>postgres:11.1 </strong>do banco de dados <strong>PostgreSQL</strong> e executar os comandos <strong>DDL</strong> para configurar as entidades e schema no banco de dados. Além disso, ela configura as <strong>propriedades de</strong> <strong>datasource</strong> para obter a url de conexão com o banco de dados e as credenciais de acesso do mesmo.</p><p>A classe está anotada com a anotação <strong>@ActiveProfiles(&quot;Test&quot;)</strong>, esta anotação fará o carregamento dos demais itens que estão configurados dentro do arquivo de properties abaixo do diretório &quot;tests&quot; da aplicação, segue abaixo o conteúdo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b7b2edfbe395ebbc81cf204f5c775e3/href">https://medium.com/media/1b7b2edfbe395ebbc81cf204f5c775e3/href</a></iframe><p>As demais anotações configuradas na classe, de forma resumida, trabalham na inicialização do contexto da aplicação (configuração de beans, data sources e etc).</p><p><strong>Classe de Teste</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c730f267255103d65397577acb09f25c/href">https://medium.com/media/c730f267255103d65397577acb09f25c/href</a></iframe><p>Esta classe de teste realiza a herança da classe abstrata implementada anteriormente, logo adquire todas as configurações que foram implementadas na classe de configuração do Testcontainers.</p><p>Assim que o teste for executado, todas as configurações realizadas anteriormente, serão inicializadas. O Testcontainers se encarregará de criar o container docker com a imagem do bando de dados postgre e de executar os comandos DDL com a estrutura das entidades mapeadas via JPA na aplicação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JJlw-pFt5M7NnzWX3Xt0ag.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WrzHQKheiPZExhDPGOMFRA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gHiitZ24u4T7QSif9KEnNA.png" /></figure><p>Neste teste simples, serão inseridos 4 registros na tabela &quot;product&quot; e depois será feita a asserção da quantidade de itens recuperados no repositório correlato.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9ka_2LB5lfrEnG-XZQ_E1w.png" /></figure><h3>Conclusão</h3><p>A implementação de testes em nossas aplicações nos dão flexibilidade para mudanças, redução do leadtime para entrega de demandas e redução de defeitos que podem ir para o ambiente produtivo.</p><p>Espero que tenha gostado =)</p><p>Em baixo está o link do repositório com o exemplo de código.</p><p><a href="https://github.com/guilhermerm-dev/product-api">GitHub - guilhermerm-dev/product-api: java + spring boot application</a></p><p>Até mais!!!</p><p><strong><em>In God I Trust!!!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d16552ff39b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID —D —  Dependency Inversion Principle]]></title>
            <link>https://guilherme-rmendes95.medium.com/solid-d-dependency-inversion-principle-46bf6a77c084?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/46bf6a77c084</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-principles]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Tue, 03 May 2022 00:35:12 GMT</pubDate>
            <atom:updated>2022-05-03T00:35:12.612Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID —D — Dependency Inversion Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*NxW-k2fkPb5QUIeQnPmSUA.png" /></figure><p>O <strong>SOLID</strong> é um acrônimo criado por <strong>Michael</strong> <strong>Feathers</strong> após a observação dos princípios da programação orientada a objetos e design de código.</p><p>Neste artigo irei abordar somente a quinta letra do acrônimo <strong>SOLID</strong>, o <strong>D</strong>— <strong>Dependency Inversion Principle</strong>. Além de abordar o seu conceito, irei mostrar um exemplo prático de violação deste princípio e um exemplo de aplicação. Para isto, irei utilizar como base para os exemplos a linguagem <strong>C#</strong>.</p><h3>DIP— Dependency Inversion Principle</h3><p>O princípio da inversão de dependência segue a seguinte premissa: &quot;Dependa de abstrações, não de classes concretas&quot;. Mas afinal de contas, o que isso quer dizer?</p><p>Bom, isso quer dizer que ao invés de você gerar um acoplamento entre classes, utilizando instâncias concretas para a execução de funções e métodos, use uma abstração para executar a rotina que você deseja. Assim, você irá diminuir o acoplamento entre as classes, e além disso, você dará a classe uma &quot;ferramenta de trabalho&quot;, da qual ela fará uso. Podemos utilizar como exemplo a imagem deste artigo… Imagine que toda abstração que é injetada dentro do construtor de sua classe, é uma ferramenta, e ao fazer a injeção desta abstração, você permite com que sua classe utilize essa ferramenta para realizar alguma ação.</p><p>Depender de abstrações nos dá uma maior flexibilidade, pois podemos trabalhar conceitos importantes da orientação à objetos, como por exemplo o polimorfismo, e assim somos capazes de redefinir métodos e funções de acordo com sua responsabilidade ou característica.</p><p>Vamos aos exemplos…</p><h3>Exemplo de Violação</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8360f6805ef8f1dadb206f7c50d62429/href">https://medium.com/media/8360f6805ef8f1dadb206f7c50d62429/href</a></iframe><p>Neste exemplo de violação estamos dependendo diretamente da classe concreta. Estamos utilizando sua instância para executar a ação implementada no método <strong>Use()</strong>.</p><h3>Exemplo de utilização do princípio</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0373ef306a9bd826404cac02c64dfe59/href">https://medium.com/media/0373ef306a9bd826404cac02c64dfe59/href</a></iframe><p>Já neste exemplo, estamos fazendo a injeção da ferramenta através do construtor da classe. A ferramenta é um item abstrato, podendo ser qualquer tipo de ferramenta… E como podemos ver no exemplo, podemos passar o martelo (Hammer) para o pedreiro (Bricklayer) via injeção de dependência e ele será capaz de quebrar a parede. Já para o lenhador (Lumberjack), podemos passar a serra (Saw) e ele conseguirá cortar a madeira.</p><h3>Conclusão</h3><p>A utilização do <strong>DIP </strong>nos traz flexibilidade para solucionar os problemas utilizando a abstração aliada ao polimorfismo. Com isso, podemos reduzir drasticamente a duplicidade de código e a complexidade da implementação.</p><p>Espero ter contribuído de alguma forma para sua carreira profissional! =)</p><p>Até mais!</p><p><strong><em>In God I Trust!!!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46bf6a77c084" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID — I — Interface Segregation Principle]]></title>
            <link>https://guilherme-rmendes95.medium.com/solid-i-interface-segregation-principle-6365e139e4ed?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6365e139e4ed</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[interface-segregation]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[solid]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Tue, 26 Apr 2022 23:47:43 GMT</pubDate>
            <atom:updated>2022-04-27T02:58:26.775Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID — I — Interface Segregation Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/1*oGSfN8N3pNqPsKL54sHwAQ.png" /></figure><p>O <strong>SOLID</strong> é um acrônimo criado por <strong>Michael</strong> <strong>Feathers</strong> após a observação dos princípios da programação orientada a objetos e design de código.</p><p>Neste artigo irei abordar somente a quarta letra do acrônimo <strong>SOLID</strong>, o I— <strong>Interface Segregation Principle</strong>. Além de abordar o seu conceito, irei mostrar um exemplo prático de violação deste princípio e um exemplo de aplicação. Para isto, irei utilizar como base para os exemplos a linguagem <strong>C#</strong>.</p><h3>ISP — Interface Segregation Principle</h3><p>O <strong>Princípio de Segregação de Interfaces </strong>nos diz o seguinte: <strong>&quot;Interfaces específicas são melhores do que interfaces de uso geral&quot;</strong>, mas o que isso quer dizer?</p><p>Bom, sabe aquela interface que contém várias assinaturas de métodos gerais? Ela está ferindo <strong>ISP</strong>. Quando realizamos a implementação dessa interface que está &quot;lotada&quot; de métodos que não são de uso específicos para uma determinada classe, somos obrigados a implementa-los por conta do contrato que foi estabelecido entre a classe e a interface, mesmo que estes métodos não sejam utilizados. E qual o malefício disso?</p><p>O malefício é que iremos trabalhar com uma complexidade maior, com classes menos coesas e vamos dificultar o trabalho de manutenção e ciclo de vida de nosso software, pois a cada alteração na assinatura do método dentro da interface, teremos que alterar em todas as classes que fazem a sua implementação, o que falando de uma aplicação com um tamanho considerável, é inviável.</p><p>Agora vamos aos exemplos de violação e aplicação do princípio…</p><h3>Exemplo de Violação</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd3136351dfbe37d49a0dbbd747a0ae9/href">https://medium.com/media/bd3136351dfbe37d49a0dbbd747a0ae9/href</a></iframe><p>Neste exemplo conseguimos observar que a interface <strong>IService</strong> fornece métodos que são de escopos diferentes, fazendo com que a classe <strong>CustomerService</strong> implemente métodos relacionados a produto, o que não faz sentido. E o mesmo serve para a classe <strong>ProductService</strong> que também implementa métodos que não fazem parte do seu contexto.</p><h3>Exemplo de utilização do princípio</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b8f16e557d9c37db62879de34c42f30/href">https://medium.com/media/1b8f16e557d9c37db62879de34c42f30/href</a></iframe><p>Já aqui neste exemplo, conseguimos notar que a especialização da interface deixa nosso código mais coeso, pois conseguimos restringir o contexto de sua utilização para classes que de fato fazem sentido implementa-la.</p><h3>Conclusão</h3><p>A utilização do <strong>ISP </strong>não só garante que nosso código seja coeso e de fácil manutenção, mas também faz com que haja uma melhor segregação de responsabilidades, o que é fantástico para reaproveitamento de código.</p><p>Espero ter contribuído de alguma forma para sua carreira profissional! =)</p><p>Até mais!</p><p><strong><em>In God I Trust!!!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6365e139e4ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SOLID — L — Liskov Substitution Principle]]></title>
            <link>https://guilherme-rmendes95.medium.com/solid-l-liskov-substitution-principle-84c2c774ddd6?source=rss-b86c6ac07fd8------2</link>
            <guid isPermaLink="false">https://medium.com/p/84c2c774ddd6</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Guilherme Ramos Mendes]]></dc:creator>
            <pubDate>Tue, 26 Apr 2022 00:29:04 GMT</pubDate>
            <atom:updated>2022-04-26T00:29:04.325Z</atom:updated>
            <content:encoded><![CDATA[<h3>SOLID — L — Liskov Substitution Principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tp_pSFwg5o9Ejxczg9LrQw.png" /></figure><p>O <strong>SOLID</strong> é um acrônimo criado por <strong>Michael</strong> <strong>Feathers</strong> após a observação dos princípios da programação orientada a objetos e design de código.</p><p>Neste artigo irei abordar somente a terceira letra do acrônimo <strong>SOLID</strong>, o <strong>L</strong>— <strong>Liskov Substitution Principle</strong>. Além de abordar o seu conceito, irei mostrar um exemplo prático de violação deste princípio e um exemplo de aplicação. Para isto, irei utilizar como base para os exemplos a linguagem <strong>C#</strong>.</p><h3>LSP — Liskov Substitution Principle</h3><p>O <strong>Principio de Substituição de Liskov (LSP)</strong>, criado por <strong>Barbara Liskov</strong>, diz: <strong>&quot;Qualquer sub-classe pode ser substituída pela super-classe da qual ela é derivada&quot;</strong>.</p><p>O <strong>LSP </strong>tem como intuito alertar e ajudar na utilização do recurso de Herança das linguagens orientadas a objeto.</p><p>Um exemplo de violação deste princípio é aquela história do Pato…<br><strong>&quot;Se parece com um pato, faz som de pato, nada como um pato, mas precisa de baterias, certamente você tem uma abstração problemática&quot;</strong></p><p>Vemos claramente nesta frase que se estamos utilizando a herança e não podemos fazer a substituição da sub-classe pela super-classe da qual ela deriva, sem quebrar o funcionamento do software, estamos utilizando o recurso erroneamente.</p><p>Vamos aos exemplos de código…</p><h3>Exemplo de Violação</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e9813ea566aa0ebff9081b29a010bb1e/href">https://medium.com/media/e9813ea566aa0ebff9081b29a010bb1e/href</a></iframe><p>Como podem ver, a classe <strong>ToyEagle</strong> está herdando da classe <strong>Bird</strong>, mas não possui o comportamento de voo, pois é um brinquedo. Quando o método <strong>Fly()</strong> é acionado, se estoura uma exceção alertando que a Águia de brinquedo não voa. Este é um exemplo de má utilização da Herança.</p><h3>Exemplo de utilização do princípio</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e1428461a916139e6ca5c4cf0e4915d8/href">https://medium.com/media/e1428461a916139e6ca5c4cf0e4915d8/href</a></iframe><p>Já nesse caso temos a especificação de cada sub-classe, cada uma deriva de uma super-classe com a sua real natureza.</p><h3>Conclusão</h3><p>A utilização do <strong>LSP </strong>nos ajuda a fazer a utilização do recurso de Herança da forma correta e garantir uma maior flexibilidade em nossa aplicação, pois com sua utilização é possível utilizar a abstração de itens de mesma natureza, sem depender de sua implementação concreta.</p><p>Espero ter contribuído de alguma forma para sua carreira profissional! =)</p><p>Até mais!</p><p><strong><em>In God I Trust!!!</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84c2c774ddd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>