Het Django-webframework heeft een model-view-template (MVT) -architectuur, waardoor dit het enige framework is dat je nodig hebt om een ​​complete website of webtoepassing te maken. Met dit Python-framework kun je modellen maken die databases genereren en dynamische HTML-sjablonen naar de gebruikersinterface weergeven met behulp van views.

De kracht van Django is geen geheim; het is snel, betrouwbaar, schaalbaar en veilig. Zowel de betrouwbaarheid als de schaalbaarheid van deze software is afhankelijk van de MVT-architectuur. En in dit artikel leer je precies hoe de MVT-architectuur van Django werkt.

Wat is het model van Django?

Het model in de MVT-architectuur van Django definieert de structuur en het gedrag van de gegevens die u via uw website wilt opslaan. Elk Django-model dat u maakt, genereert een bijbehorende databasetabel, waarbij elk kenmerk van het model een veld in de tabel wordt.

Doorgaan met de setup van onze inleidend artikel over Django, kunt u een model maken voor de verkopers. Een verkoper kan een verkopersmodel hebben met persoonlijke informatie, zoals een naam en contactgegevens, en een gerelateerd model voor de artikelen die elke verkoper verkoopt.

De bestaande voorbeeldbestandsstructuur van het Django-project

mijn website/
 mijn website/
 _pycache_
 _init_.py
 asgi.py
 instellingen.py
 urls.py
 wsgi.py
 verkopers/
 migratie
 _init_.py
 admin.py
 apps.py
 modellen.py
 test.py
 views.py
 db.sqlite3
 manage.py

Django-modellen maken

Als u in de bovenstaande bestandsstructuur onder de app-sectie van de verkoper kijkt, ziet u een bestand met de naam modellen.py. Hier maakt u al uw Django-modellen voor het verkopersgedeelte van uw website. Elk model dat u maakt, is een subklasse van: Django's model-API, dat is de reden waarom elke door Django gegenereerde modellen.py bestand heeft een standaard import van modellen.

Het bestand models.py

Importeer modellen van django.db
# Maak hier je modellen aan.
klasse Verkoper (modellen. Model):
voornaam = modellen. CharField (max_length=30)
achternaam = modellen. CharField (max_length=30)
contact_nummer = modellen. CharField (max_length=30)
klasse Product (modellen. Model):
verkoper = modellen. ForeignKey (verkoper, on_delete=modellen. CASCADE)
item_name = modellen. CharField (max_length=100)
item_qantity = modellen. IntegerVeld()
item_price = modellen. Decimaalveld (max_digits=9, decimale_plaatsen=2)
item_description = modellen. TekstVeld()

De bovenstaande code is een kopie van de bijgewerkte inhoud van de model.py het dossier. Het bestand maakt nu twee modellen aan: Verkoper en Product. Deze modellen delen een een-op-veel-relatie, waarbij één verkoper veel producten in de uitverkoop kan hebben. Het productmodel heeft dus een vreemde sleutel van de verkoper en an on_delete attribuut ingesteld op modellen. CASCADE, wat betekent dat wanneer u een verkoper verwijdert, u automatisch elk product verwijdert dat dat heeft hoofdsleutel als een vreemde sleutel.

Verwant: Leer vandaag Python en Django met deze geweldige cursussen U merkt misschien ook dat elk van de modellen in de bovenstaande code geen primaire sleutel heeft. Dit komt omdat Django automatisch een hoofdsleutel als u er niet expliciet een maakt.

Voordat u een model dat u maakt, kunt gebruiken, moet u Django vertellen waar u het kunt vinden. Om dit te doen, moet je navigeren naar de instellingen.py bestand en voeg de naam in van de module die de. bevat modellen.py bestand, in de INSTALLED_APP sectie.

In het voorbeeldproject voor dit artikel, de modellen.py bestand bevindt zich in de verkopersmodule. Daarom is de bijgewerkte INSTALLED_APP sectie luidt als volgt:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.berichten',
'django.contrib.staticfiles',
'verkopers',
]

Met de bovenstaande code zijn de modellen in de verkopersapp nu zichtbaar voor de Django-website, en nu kun je overgaan tot migraties.

Het uitvoeren van migraties is belangrijk omdat dit proces een manier is om de wijzigingen die u in uw modellen aanbrengt, te verspreiden naar het bijbehorende databaseschema. Dus elke keer dat u wijzigingen aanbrengt in uw model, moet u het migratieproces uitvoeren, dat uit twee stappen bestaat.

Stap één is om migraties uit te voeren, een commando dat migraties maakt op basis van de veranderingen die zijn gedetecteerd in de modellen.py het dossier. Om het migratieproces te starten, moet u uw terminal openen, naar de map navigeren met uw Django-project en de server starten met de volgende opdracht:

python manage.py runserver

Terwijl de server in één terminal draait, opent u een nieuwe terminal en voert u de volgende opdracht in:

python manage.py makemigrations

Na uitvoering zal de terminal de volgende output produceren:

Migraties voor 'verkopers':
verkopers\migraties\0001_initial.py
- Modelverkoper maken
- Modelproduct maken

In de bovenstaande uitvoer staat duidelijk dat u nu migraties heeft voor twee modellen: de verkoper en het product. Als u nu naar de migratiemap in de module van uw verkopers navigeert, ziet u dat deze nu een nieuw bestand heeft met de naam 0001_initial.py. In dit bestand vindt u de migraties die u zojuist hebt gemaakt.

Het bestand 0001_initial.py

# Gegenereerd door Django 3.2.9 op 2022-02-26 16:06
van django.db import migraties, modellen
import django.db.models.deletion
klasse Migratie (migraties. Migratie):
initiaal = True
afhankelijkheden = [
]
bewerkingen = [
migraties. MaakModel(
naam='Verkoper',
velden=[
('id', modellen. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', modellen. CharField (max_length=30)),
('achternaam', modellen. CharField (max_length=30)),
('contact_nummer', modellen. CharField (max_length=30)),
],
),
migraties. MaakModel(
naam='Product',
velden=[
('id', modellen. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('item_name', modellen. CharField (max_length=100)),
('item_qantity', modellen. geheel getalVeld()),
('item_price', modellen. DecimalField (decimal_places=2, max_digits=9)),
('item_description', modellen. Tekstveld()),
('verkoper', modellen. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]

Elke keer dat u een nieuwe migratie uitvoert, genereert de migratiemap een nieuwe versie van dit bestand.

Stap twee van het migratieproces is het definitief migreren van de modellen. Dit betekent dat u de databasestatus synchroniseert met de modellen.py bestand, met behulp van de migraties die u zojuist hebt gemaakt in de 0001_initial.py het dossier. U kunt dit proces voltooien (terwijl de server nog draait) met het volgende commando:

python manage.py migreren

Wat is de sjabloon van Django?

Sjablonen zijn een manier om dynamisch HTML te genereren voor uw Django-project. Elke Django-sjabloon heeft de .html extensie en een combinatie van statische en dynamische inhoud. Django-sjablonen hebben een unieke syntaxis die nieuwe manieren omvat om variabelen en tags in een HTML-document te maken.

Een Django-sjabloon maken

Om sjablonen te introduceren op de voorbeeldwebsite voor e-commerce voor dit artikel, moet u een nieuwe map maken in de verkopersmodule. Deze nieuwe map met de naam "templates" zal de thuisbasis zijn van alle HTML-documenten voor de app van de verkoper, te beginnen met de startpagina.

Het bestand sellers_home.html

Welkom verkopers!

Nadat u uw sjablonen heeft gemaakt, moet u ze zichtbaar maken voor Django door de map van uw sjablonen toe te voegen aan de SJABLONEN gedeelte van de instellingen.py het dossier. de bijgewerkte SJABLONEN sectie ziet er als volgt uit:

SJABLONEN = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# nieuwe code die verwijst naar de locatie van de sjablonen
BASE_DIR / 'verkopers' / 'sjablonen'
],
'APP_DIRS': waar,
'OPTIES': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Nu Django weet waar de sjablonen voor de website te vinden zijn, kunt u doorgaan en ze naar de gebruikersinterface weergeven met behulp van de weergave.

Wat is de visie van Django?

De weergave is de tweede laag van Django's MVT-architectuur, een sjabloon is nutteloos tenzij een weergave deze naar de gebruikersinterface weergeeft. De view is verantwoordelijk voor het accepteren van webverzoeken en het retourneren van passende antwoorden (inclusief sjablonen). In zijn meest basale vorm is de weergave een Python-functie, opgeslagen in de bekijk.py bestand van uw Django-project.

Django-weergave maken

De bekijk.py bestand bevindt zich in de verkopersmodule van het voorbeeld-Django-project. Wanneer een verkoper uw website bezoekt, wilt u dat deze naar de startpagina van een verkoper gaat. Deze startpagina maakt u met een HTML-sjabloon, vergelijkbaar met degene die in het sjabloongedeelte hierboven is gemaakt.

Het view.py-bestand

van django.shortcuts import render
def index (verzoek):
render render (verzoek, 'sellers_home.html')

De bovenstaande weergave neemt een verzoek en retourneert de HTML-sjabloon van de verkoper. Dus elke keer dat een gebruiker een bezoek brengt (of vraagt) http://127.0.0.1:8000/sellers/ ze zullen de startpagina van de verkopers zien. Dit is nadat je een hebt gemaakt urls.py bestand in de verkopersmodule.

Het bestand Verkopers urls.py

van django.urls importpad
van. weergaven importeren
urlpatronen = [
pad('', views.index, naam='index'),
]

En voeg het pad naar de verkopersmodule toe urls.py bestand in de urls.py bestand dat zich in de hoofddirectory van Django bevindt.

Het website-urls.py-bestand

van django.contrib importbeheerder
van django.urls import include, path
urlpatronen = [
path('sellers/', include('sellers.urls')),
path('admin/', admin.site.urls),
]

Nu de weergave is ingesteld, kunt u ervoor zorgen dat de Django-server nog steeds actief is en navigeert u naar: http://127.0.0.1:8000/sellers/ in uw browser om de startpagina van de verkopers te zien.

De startpagina van de verkopers

Django's MVT-architectuur vs. MVC-architectuur

De MVT-architectuur van Django verschilt nogal van de populaire MVC-architectuur.

Het sjabloongedeelte van de MVT-architectuur werkt op vrijwel dezelfde manier als de weergave in de MVC-architectuur, terwijl de weergave in de MVT-architectuur kwaliteiten vertoont die vergelijkbaar zijn met de controller in de MVC architectuur. De modellen in beide architecturen werken echter identiek.

Een inleiding tot MVC-architectuur: voorbeelden uitgelegd

Pas de ontwerpprincipes van Model-View-Controller toe op uw eigen programma's voor onmiddellijke resultaten. Hier leest u hoe u aan de slag kunt gaan.

Lees volgende

Over de auteur