Nas partes anteriores, vimos que o acoplamento é inevitável, mas que podemos controlá-lo usando Inversão de Controle. Agora vamos explorar uma técnica que vai um passo além: abstração via plugins.
Isso mesmo: você pode enganar o acoplamento, contornando a dependência direta com um sistema dinâmico e flexível. Chegou a hora de usar tudo que aprendemos para criar sistemas onde partes do comportamento podem ser carregadas, substituídas ou estendidas sem tocar no código principal.
O que é um plugin, na essência?
Um plugin é uma implementação de um contrato. Nada mais.
A diferença é que ele pode ser carregado dinamicamente e registrado em tempo de execução.
Não estamos falando (ainda) de DLLs ou pacotes externos. Estamos falando da ideia central: permitir que comportamentos sejam adicionados ou modificados sem mexer no core do sistema.
Exemplo em Delphi: sistema de relatórios pluginável
Imagine que você tem um sistema que precisa exportar relatórios em vários formatos: PDF, Excel, JSON, XML.
type
IReportPlugin = interface
function GetName: string;
procedure ExportData(Data: TDataSet);
end;
Agora você cria classes que implementam esse contrato:
type
TPDFReport = class(TInterfacedObject, IReportPlugin)
procedure ExportData(Data: TDataSet);
function GetName: string;
end;
TExcelReport = class(TInterfacedObject, IReportPlugin)
procedure ExportData(Data: TDataSet);
function GetName: string;
end;
E em algum lugar central do seu sistema:
var
ReportPlugins: TDictionary<string, IReportPlugin>;
procedure RegisterReport(APlugin: IReportPlugin);
begin
ReportPlugins.Add(APlugin.GetName, APlugin);
end;
Agora, o sistema não precisa mais saber quais relatórios existem. Ele apenas invoca:
ReportPlugins['PDF'].ExportData(MyData);
Isso é ou não é acoplamento?
Claro que é. Mas é um acoplamento por abstração, não por implementação. Você está acoplado ao contrato, não à forma de fazer.
E melhor: você pode registrar novos plugins em tempo de execução. Pode até ler um JSON, criar instâncias dinamicamente e chamar os métodos corretos com RTTI, se quiser ir mais longe.
Benefícios do modelo pluginável
- Extensão sem recompilar
- Modularidade real
- Facilidade para testes A/B ou customizações por cliente
- Possibilidade de marketplace interno (plugins especializados)
Aplicações práticas
- Conversores de dados
- Integrações com sistemas externos
- Lógicas de negócio personalizadas por cliente
- Workflows configuráveis
Quando não usar plugins?
- Quando a extensão não é necessária
- Quando todo o sistema já é conhecido e fechado
- Quando a complexidade do sistema de registro não compensa o ganho
Conclusão
Acoplamento pode ser domado.
Com plugins, você cria um campo de batalha onde o core é blindado, e os comportamentos variáveis ficam fora das trincheiras.
No fim, o objetivo é simples: deixar o sistema inteligente o suficiente para se adaptar sem que você precise reescrever tudo.
Isso não é magia. É arquitetura.
Próximo artigo sugerido: "Interpretação via JSON: plugins configuráveis com dicionários de ações"
