12. Conclusão
Este documento descreveu o desenvolvimento de uma aplicação web MVC com o framework [Django]: uma aplicação cujas páginas HTML são geradas pelo servidor por meio de templates do [Django], sem um framework [JavaScript] no navegador. Ele seguiu passo a passo o curso de [Symfony], que por sua vez se baseia nos cursos de [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] e [NestJS]: das views e do roteamento aos templates, formulários, internacionalização, segurança e acesso a dados, seguidos de um estudo de caso completo.
Os mesmos 28 exemplos e a mesma aplicação foram assim escritos com sete frameworks: em [TypeScript], em [C#], em [Java], duas vezes em [PHP] e duas vezes em [Python]. Os conceitos são os mesmos; só os nomes e os mecanismos diferem. As correspondências entre [Symfony] e [Django]:
[Symfony] | [Django] |
núcleo ([src/Kernel.php]), bundles, contêiner de serviços, injeção de dependência | configurações ([config/settings.py]), aplicações ([INSTALLED_APPS]), módulos importados, providers ([functools.cache]) |
[composer.json], pasta [vendor], [php bin/console] | [requirements.txt], ambiente virtual ([.venv]), [python manage.py] |
arquivo [.env], pasta [config/packages] (arquivos YAML), [%env(...)%] | arquivo [config/settings.py] (em [Python]), variáveis de ambiente ([os.environ]), arquivo [.env] lido por nós |
[#[Route]] atributos dos controllers | listas [urlpatterns] ([path], [re_path], [include]), rotas nomeadas, [app_name] |
[render], [redirectToRoute], [generateUrl]; [path] nas views | [render], [redirect], [reverse]; [{% url %}] nos templates |
objeto [Request], [requirements] ([{id<\d+>}]), argument resolvers, [#[MapQueryString]] | objeto [HttpRequest] ([GET], [POST], [headers], [COOKIES]), conversores ([<int:id>]), formulários como validadores |
componente Validator (restrições por atributos), componente Form (tipos, [handleRequest], [isValid]) | [django.forms] formulários (campos, validadores, [clean], [error_messages], [is_valid], [cleaned_data]) |
tema de formulário [Bootstrap] 5 | mecanismo de renderização ([FORM_RENDERER]), template de campo, [as_field_group] |
views [Twig], [{{ }}], [{% for %}], [{% if %}] | Templates da DTL, [{{ }}], [{% for %}] ... [{% empty %}], [{% if %}] |
[{% extends %}] e blocos, [{% include %}], macros | [{% extends %}] e blocos, [{% include %}], fragmentos nomeados ([{% partialdef %}]) |
variáveis globais, extensões [Twig] (funções, filtros) | context processors, bibliotecas de tags ([templatetags]: filtros, simple tags, inclusion tags) |
mensagens flash ([addFlash], [app.flashes]), sessões baseadas em arquivos | [messages] aplicação (cookie assinado), sessões (arquivos, cookie assinado, banco de dados...) |
listeners de eventos do kernel ([kernel.request], [kernel.controller], [kernel.response]...) | middleware ([__call__], [process_view], [process_exception]), sinais ([request_started], [request_finished]) |
fones de ouvido: [kernel.exception], [HttpException], [createNotFoundException] | [Http404], [PermissionDenied], [BadRequest], views [handler404]..., [process_exception] |
firewalls, authenticators, [access_control], [#[IsGranted]], voters | middleware de autenticação e de controle de acesso escritos por nós, decoradores; ou a aplicação [django.contrib.auth] |
token anti-CSRF do componente Form, [csrf_token()], [isCsrfTokenValid] | [CsrfViewMiddleware] middleware, [{% csrf_token %}] tag, [CSRF_FAILURE_VIEW] (resposta 403, ou 419 na nossa aplicação) |
componente [RateLimiter] | um limitador escrito sobre o cache |
Arquivo [translations] (YAML, ICU), filtro [trans], [TranslatorInterface] | arquivo [locale] ([gettext]: [.po], [.mo]), [gettext], [gettext_lazy], [ngettext], [{% translate %}], [{% blocktranslate %}] |
[intl] extensão: [IntlDateFormatter], [NumberFormatter] | Formatação com base no idioma ativo (filtro [date], [floatformat]), [Babel] |
componente Cache (PSR-6 e contratos), componente Lock | cache do [Django] ([LocMemCache], [FileBasedCache]...), [get_or_set] |
[Doctrine]: entidades Data Mapper, entity manager, DQL e QueryBuilder | ORM do [Django]: modelos Active Record, managers ([objects]), [QuerySet], [select_related], [F()] |
[wrapInTransaction(...)], [flush] | [transaction.atomic()], [select_for_update()] |
[#[ORM\Version]], gerenciado pelo [Doctrine] ([OptimisticLockException]) | [update()], dependente da versão ([filter(version=...)]), escrito na camada DAO |
[php -S localhost:8000 -t public], ou [symfony server:start] | [python manage.py runserver] |
Em relação ao [Symfony], os pontos principais a observar são:
- a aplicação [Django] é carregada uma única vez, quando o servidor inicia, e depois permanece na memória e processa todas as requisições (exemplo 01): os objetos criados na inicialização (configurações, rotas, middleware, serviços) são compartilhados por todas as requisições. É simples e rápido, mas exige distinguir o que pertence à aplicação (compartilhado e, portanto, sem estado específico de uma requisição) do que pertence a uma requisição (o objeto [request], as variáveis locais das views) e lembrar que um servidor de produção executa vários processos, que compartilham apenas o que é armazenado fora deles (o banco de dados, o cache em arquivos);
- sem contêiner de serviços: os serviços são módulos [Python] que são importados, e funções provider que criam um objeto único na primeira requisição. As dependências de um módulo são visíveis em seus arquivos [import]; substituí-las para fins de teste é feito por meio de uma configuração (exemplo 06);
- A configuração é um arquivo [Python] ou [config/settings.py] : uma sequência de atribuições que podem ser calculadas, comentadas ou divididas. O comando [python manage.py diffsettings] exibe o que difere dos valores padrão;
- O processamento de uma requisição passa por uma lista de componentes de middleware na ordem especificada na lista [MIDDLEWARE] e depois na ordem inversa para a resposta: é aqui que são tratadas as configurações de idioma, a proteção anti-CSRF, a autenticação, o controle de acesso e as páginas de erro. O mecanismo é mais simples que os eventos do kernel no [Symfony]: a ordem da lista é a ordem de execução;
- As views são funções simples que recebem uma requisição e retornam uma resposta; os decoradores ([@require_POST], [@registration_pass_required]) as envolvem para acrescentar controle. Escrevemos várias delas, e até uma classe cujos métodos são views ([PersonManagement]), sem exigir nada específico do [Django];
- Os formulários são objetos, descritos por classes: campos, conversão de valores, validadores, reexibição da entrada e mensagens de erro. Eles são renderizados por templates que podem ser substituídos (uma engine de renderização, um template de campo): os campos de toda a aplicação são renderizados da mesma forma, com as classes do [Bootstrap] e atributos de acessibilidade;
- O [Django] já vem “pronto para uso”: sessões, mensagens, traduções, cache, proteção anti-CSRF, arquivos estáticos, ORM — tudo está incluído, documentado em um só lugar, sem nenhuma instalação adicional. Acrescentamos apenas três bibliotecas: o driver [MySQL], [PyJWT], e [bcrypt]. A abrangente aplicação de autenticação [django.contrib.auth] ficou de fora: o banco de dados do estudo de caso tem seus próprios usuários, e queríamos tokens JWT, como nas outras versões da aplicação. Escrever o código de autenticação do zero, em cerca de cem linhas, mostrou exatamente o que ele faz;
- o ORM do [Django] segue o padrão Active Record: um modelo é uma classe ligada a uma tabela, em que cada objeto sabe como se salvar. Mais direto que o Data Mapper do [Doctrine], ele também funciona muito bem com um banco de dados existente ([managed = False], em que os nomes das tabelas e colunas são predefinidos). Seus [QuerySet] tardios, [select_related], as expressões [F()] e as instruções [update()] condicionais permitem escrever consultas eficientes e seguras, e o console do modo de desenvolvimento exibe cada comando SQL enviado ao banco de dados;
- Os templates DTL usam uma linguagem deliberadamente limitada: sem aritmética, sem chamadas de função com parâmetros. Um template só pode exibir os dados que lhe são fornecidos: isso é ao mesmo tempo uma restrição e uma garantia que leva a lógica para as views e os view models. Qualquer informação que falte é adicionada por meio de filtros e tags escritos em [Python]. Os templates escapam automaticamente tudo o que exibem.
O estudo de caso mostra que uma aplicação HTML clássica, sem o [JavaScript] essencial, continua sendo uma solução simples e robusta: cada página é uma URL, o botão “Voltar” do navegador funciona e o servidor controla tudo. O uso mínimo de [JavaScript] (janelas de confirmação) melhora a experiência do usuário sem ser necessário para o funcionamento. [Django] também pode oferecer suporte a aplicações mais interativas sem se afastar de seus templates (com a biblioteca [htmx], por exemplo, os fragmentos nomeados do [Django] 6 funcionam muito bem) ou com um framework [JavaScript] no navegador, ao qual ele fornece uma API JSON ([Django REST framework], [Django Ninja]): isso será abordado em outros documentos.
Para mais informações, consulte a documentação do [Django] (docs.djangoproject.com, traduzida para o francês), em particular as páginas dedicadas a views e URLs, formulários, templates, middleware, internacionalização, ORM e segurança, o seu tutorial (que trata da interface de administração e das migrações, que não são abordadas aqui), o tutorial de [Python] (docs.python.org/fr), e compare esta aplicação com suas aplicações irmãs [Symfony], [Laravel], [Flask], [Spring MVC], [ASP.NET Core MVC] e [NestJS].