Pesquisa de site

Como funciona a arquitetura MVT do Django: um mergulho profundo em modelos, visualizações e modelos


Django é um framework Python de alto nível. É popular por sua simplicidade e eficiência na construção de aplicativos web robustos.

No coração da arquitetura de Django está o padrão de modela-visualização (MVT). Ter um bom entendimento de como modelos, visualizações e modelos interage é crucial se você deseja aproveitar todo o poder do Django.

Se você é completamente novo no Django ou em um iniciante, este artigo servirá como um guia abrangente, mostrando como esses componentes funcionam e interagem entre si para criar aplicativos da Web dinâmicos.

Para torná -lo ainda mais compreensível, criaremos um aplicativo simples para ajudá -lo a entender melhor a interconectividade desses componentes.

Se você já está animado, vamos direto para isso!

Aqui está o que abordaremos:

  • Pré-requisitos

  • Qual é a arquitetura da MVT?

  • O componente do modelo

  • O componente de visualização

  • O componente de modelo

  • Diagrama mostrando o fluxo de trabalho do MVT

  • Analogia do mundo real de MVT

  • Juntando tudo em um projeto

  • Conclusão

Pré-requisitos

Para acompanhar, você precisa de:

  • Compreensão básica de como funcionam os aplicativos da web, incluindo arquitetura cliente-servidor.

  • Conhecimento básico de Python.

Qual é a arquitetura da MVT?

O padrão MVT é a abordagem do Django para organizar a base de código e o fluxo de trabalho de uma aplicação web. Os componentes que compõem esta arquitetura são o Modelo, a Visualização e o Modelo. Cada componente executa funções específicas e então passa o processo para os outros componentes fazerem as suas.

Vamos dar uma olhada rápida nos componentes com as funções específicas que desempenham:

  • Modelo: Também conhecido como camada de dados, gerencia dados e interage com o banco de dados.

  • Visualizar: também conhecida como camada lógica, atua como intermediária, lida com a lógica e gerencia o fluxo de dados.

  • modelo : Também conhecido como camada de apresentação, ele renderiza o conteúdo HTML na interface do usuário.

Agora que você tem uma idéia sobre os componentes e seus papéis em um aplicativo de Django, examinaremos extensivamente cada componente e como eles interagem na arquitetura.

O componente do modelo

Os modelos gerenciam a estrutura e a interação dos dados em um aplicativo de Django, tornando -os a base dos aplicativos Django devido às dicas de função crítica.

Os modelos Django utilizam um recurso poderoso chamado mapeamento de objetos-relacionais (ORM), que preenche a lacuna entre um banco de dados relacional e o código Python. Ele converte os objetos Python (classes) em tabelas de banco de dados, seus atributos em colunas e instâncias em linhas nessas tabelas.

Uma enorme vantagem do ORM é que ele permite que você interaja com o banco de dados usando objetos Python em vez de escrever consultas SQL. Pense nisso como um tradutor que converte um idioma em outro para um público entender. Nesse caso, o ORM traduz o código Python em comandos SQL que o banco de dados pode executar e vice -versa.

Os modelos Django encapsulam toda a lógica relacionada ao banco de dados e definem a estrutura do seu banco de dados, atuando como um plano para os dados que você deseja armazenar.

Formato geral de um modelo Django

Em Django, todo modelo segue uma maneira particular de declaração. Aqui está a estrutura básica de uma declaração de modelo:

class <model_name>(models.Model):
    <field_name> = models.<field_type>(<optional_field_characteristics>)

Vamos quebrá -lo:

  • classe : a palavra -chave usada para definir um modelo no Django.

  • Model_name : o nome do modelo.

  • models.Model: a classe base da qual a classe do modelo herda.

  • field_name: o nome da coluna do banco de dados.

  • field_type : refere -se ao tipo de dados que o campo é mantido como charfield , booleanfield e assim por diante.

  • optional_field_characteristics: usado para definir melhor como o campo se comporta, como max_length, default e assim por diante.

Exemplo de modelo

Tendo sabido tudo sobre modelos até agora, construiremos um para uma lista de tarefas. Normalmente contém o título da tarefa, a descrição e um indicador se as tarefas foram concluídas ou não.

class Task(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    completed = models.BooleanField(default=False)

Neste modelo:

  • Tarefa é o nome do modelo.

  • O modelo de tarefas tem três campos:

    • Título : um Charfield que mantém o texto, com um comprimento máximo de 100 caracteres.

    • descrição: um TextField para texto mais longo.

    • completed: um BooleanField que armazena um valor True ou False, com um padrão de False.

O componente de visualização

As visualizações do Django são responsáveis pelo processamento de solicitações de usuário e respostas de retorno. Eles atuam como a ponte entre o modelo e o modelo coletando dados de objetos de modelo, executando operações lógicas neles (como consultas com base em determinados critérios) e depois passando os dados para o modelo para exibição.

As visualizações podem ser escritas como funções ou baseadas em classes, dependendo da complexidade e dos requisitos da sua aplicação.

Formato geral de uma visão django

Aqui está a estrutura básica de uma visão:

def <view_name>(request):
    # View Logic goes in here....
    return render(request, <template>, <context>)

Vamos decompô-lo:

  • view_name: o nome da função de visualização.

  • request: a solicitação HTTP enviada pelo cliente ao servidor Django, pode ser acionada a partir do envio de um formulário ou do clique em um botão.

  • Retornar renderização : Usado para gerar a resposta HTML. Leva:

    • Solicitação : O objeto Solicitação, que contém informações sobre a solicitação recebida.

    • Modelo : o arquivo de modelo para renderizar.

    • context: contém variáveis a serem disponibilizadas no template, geralmente vem na forma de um dicionário.

Ver exemplo

Continuando com nossa lista de tarefas, é assim que nossa visão seria:

def task_list(request):
    # Logic goes in here...
    return render(request, <template>, {'tasks': tasks})

O componente modelo

Os modelos de Django são responsáveis por renderizar a saída HTML final no navegador. Eles definem como os dados devem ser apresentados, usando uma combinação da linguagem de modelos HTML e Django.

A linguagem de modelagem do Django envolve o uso de tags de modelo {% %} e variáveis de modelo {{ }} que permitem que você entre no modo Django em seu modelo HTML. Neste modo, você pode acessar variáveis definidas em suas Views e utilizar estruturas de controle dentro do seu template.

Os modelos também podem ser estilizados usando CSS ou qualquer uma de suas estruturas CSS favoritas para tornar sua interface de usuário mais apresentável.

exemplo de modelo

Nosso template é um arquivo HTML normal com a linguagem de templates do Django. Esta é a aparência do nosso modelo de lista de tarefas:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Task List</title>
</head>
<body>
    <h1>Task List</h1>
    <ul>
        {% for task in tasks %}
            <li>{{ task.title }} - {{ task.completed|yesno:"Done,Not Done" }}</li>
        {% empty %}
            <p>No tasks available.</p>
        {% endfor %}
    </ul>
</body>
</html>

Neste modelo:

  • O para loop itera através de cada tarefa na lista Tasks (lembre -se de que ela foi aprovada como contexto em nossas opiniões).

  • Para cada tarefa, ele exibe o título da tarefa e seu status concluído (como "Concluído" ou "Não concluído").

  • Se a lista Tasks estiver vazia, o bloco { % vazio} exibe uma mensagem de fallback dizendo "Nenhuma tarefa disponível".

Diagrama mostrando o fluxo de trabalho da MVT

Este diagrama mostra como os dados fluem na arquitetura MVT da Django:

Analogia do mundo real de MVT

Imagine que você vá a um restaurante e faça um pedido para sua refeição favorita. Nos bastidores, o restaurante possui um livro de receitas que descreve como cada prato deve ser preparado. O chef usa as receitas para preparar sua refeição exatamente da maneira que você pediu. Quando estiver pronto, o servidor oferece a refeição para você de uma maneira apresentável.

Assim como um chef segue a receita para criar o prato, a exibição usa o modelo para coletar e processar dados. Por fim, como o servidor que entrega o prato, o modelo garante que a saída final seja apresentada em um formato claro e envolvente ao usuário.

Juntando tudo em um projeto

Esta seção orientará você, do início ao fim, como configurar a Lista de Tarefas que usamos como exemplo no artigo. Ao final, você deverá ter uma aplicação funcional com a arquitetura MVT em pleno fluxo.

Instale o python

Primeiro, certifique-se de ter o Python instalado. Você pode visitar o site oficial do Python para baixar a versão mais recente do Python.

Configure o projeto Django e o aplicativo

Em seguida, instale o Django. Você pode instalá-lo usando pip:

pip install django

Crie uma pasta e abra -a no seu editor de código favorito.

Crie um novo projeto Django e aplicativo executando os seguintes comandos em seu terminal, um após o outro:

django-admin startproject myproject 
cd myproject
django-admin startapp myapp

Defina o modelo

Em seu myApp/models.py :

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    completed = models.BooleanField(default=False)

Crie um formulário

Precisamos de um formulário Django baseado no modelo Task, então criaremos um usando o Django ModelForm.

Em seu myapp, crie um arquivo, nomeie-o como forms.py e insira este código:

from django import forms
from .models import Task

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['title', 'description', 'completed']

Neste código:

  • Task é importado de .models .

  • classe TaskForm (forms.modelform) : Isso cria uma nova classe chamada TaskForm , que é uma subclasse de forms.modelfform .

  • class Meta:: é uma classe especial usada pelo ModelForm do Django para fornecer configuração para o formulário. A classe Meta diz ao Django como criar o formulário especificando o modelo associado e os campos a serem incluídos no formulário.

  • model=Task: especifica o modelo no qual o formulário se baseia. Neste caso, o formulário é baseado no modelo Task.

  • fields=['title', 'description', 'completed']: especifica quais campos do modelo Task devem ser incluídos no formulário. Isso permite controlar quais campos do modelo aparecem no formulário e pode ser personalizado para incluir apenas determinados campos, em vez de todos os campos do modelo.

Crie a visualização

Em seu myApp/Views.py , insira este código:

from django.shortcuts import render,redirect
from .models import Task
from .forms import TaskForm

def task_list(request):
    tasks = Task.objects.all()    # Retrieve all tasks

    if request.method == 'POST':    # Handle form submissions
        form = TaskForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('task_list')  # Redirect to avoid duplicate submissions
    else:
        form = TaskForm()

    # Pass tasks and the form to the template
    return render(request, 'task_list.html', {'tasks': tasks, 'form': form})

Nesta visão,

  • TaskForm é importado de Forms .

  • O código verifica se o método de solicitação é post , indicando que o usuário enviou um formulário.

  • Se o método for POST, ele cria uma instância de TaskForm usando os dados enviados (request.POST).

  • O formulário é então validado usando form.is_valid() e, se for válido, o formulário é salvo no banco de dados.

  • Após o salvamento, o usuário é redirecionado para a página da lista de tarefas para evitar envios duplicados.

Defina o modelo

No seu diretório myApp , crie uma pasta modelos . Dentro da pasta Modelos, crie um arquivo e nomeie -o task_list.html . Precisamos adicionar um elemento de formulário que coleta as entradas do usuário e as exiba em uma lista na interface do usuário.

No arquivo task_list html, temos:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Task List</title>
</head>
<body>
    <h1>Task List</h1>
    <ul>
        {% for task in tasks %}
            <li>{{ task.title }} - {{ task.completed|yesno:"Done,Not Done" }}</li>
        {% empty %}
            <p>No tasks available.</p>
        {% endfor %}
    </ul>

    <h2>Add a New Task</h2>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Add Task</button>
    </form>
</body>
</html>

No código de formulário adicionado:

  • Criamos um formulário HTML com o método post para enviar dados. Inclui um { % csrf_token %} para proteger contra ataques de CSRF.

  • Os campos do formulário são renderizados usando {{ form.as_p }}, que exibe cada campo dentro de uma tag <p>.

  • Finalmente, é fornecido um botão de envio denominado "Adicionar tarefa", permitindo ao usuário enviar os dados do formulário.

Estrutura de pastas

Chegando a este ponto, é importante verificar se você está configurando seu aplicativo da maneira correta. Esta é a aparência de sua estrutura de pastas/arquivos:

└── ?myproject
    └── ?myapp
        └── ?__pycache__
        └── ?migrations
        └── ?templates
            └── task_list.html
        └── __init__.py
        └── admin.py
        └── apps.py
        └── forms.py
        └── models.py
        └── tests.py
        └── urls.py
        └── views.py
    └── ?myproject
        └── ?__pycache__
        └── __init__.py
        └── asgi.py
        └── settings.py
        └── urls.py
        └── wsgi.py
    └── db.sqlite3
    └── manage.py

Configure o URL do projeto

Em seu myproject/urls.py, inclua a URL em seu myapp:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Adicione o aplicativo às configurações do projeto

Adicione seu myApp à lista de aplicativos instalados em seu myProject/Settings.py :

INSTALLED_APPS = [
    'myapp',      # added our myapp app
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Execute o servidor

Aplique a migração e execute o servidor inserindo estes comandos:

python manage.py migrate

python manage.py runserver

Visite http://127.0.0.1:8000/ No seu navegador para testar seu aplicativo.

Look final

Esta é a aparência do nosso aplicativo de lista de tarefas no navegador depois de adicionar algumas tarefas usando o formulário. Você pode fazer melhorias adicionais no estilo do modelo que desejar.

Conclusão

Neste artigo, você aprendeu sobre os componentes da arquitetura MVT do Django, como eles interagem entre si e como tornam as experiências web perfeitas. Também construímos um projeto simples para ver como funciona na prática, e espero que você entenda melhor agora.

Se você gostou de ler este artigo, pode me seguir em X ou se conectar comigo no LinkedIn para mais artigos e postagens de programação.

Vejo você no próximo!