Coesão e Acoplamento: dois conceitos fundamentais da arquitetura de software

Ao desenvolver uma aplicação, é comum focarmos em funcionalidades, regras de negócio e requisitos. Mas existe outra preocupação importante: como organizamos o código e como as partes do sistema se relacionam?

É nesse ponto que dois conceitos ganham importância: coesão e acoplamento.

Embora sejam conceitos simples, eles influenciam diretamente a manutenibilidade, a testabilidade e a capacidade de evolução de uma aplicação.

O que é coesão?

Coesão representa o quanto as responsabilidades de um módulo estão relacionadas entre si.

Um módulo com alta coesão possui um propósito bem definido. Suas funcionalidades trabalham em conjunto para cumprir uma responsabilidade específica.

Imagine um serviço responsável pelo gerenciamento de usuários. Ele pode conter operações como:

• Cadastrar um usuário.
• Atualizar seus dados.
• Consultar suas informações.
• Desativar uma conta.

Essas operações estão relacionadas ao mesmo domínio, o que contribui para uma boa coesão.

Agora imagine que esse mesmo serviço também seja responsável por processar pagamentos e gerar relatórios financeiros.

As responsabilidades começam a se distanciar, tornando o componente mais difícil de compreender e modificar.

A ideia é manter juntas as funcionalidades que pertencem ao mesmo propósito.

O que é acoplamento?

Acoplamento representa o grau de dependência entre diferentes módulos ou componentes.

Quando um componente depende diretamente dos detalhes internos de outro, mudanças na implementação podem gerar impactos em diferentes partes do sistema.

Considere o seguinte exemplo em TypeScript:

class MySQLDatabase {
  save(data: string): void {
    console.log("Salvando no MySQL:", data);
  }
}

class UserService {
  private database = new MySQLDatabase();

  createUser(name: string): void {
    this.database.save(name);
  }
}

Nesse exemplo, UserService cria diretamente uma instância de MySQLDatabase.

Isso significa que o serviço está acoplado a uma implementação específica. Se precisarmos trocar o banco de dados ou utilizar uma implementação em memória nos testes, será necessário modificar a estrutura ou criar mecanismos adicionais para acomodar essa mudança.

Uma alternativa é depender de uma abstração:

interface Database {
  save(data: string): void;
}

class MySQLDatabase implements Database {
  save(data: string): void {
    console.log("Salvando no MySQL:", data);
  }
}

class UserService {
  constructor(private database: Database) {}

  createUser(name: string): void {
    this.database.save(name);
  }
}

Agora, UserService não precisa conhecer a implementação concreta do banco de dados.

Podemos fornecer diferentes implementações que respeitem o contrato definido pela interface.

Isso reduz o acoplamento com uma implementação específica e facilita a substituição de dependências.

Vale destacar que a interface, sozinha, não elimina o acoplamento. O serviço ainda depende do contrato Database, mas não precisa depender de uma implementação concreta.

Como esses conceitos se complementam?

Coesão e acoplamento analisam aspectos diferentes da organização do software.

• Alta coesão: as responsabilidades de um módulo fazem sentido juntas.
• Baixo acoplamento: os módulos possuem dependências controladas e não precisam conhecer detalhes desnecessários uns dos outros.

O objetivo não é eliminar todas as dependências. Sistemas precisam de colaboração entre componentes para funcionar.

O importante é organizar essa colaboração de maneira que uma mudança não provoque uma sequência desnecessária de alterações em toda a aplicação.

Isso significa que precisamos criar mais abstrações?

Não necessariamente.

Adicionar interfaces, classes e camadas sem uma necessidade concreta pode aumentar a complexidade em vez de reduzi-la.

Uma aplicação pequena pode funcionar muito bem com uma estrutura simples. Conforme surgem novas responsabilidades e necessidades de evolução, determinadas abstrações podem começar a fazer sentido.

A arquitetura deve resolver problemas reais, não criar estruturas apenas para seguir um padrão.

Conclusão

Coesão e acoplamento são fundamentos importantes para construir sistemas que possam evoluir de forma sustentável.

Ao organizar um módulo, pergunte se suas responsabilidades realmente pertencem juntas.

Ao criar uma dependência, avalie se o componente precisa conhecer uma implementação específica ou se pode trabalhar com um contrato mais estável.

Essas decisões parecem pequenas, mas podem fazer uma diferença significativa conforme a aplicação cresce.

Uma boa arquitetura não é aquela que elimina a complexidade, mas aquela que evita espalhá-la desnecessariamente pelo sistema.