Bem vindo à ModularBr

Descubra como implementar uma estrutura ModularBr em seus projetos Delphi.

Fluxo

O que é ModularBr?

O ModularBr for Delphi propõe uma solução para dois problemas de forma modularizadas em desenvolvimento de APIs em delphi:

• ROUTES : Módulos por rota

• BINDS : Injeção de dependência

• IMPORTS : Importar Binds exportados por outros módulos

• ROUTEHANDLERS : Redirecionador de rotas

• EXPOSTEDBINDS : Exportar Binds para outras módulos

O ModularBr é um framework que oferece uma arquitetura de desenvolvimento modular para aplicações, permitindo a separação de recursos em módulos independentes e interconectados. Com essa arquitetura, é possível obter benefícios como a organização do código-fonte, maior escalabilidade, manutenção mais fácil e clara, testabilidade mais eficiente e um processo de desenvolvimento mais ágil.

Com a modularização, é possível desenvolver e testar cada módulo de forma independente, além de reutilizar módulos em diferentes projetos. Essa abordagem permite que a equipe de desenvolvimento trabalhe em diferentes áreas da aplicação simultaneamente, aumentando a produtividade e reduzindo o tempo de desenvolvimento.

O ModularBr oferece diversas funcionalidades úteis para desenvolvedores, como a injeção de dependência e o gerenciamento de módulos por rotas. A injeção de dependência é uma técnica que permite a fácil troca de implementações de uma classe durante a execução da aplicação ou uma requisição em uma API, tornando o código mais flexível e modular. Já o gerenciamento de rotas permite a instanciação de módulos de forma organizada, disponibilizando recursos que podem ser usados de forma simples, gerenciável e desacoplada. Além disso, o ModularBr permite a interceptação de rotas, possibilitando a validação de permissões e autenticação de usuários antes de permitir o acesso a determinadas rotas. Essas funcionalidades são fundamentais para garantir a escalabilidade e manutenibilidade de projetos mais complexos.

Veja as vantagens de utilizar uma arquitetura modular em seu projeto:

Maior compreensão dos recursos

Ao dividir o escopo de recursos, é possível ter uma visão mais clara de cada parte do sistema, o que ajuda na manutenção e evolução do projeto.

Menos mudanças que podem quebrar o sistema

Ao gerenciar cada recurso de forma independente, mudanças em um módulo não afetam os outros, reduzindo o risco de quebra do sistema.

Adição de novos recursos sem conflitos

Com a modularização, é possível adicionar novos recursos sem conflitos, pois cada módulo é independente.

Menos pontos cegos na regra principal do negócio

Ao separar os recursos em módulos, é possível ter uma visão mais clara da regra principal do negócio e evitar pontos cegos.

Maior rotatividade de desenvolvedores

Com uma arquitetura modular, é mais fácil para novos desenvolvedores entenderem o sistema e começarem a trabalhar em novas funcionalidades.

Código mais legível e prolongamento da vida útil do projeto

A separação de recursos em módulos torna o código mais legível e facilita a manutenção, prolongando a vida útil do projeto.

Um exemplo prático de uma arquitetura modular é um modelo MVC padrão com 3 recursos (Autenticação, Página Inicial e Produtos). Com a modularização, cada recurso pode ser gerenciado de forma independente, sem interferir nas outras partes do sistema.

Típico MVC

projeto
├── models                      # Todos os modelos
│   ├── auth_model.pas          
│   ├── home_model.pas          
│   └── product_model.pas       
├── controllers                 # Todos os controladores
│   ├── auth_controller.pas     
│   ├── home_controller.pas     
│   └── product_controller.pas  
├── views                       # Todas as visualizações
│   ├── auth_form.pas           
│   ├── home_form.pas           
│   └── product_form.pas        
├── core                        # Ferramentas e utilidades
│   ├── database.pas            
│   ├── utils.pas               
│   └── validation.pas          
├── app.pas                     # Classe principal contendo a lógica da app
└── main.pas                    # Executa a aplicação

A cima, apresentamos uma estrutura comum utilizando o padrão MVC, o qual é bastante útil em praticamente todos os tipos de aplicativos.

Estrutura dividida por escopo

projeto
├── modules                       # Todos os módulos
│   ├─ auth                       # MVC da autenticação
│   │  ├── auth_model.pas
│   │  ├── auth_controller.pas
│   │  └── auth_form.pas
│   ├─ home                       # MVC da página inicial
│   │  ├── home_model.pas
│   │  ├── home_controller.pas
│   │  └── home_form.pas
│   └─ product                    # MVC de produtos
│      ├── product_model.pas
│      ├── product_controller.pas
│      └── product_form.pas
├── core                          # Ferramentas e utilidades
│   ├── database.pas              
│   ├── utils.pas                 
│   └── validation.pas           
├── app.pas                       # Classe principal contendo a lógica da app
└── main.pas                      # Executa a aplicação

O que fizemos nessa estrutura foi continuar usando o MVC, mas desta vez por escopo. Isso significa que cada funcionalidade tem seu próprio MVC e essa abordagem simples resolve muitos problemas de escalabilidade e manutenção. Chamamos essa abordagem de "Estrutura Inteligente". Mas duas coisas ainda eram globais e entravam em conflito com a própria estrutura, então criamos o ModularBr para resolver esse impasse.

Em resumo: o ModularBr é uma solução para modularizar o sistema de roteamento e injeção de dependência, tornando cada escopo ter suas próprias rotas e injeções independentes de qualquer outro fator na estrutura. Criamos objetos para agrupar as Rotas e Injeções e os chamamos de Módulos.

Pronto para começar?

O ModularBr não é apenas genial por fazer algo incrível, como componentizar rotas e injeções de dependência, mas também por conseguir fazer tudo isso de maneira simples!

Vá para o próximo tópico e comece sua jornada em direção a uma estrutura inteligente.