Elegância e simplicidade da implementação de fluent interfaces na Arquitetura de Software

A arquitetura de software é uma disciplina em constante evolução, e uma das abordagens que tem ganhado destaque é a utilização de fluent interfaces. Este padrão de projeto não apenas proporciona clareza no código, mas também se destaca por sua elegância e expressividade.

Origens do Padrão de Projeto Fluent Interface

O conceito de fluent interface foi introduzido por Eric Evans em seu livro "Domain-Driven Design" no início dos anos 2000. Ele propôs uma forma de construir APIs que permitissem a leitura do código de maneira mais próxima da linguagem natural. Essa ideia ganhou força e foi adotada em diversas linguagens de programação.

Problemas Resolvidos pela Fluent Interface

A principal motivação por trás da utilização de fluent interfaces é tornar o código mais legível e expressivo. Muitas vezes, em programação, nos deparamos com chamadas de métodos que, apesar de se relacionarem, possuem uma escrita que não facilita a legibilidade por serem tratados em chamadas diferentes.

O padrão fluent interface visa resolver esse problema, proporcionando uma sintaxe mais fluida e compreensível. O princípio do padrão é permitir que a leitura das chamadas de métodos seja mais legível por meio de uma estratégia que permite a chamada encadeada, gerando a ideia de adição de comportamento. Isso faz com que a leitura do código possua uma semântica mais fluida.

Principais Benefícios:

• Legibilidade Aprimorada: Código mais claro e fácil de entender, promovendo uma leitura natural.
• Expressividade: Facilita a comunicação das intenções do código entre desenvolvedores.
• Encadeamento de Métodos Simples: Possibilita a concatenação de chamadas de métodos de forma intuitiva, simplificando a construção de sequências complexas.

Exemplos de Implementação em Linguagens Populares

Esses exemplos demonstram como a fluent interface é utilizada em práticas comuns, como filtragem, ordenação e projeção de dados, proporcionando um código mais expressivo e fácil de dar manutenção.

C# (LINQ):

csharp
content_copy
var pares = numeros
    .Where(n => n % 2 == 0)
    .OrderBy(n => n)
    .Select(n => n * 2);

C# (Entity Framework):

csharp
content_copy
var produtos = dbContext.Produtos
    .Where(p => p.Categoria == "Eletrônicos")
    .OrderBy(p => p.Preco);

Java:

java
content_copy
List<String> listaNomes = Arrays.asList("Alice", "Bob", "Charlie");
listaNomes.stream()
    .filter(nome -> nome.length() > 4)
    .forEach(System.out::println);

Aplicando Fluent interfaces na prática

Para exemplificar a implementação de Fluent Interfaces, vamos usar um caso muito comum que é a criação de uma camada de validação de entidades. No exemplo abaixo, irei utilizar a linguagem C#, mas o conceito pode ser utilizado por qualquer linguagem, quando aplicável.

Imaginemos uma entidade funcionário e precisamos fazer a validação dos campos da entidade.

csharp
content_copy
public class Funcionario
{
    public string Nome { get; set; }
    public decimal Salario { get; set; }
    public string Endereco { get; set; }
}

A implementação da validação usando Fluent interfaces pode ser feita conforme desenhado abaixo:

csharp
content_copy
public class FluentValidation
{
    private readonly Funcionario _funcionario;
    private readonly decimal _salarioMinimo = 1412.00m;

    private FluentValidation(Funcionario funcionario)
    {
        _funcionario = funcionario;
    }

    public static FluentValidation ParaFuncionario(Funcionario funcionario)
    {
        return new FluentValidation(funcionario);
    }

    public FluentValidation ValidarNome()
    {
        if (string.IsNullOrWhiteSpace(_funcionario.Nome))
        {
            throw new Exception("Nome não pode ser vazio.");
        }
        return this;
    }

    public FluentValidation ValidarSalario()
    {
        if (_funcionario.Salario < _salarioMinimo)
        {
            throw new Exception("Salário abaixo do mínimo permitido.");
        }
        return this;
    }

    public FluentValidation ValidarEndereco()
    {
        // Lógica de validação do endereço
        if (string.IsNullOrWhiteSpace(_funcionario.Endereco))
        {
            throw new Exception("Endereço não pode ser vazio.");
        }
        return this;
    }

    public Funcionario Construir()
    {
        // Lógica de construção do funcionário após todas as validações
        return _funcionario;
    }
}

Com esta implementação podemos escrever uma validação bem mais simples de ser escrita e mais fácil de ser lida, vejamos abaixo:

csharp
content_copy
// Criando um novo funcionário
Funcionario novoFuncionario = new()
{
    Nome = "João",
    Salario = 5000,
    Endereco = "Rua Principal, 123"
};

// Utilizando fluent interfaces para validação
var funcionarioValidado = FluentValidation
    .ParaFuncionario(novoFuncionario)
    .ValidarNome()
    .ValidarSalario()
    .ValidarEndereco()
    .Construir();

// O funcionário agora está validado e pronto para ser utilizado
Console.Write(funcionarioValidado.Nome);

Conclusão

A utilização de fluent interfaces na arquitetura de software não apenas aprimora a legibilidade do código, mas também promove uma comunicação mais clara entre os desenvolvedores. Ao simplificar a escrita e proporcionar uma semântica mais fluida, essa abordagem facilita a compreensão e manutenção do código.

Além disso, promove a eficiência na entrega de soluções robustas, simplificando a escrita e evolução do código. É uma abordagem que, quando aplicada corretamente, eleva a experiência de desenvolvimento, fazendo com que a curva de aprendizado para novos integrantes da equipe seja menor.

---

Tags: #ArquiteturaDeSoftware #FluentInterfaces #DesenvolvimentoDeSoftware #CleanCode