O framework web do Django tem uma arquitetura model-view-template (MVT), o que o torna o único framework que você precisará para criar um site ou aplicativo web completo. Essa estrutura Python permite criar modelos que geram bancos de dados e renderizam modelos HTML dinâmicos para a interface do usuário usando visualizações.

O poder do Django não é segredo; é rápido, confiável, escalável e seguro. A confiabilidade, assim como a escalabilidade deste software, depende de sua arquitetura MVT. E neste artigo, você aprenderá exatamente como funciona a arquitetura MVT do Django.

Qual é o modelo do Django?

O modelo na arquitetura MVT do Django define a estrutura e o comportamento dos dados que você deseja armazenar em seu site. Cada modelo Django que você cria gera uma tabela de banco de dados correspondente, onde cada atributo do modelo se torna um campo na tabela.

Continuando com a configuração do nosso artigo introdutório sobre Django, você pode criar um modelo para os vendedores. Um vendedor pode ter um modelo de vendedor com informações pessoais, como nome e detalhes de contato, e um modelo relacionado para os itens que cada vendedor vende.

A Estrutura de Arquivos do Projeto Django de Amostra Existente

meu site/
 meu site/
 _pycache_
 _init_.py
 asgi.py
 configurações.py
 urls.py
 wsgi.py
 vendedores/
 migração
 _init_.py
 admin.py
 apps.py
 modelos.py
 teste.py
 views.py
 db.sqlite3
 manage.py

Criando Modelos Django

Se você procurar na seção de aplicativos dos vendedores na estrutura de arquivos acima, verá um arquivo chamado modelos.py. É aqui que você criará todos os seus modelos Django para a seção de vendedores do seu site. Cada modelo que você criar será uma subclasse de API de modelo do Django, e é por isso que cada Django gerado modelos.py arquivo tem uma importação de modelos padrão.

O arquivo models.py

Dos modelos de importação do django.db
# Crie seus modelos aqui.
classe Vendedor (modelos. Modelo):
first_name = modelos. CharField (max_length=30)
last_name = modelos. CharField (max_length=30)
contact_number = modelos. CharField (max_length=30)
classe Produto (modelos. Modelo):
vendedor = modelos. ForeignKey (Vendedor, on_delete=models. CASCATA)
item_name = modelos. CharField (max_length=100)
item_qantity = modelos. Campo inteiro()
item_price = modelos. DecimalField (max_digits=9, decimal_places=2)
item_description = modelos. Campo de texto()

O código acima é uma cópia do conteúdo atualizado do model.py Arquivo. O arquivo agora cria dois modelos — Vendedor e Produto. Esses modelos compartilham um relacionamento um-para-muitos, onde um vendedor pode ter muitos produtos à venda. Assim, o modelo Produto tem um chave estrangeira do vendedor e um on_delete atributo definido como modelos. CASCATA, o que significa que, ao excluir um vendedor, você excluirá automaticamente todos os produtos que tenham esse chave primária como um chave estrangeira.

Relacionado: Aprenda Python e Django Hoje Com Esses Cursos Incríveis Você também pode notar que cada um dos modelos no código acima não possui uma chave primária. Isso porque o Django irá gerar automaticamente um chave primária se você não criar um explicitamente.

Antes de poder usar qualquer modelo que você criar, você precisará dizer ao Django onde encontrá-lo. Para fazer isso, você precisará navegar até o configurações.py arquivo e insira o nome do módulo que contém o modelos.py arquivo, no INSTALLED_APP seção.

No projeto de amostra para este artigo, o modelos.py arquivo está no módulo dos vendedores. Portanto, a atualização INSTALLED_APP seção terá a seguinte redação:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'vendedores',
]

Com o código acima, os modelos no aplicativo dos vendedores agora estão visíveis no site do Django, e agora você pode passar para as migrações.

A realização de migrações é importante porque esse processo é uma maneira de espalhar as alterações feitas em seus modelos para o esquema de banco de dados correspondente. Portanto, toda vez que você fizer alterações em seu modelo, precisará realizar o processo de migração, que envolve duas etapas.

O primeiro passo é fazer migrações, que é um comando que cria migrações com base nas alterações detectadas no modelos.py Arquivo. Para iniciar o processo de migração, você precisará abrir seu terminal, navegar até o diretório que contém seu projeto Django e iniciar o servidor usando o seguinte comando:

python manage.py runserver

Com o servidor rodando em um terminal, abra um novo terminal e digite o seguinte comando:

python manage.py makemigrations

Após a execução, o terminal produzirá a seguinte saída:

Migrações para 'vendedores':
vendedores\migrações\0001_initial.py
- Criar modelo de vendedor
- Criar modelo de produto

A saída acima indica claramente que agora você tem migrações para dois modelos: o vendedor e o produto. Agora, se você navegar até a pasta de migração no módulo de seus vendedores, verá que agora tem um novo arquivo chamado 0001_initial.py. Nesse arquivo, você encontrará as migrações que acabou de criar.

O arquivo 0001_initial.py

# Gerado por Django 3.2.9 em 26/02/2022 16:06
das migrações de importação do django.db, modelos
importar django.db.models.deletion
classe Migração (migrações. Migração):
inicial = Verdadeiro
dependências = [
]
operações = [
migrações. CriarModelo(
nome='Vendedor',
campos=[
('id', modelos. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', models. CharField (max_length=30)),
('last_name', models. CharField (max_length=30)),
('contact_number', models. CharField (max_length=30)),
],
),
migrações. CriarModelo(
nome='Produto',
campos=[
('id', modelos. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('item_name', models. CharField (max_length=100)),
('item_qantity', models. Campo inteiro()),
('item_price', models. DecimalField (decimal_places=2, max_digits=9)),
('item_description', models. Campo de texto()),
('vendedor', modelos. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]

Cada vez que você faz uma nova migração, a pasta de migração gera uma nova versão desse arquivo.

A segunda etapa do processo de migração é finalmente migrar os modelos. Isso significa que você sincroniza o estado do banco de dados com o modelos.py arquivo, usando as migrações que você acabou de criar no 0001_initial.py Arquivo. Você pode concluir este processo (enquanto o servidor ainda está em execução) com o seguinte comando:

python manage.py migrar

O que é o template do Django?

Os templates são uma forma de gerar HTML dinamicamente para o seu projeto Django. Cada template do Django tem o .html extensão e uma combinação de conteúdo estático e dinâmico. Os templates do Django possuem uma sintaxe única que inclui novas formas de criar variáveis ​​e tags em um documento HTML.

Criando um modelo Django

Para introduzir modelos no site de comércio eletrônico de exemplo deste artigo, você precisará criar um novo diretório no módulo de vendedores. Esse novo diretório chamado "templates" será o lar de todos os documentos HTML do aplicativo dos vendedores, começando pela página inicial.

O arquivo sellers_home.html

Bem-vindos Vendedores!

Depois de criar seus templates, você precisará torná-los visíveis para o Django adicionando o diretório de seus templates ao diretório MODELOS seção do configurações.py Arquivo. O atualizado MODELOS seção terá a seguinte aparência:

MODELOS = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# novo código que aponta para a localização dos templates
BASE_DIR / 'vendedores' / 'modelos'
],
'APP_DIRS': Verdadeiro,
'OPÇÕES': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Agora que o Django sabe onde encontrar os templates para o site, você pode ir em frente e renderizá-los para a UI usando a view.

Qual é a visão do Django?

A View é a segunda camada da arquitetura MVT do Django, um template é inútil a menos que uma view o renderize para a UI. A visualização é responsável por aceitar solicitações da web e retornar as respostas apropriadas (incluindo modelos). Em sua forma mais básica, a visão é uma função Python, armazenada no view.py arquivo do seu projeto Django.

Criando Visualização Django

O view.py O arquivo está no módulo sellers do projeto Django de amostra. Quando um vendedor visita seu site, você deseja que ele vá para a página inicial de um vendedor. Esta página inicial você criará usando um modelo HTML, muito parecido com o criado na seção de modelos acima.

O arquivo view.py

de django.shortcuts importar renderização
índice def (solicitação):
return render (solicitação, 'sellers_home.html')

A visualização acima recebe uma solicitação e retorna o modelo HTML dos vendedores. Assim, cada vez que um usuário visita (ou solicita) http://127.0.0.1:8000/sellers/ eles verão a página inicial dos vendedores. Isso depois de criar um urls.py arquivo no módulo de vendedores.

O arquivo urls.py dos vendedores

do caminho de importação do django.urls
a partir de. importar visualizações
padrões de url = [
path('', views.index, name='index'),
]

E inclua o caminho para o módulo dos vendedores urls.py arquivo no urls.py arquivo localizado no diretório principal do Django.

O arquivo urls.py do site

do administrador de importação do django.contrib
from django.urls import include, path
padrões de url = [
path('vendedores/', include('vendedores.urls')),
path('admin/', admin.site.urls),
]

Agora que a visualização está configurada, você pode garantir que o servidor Django ainda esteja em execução e navegar para http://127.0.0.1:8000/sellers/ no seu navegador para ver a página inicial dos vendedores.

A página inicial dos vendedores

Arquitetura MVT do Django vs. Arquitetura MVC

A arquitetura MVT do Django é bem diferente da arquitetura MVC popular.

A seção de modelo da arquitetura MVT opera da mesma maneira que a visualização na arquitetura MVC, enquanto a visualização na arquitetura MVT exibe qualidades semelhantes ao controlador no MVC arquitetura. No entanto, os modelos em ambas as arquiteturas funcionam de forma idêntica.

Uma introdução à arquitetura MVC: exemplos explicados

Aplique os princípios de design do Model-View-Controller aos seus próprios programas para obter resultados imediatos. Veja como começar.

Leia a seguir

Sobre o autor