Django webbramverk har en modell-vy-mall (MVT) arkitektur, vilket gör det till det enda ramverket du behöver för att skapa en komplett webbplats eller webbapplikation. Detta Python-ramverk låter dig skapa modeller som genererar databaser och renderar dynamiska HTML-mallar till användargränssnittet med hjälp av vyer.

Djangos kraft är ingen hemlighet; det är snabbt, pålitligt, skalbart och säkert. Tillförlitligheten, såväl som skalbarheten hos denna programvara, är beroende av dess MVT-arkitektur. Och i den här artikeln kommer du att lära dig exakt hur Djangos MVT-arkitektur fungerar.

Vad är Djangos modell?

Modellen i Djangos MVT-arkitektur definierar strukturen och beteendet för den data du vill lagra via din webbplats. Varje Django-modell du skapar genererar en motsvarande databastabell, där varje attribut i modellen blir ett fält i tabellen.

Fortsätter med inställningen från vår inledande artikel om Django, kan du skapa en modell för säljarna. En säljare kan ha en säljarmodell som har personlig information, såsom ett namn och kontaktuppgifter, och en relaterad modell för varorna varje säljare säljer.

Den befintliga Django-projektfilstrukturen

min sida/
 min sida/
 _pycache_
 _init_.py
 asgi.py
 settings.py
 urls.py
 wsgi.py
 säljare/
 migration
 _init_.py
 admin.py
 apps.py
 models.py
 test.py
 views.py
 db.sqlite3
 hantera.py

Skapa Django-modeller

Om du tittar under säljarens appsektion i filstrukturen ovan ser du en fil som heter models.py. Det är här du skapar alla dina Django-modeller för säljarens avsnitt på din webbplats. Varje modell som du skapar kommer att vara en underklass av Django's Model API, vilket är anledningen till att varje Django-genererad models.py filen har en standardmodellimport.

Filen models.py

Från django.db importmodeller
# Skapa dina modeller här.
klass Säljare (modeller. Modell):
förnamn = modeller. CharField (max_length=30)
efternamn = modeller. CharField (max_length=30)
contact_number = modeller. CharField (max_length=30)
klass Produkt (modeller. Modell):
säljare = modeller. ForeignKey (säljare, on_delete=modeller. KASKAD)
item_name = modeller. CharField (max_length=100)
item_quantity = modeller. IntegerField()
artikelpris = modeller. Decimalfält (max_digits=9, decimal_places=2)
item_description = modeller. Textfält()

Koden ovan är en kopia av det uppdaterade innehållet i model.py fil. Filen skapar nu två modeller – säljare och produkt. Dessa modeller delar en en-till-många-relation, där en säljare kan ha många produkter på rea. Så, produktmodellen har en främmande nyckel från säljaren och en on_delete attribut inställt på modeller. KASKAD, vilket innebär att när du tar bort en säljare tar du automatiskt bort alla produkter som har det primärnyckel som en främmande nyckel.

Relaterad: Lär dig Python och Django idag med dessa fantastiska kurser Du kanske också märker att var och en av modellerna i koden ovan inte har en primärnyckel. Detta beror på att Django automatiskt genererar en primärnyckel om du inte uttryckligen skapar en.

Innan du kan använda någon modell som du skapar måste du berätta för Django var den kan hittas. För att göra detta måste du navigera till settings.py fil och infoga namnet på modulen som innehåller models.py fil, in i INSTALLERAD_APP sektion.

I exempelprojektet för den här artikeln models.py filen finns i säljarens modul. Därför uppdateras INSTALLERAD_APP avsnitt kommer att lyda som följer:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
"säljare",
]

Med koden ovan är modellerna i säljarens app nu synliga på Django-webbplatsen och nu kan du gå vidare till migrering.

Att genomföra migrering är viktigt eftersom denna process är ett sätt att sprida de ändringar du gör i dina modeller till motsvarande databasschema. Så varje gång du gör ändringar i din modell måste du genomföra migreringsprocessen – som omfattar två steg.

Steg ett är att göra migreringar, vilket är ett kommando som skapar migreringar baserat på de ändringar som upptäckts i models.py fil. För att starta migreringsprocessen måste du öppna din terminal, navigera till katalogen som har ditt Django-projekt och starta servern med följande kommando:

python manage.py runserver

Med servern igång i en terminal, öppna en ny terminal och skriv in följande kommando:

python manage.py makemigrationer

Efter exekvering kommer terminalen att producera följande utdata:

Migrering för "säljare":
säljare\migrationer\0001_initial.py
- Skapa modell säljare
- Skapa modellprodukt

Resultatet ovan visar tydligt att du nu har migrering för två modeller – säljaren och produkten. Om du nu navigerar till migreringsmappen i din säljares modul ser du att den nu har en ny fil som heter 0001_initial.py. I den här filen hittar du migreringarna du just skapade.

Filen 0001_initial.py

# Genererad av Django 3.2.9 2022-02-26 16:06
från django.db import migrationer, modeller
importera django.db.models.deletion
klass Migration (migrationer. Migration):
initial = Sant
beroenden = [
]
operationer = [
migrationer. SkapaModel(
name='Säljare',
fält=[
('id', modeller. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', modeller. CharField (max_length=30)),
('efternamn', modeller. CharField (max_length=30)),
('kontaktnummer', modeller. CharField (max_length=30)),
],
),
migrationer. SkapaModel(
name='Produkt',
fält=[
('id', modeller. BigAutoField (auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('artikelnamn', modeller. CharField (max_length=100)),
('item_quantity', modeller. IntegerField()),
('varupris', modeller. DecimalFält (decimal_platser=2, max_siffror=9)),
('item_description', modeller. Textfält()),
('säljare', modeller. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='sellers.seller')),
],
),
]

Varje gång du gör en ny migrering genererar migreringsmappen en ny version av den här filen.

Steg två i migreringsprocessen är att slutligen migrera modellerna. Detta innebär att du synkroniserar databastillståndet med models.py fil, med hjälp av migreringarna som du just skapade i 0001_initial.py fil. Du kan slutföra denna process (medan servern fortfarande körs) med följande kommando:

python manage.py migrera

Vad är Djangos mall?

Mallar är ett sätt att dynamiskt generera HTML för ditt Django-projekt. Varje Django-mall har .html förlängning och en kombination av statiskt och dynamiskt innehåll. Django-mallar har en unik syntax som inkluderar nya sätt att skapa variabler och taggar i ett HTML-dokument.

Skapa en Django-mall

För att introducera mallar i exempel på e-handelswebbplatsen för den här artikeln måste du skapa en ny katalog i säljarens modul. Den här nya katalogen som heter "mallar" kommer att vara hemmet för alla HTML-dokument för säljarens app – från och med startsidan.

Filen sellers_home.html

Välkomna säljare!

När du har skapat dina mallar måste du göra dem synliga för Django genom att lägga till mallarnas katalog i MALLAR avsnitt av settings.py fil. Den uppdaterade MALLAR avsnitt kommer att se ut så här:

MALLAR = [
{
'BACKEND': 'django.template.backends.django. DjangoTemplates',
'DIRS': [
# ny kod som pekar på platsen för mallarna
BASE_DIR / 'säljare' / 'mallar'
],
'APP_DIRS': Sant,
'ALTERNATIV': {
'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 när Django vet var man kan hitta mallarna för webbplatsen kan du gå vidare och återge dem till användargränssnittet med hjälp av vyn.

Vad är Djangos syn?

Vyn är det andra lagret av Djangos MVT-arkitektur, en mall är värdelös om inte en vy återger den till användargränssnittet. Vyn ansvarar för att acceptera webbförfrågningar och returnera lämpliga svar (inklusive mallar). I sin mest grundläggande form är vyn en Python-funktion, lagrad i view.py fil för ditt Django-projekt.

Skapar Django View

De view.py filen finns i säljarens modul för Django-exemplet. När en säljare besöker din webbplats vill du att de ska gå till en säljares hemsida. Den här hemsidan skapar du med hjälp av en HTML-mall, ungefär som den som skapades i mallavsnittet ovan.

Filen view.py

från django.shortcuts import render
def index (begäran):
returnera rendering (request, 'sellers_home.html')

Vyn ovan tar emot en begäran och returnerar säljarens HTML-mall. Så varje gång en användare besöker (eller begär) http://127.0.0.1:8000/sellers/ de kommer att se säljarens hemsida. Detta är efter att du har skapat en urls.py fil i säljarens modul.

Filen Sellers urls.py

från django.urls importsökväg
från. importera vyer
urlpatterns = [
path('', views.index, name='index'),
]

Och inkludera sökvägen till säljarens modul urls.py fil i urls.py fil som finns i huvudkatalogen för Django.

Webbplatsens urls.py-fil

från django.contrib import admin
från django.urls import inkluderar, sökväg
urlpatterns = [
path('sellers/', include('sellers.urls')),
sökväg('admin/', admin.site.urls),
]

Nu när vyn är inställd kan du se till att Django-servern fortfarande körs och navigera till http://127.0.0.1:8000/sellers/ i din webbläsare för att se säljarens hemsida.

Säljarnas hemsida

Djangos MVT-arkitektur vs. MVC arkitektur

Djangos MVT-arkitektur skiljer sig ganska mycket från den populära MVC-arkitekturen.

Mallsektionen i MVT-arkitekturen fungerar på ungefär samma sätt som vyn i MVC-arkitekturen, medan vyn i MVT-arkitekturen visar egenskaper som liknar styrenheten i MVC arkitektur. Dock fungerar modellerna i båda arkitekturerna identiskt.

En introduktion till MVC-arkitektur: exempel förklaras

Tillämpa Model-View-Controller designprinciper på dina egna program för omedelbara resultat. Så här kommer du igång.

Läs Nästa

Om författaren