A Django webes keretrendszer modellnézet-sablon (MVT) architektúrával rendelkezik, így ez az egyetlen keretrendszer, amelyre egy teljes webhely vagy webes alkalmazás létrehozásához szüksége lesz. Ez a Python-keretrendszer lehetővé teszi olyan modellek létrehozását, amelyek adatbázisokat generálnak, és dinamikus HTML-sablonokat jelenítenek meg a felhasználói felületen nézetek használatával.

A Django ereje nem titok; gyors, megbízható, méretezhető és biztonságos. A szoftver megbízhatósága és méretezhetősége az MVT architektúrán múlik. Ebből a cikkből pedig pontosan megtudhatja, hogyan működik a Django MVT architektúrája.

Mi a Django modellje?

A Django MVT architektúrájának modellje határozza meg a webhelyén keresztül tárolni kívánt adatok szerkezetét és viselkedését. Minden létrehozott Django-modell létrehoz egy megfelelő adatbázistáblát, ahol a modell minden attribútuma mezővé válik a táblában.

Folytatjuk a beállítást a mi oldalunkról bevezető cikk a Django-ról, modellt készíthet az eladók számára. Az eladó rendelkezhet olyan eladói modellel, amely személyes adatokat, például nevet és elérhetőségi adatokat tartalmaz, valamint egy kapcsolódó modellt az egyes eladók által értékesített cikkekhez.

A meglévő minta Django projekt fájlstruktúrája

az én oldalam/
 az én oldalam/
 _pycache_
 _init_.py
 asgi.py
 settings.py
 urls.py
 wsgi.py
 eladók/
 migráció
 _init_.py
 admin.py
 apps.py
 modellek.py
 test.py
 views.py
 db.sqlite3
 manage.py

Django modellek készítése

Ha megnézi a fenti fájlstruktúrában az eladók alkalmazásai részt, egy nevű fájlt fog látni modellek.py. Itt hozhatja létre az összes Django modelljét webhelye eladói részéhez. Minden létrehozott modell egy alosztálya lesz Django modell API, ezért minden Django generált modellek.py fájl alapértelmezett modellimportálással rendelkezik.

A models.py fájl

A django.db import modellekből
# Készítse el modelljeit itt.
osztály Eladó (modellek. Modell):
keresztnév = modellek. CharField (max_length=30)
last_name = modellek. CharField (max_length=30)
kapcsolati_szám = modellek. CharField (max_length=30)
osztályú termék (modellek. Modell):
eladó = modellek. ForeignKey (Eladó, on_delete=models. VÍZESÉS)
item_name = modellek. CharField (max_length=100)
item_qantity = modellek. IntegerField()
item_price = modellek. Tizedes mező (max_digits=9, decimal_places=2)
item_description = modellek. Szövegmező()

A fenti kód a frissített tartalom másolata modell.py fájlt. A fájl most két modellt hoz létre – az eladót és a terméket. Ezek a modellek egy-a többhez viszonyban állnak egymással, ahol egy eladónak sok terméke lehet akciósan. Tehát a termékmodell rendelkezik a idegen kulcs az eladótól és egy on_delete attribútum beállítva modellek. VÍZESÉS, ami azt jelenti, hogy amikor töröl egy eladót, automatikusan törli az összes olyan terméket, amelyik rendelkezik ezzel elsődleges kulcs mint a idegen kulcs.

Összefüggő: Tanuljon Python és Django nyelven még ma ezeken a csodálatos tanfolyamokon Azt is észreveheti, hogy a fenti kódban szereplő modellek mindegyike nem rendelkezik elsődleges kulccsal. Ennek az az oka, hogy a Django automatikusan generál a elsődleges kulcs ha nem hoz létre kifejezetten.

Mielőtt bármilyen létrehozott modellt használhatna, meg kell adnia a Django-nak, hogy hol találja meg. Ehhez navigálnia kell a settings.py fájlt, és írja be a modul nevét, amely tartalmazza a modellek.py fájlba, a INSTALLED_APP szakasz.

A cikk mintaprojektjében a modellek.py fájl az eladói modulban található. Ezért a frissített INSTALLED_APP szakasz a következőképpen fog szólni:

INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
"eladók",
]

A fenti kóddal az eladók alkalmazásában lévő modellek mostantól láthatók a Django webhelyén, és most már áttérhet a migrációra.

Az áttelepítések végrehajtása azért fontos, mert ez a folyamat egy módja annak, hogy a modellekben végrehajtott módosításokat a megfelelő adatbázissémára terjeszthesse. Tehát minden alkalommal, amikor módosítja a modellt, el kell végeznie az áttelepítési folyamatot, amely két lépésből áll.

Az első lépés az áttelepítések végrehajtása, amely egy olyan parancs, amely a fájlban észlelt változások alapján hoz létre migrációt modellek.py fájlt. A migrációs folyamat elindításához meg kell nyitnia a terminált, el kell navigálnia a Django-projektet tartalmazó könyvtárba, és el kell indítania a kiszolgálót a következő paranccsal:

python manage.py runserver

Ha a szerver egy terminálon fut, nyisson meg egy új terminált, és írja be a következő parancsot:

python manage.py makemigrations

A végrehajtás után a terminál a következő kimenetet produkálja:

Áttelepítések az „eladók” számára:
sellers\migrations\0001_initial.py
- Modell eladó létrehozása
- Modelltermék létrehozása

A fenti kimenet egyértelműen kijelenti, hogy most két modell – az eladó és a termék – migrációja van. Ha most az eladói modulban lévő migrációs mappához navigál, látni fogja, hogy van egy új fájl, 0001_initial.py. Ebben a fájlban találja az imént létrehozott migrációkat.

A 0001_initial.py fájl

# Generálta Django 3.2.9, 2022-02-26 16:06
django.db-ből import migrációk, modellek
django.db.models.deletion importálása
osztály Migráció (migrációk. Migráció):
kezdeti = igaz
függőségek = [
]
műveletek = [
vándorlások. CreateModel(
name='Eladó',
mezők=[
('id', modellek. BigAutoField (auto_created=igaz, elsődleges_key=igaz, serialize=hamis, verbose_name='ID')),
('first_name', modellek. CharField (max_length=30)),
('last_name', modellek. CharField (max_length=30)),
('contact_number', modellek. CharField (max_length=30)),
],
),
vándorlások. CreateModel(
name='Termék',
mezők=[
('id', modellek. BigAutoField (auto_created=igaz, elsődleges_key=igaz, serialize=hamis, verbose_name='ID')),
('elem_neve', modellek. CharField (max_length=100)),
('item_quantity', modellek. IntegerField()),
('cikk_ára', modellek. DecimalField (tizedes_helyek=2, max_digits=9)),
('elem_leírása', modellek. Szövegmező()),
('eladó', modellek. ForeignKey (on_delete=django.db.models.deletion. CASCADE, to='eladók.eladó')),
],
),
]

Minden alkalommal, amikor új áttelepítést hajt végre, az áttelepítési mappa a fájl új verzióját hozza létre.

Az áttelepítési folyamat második lépése a modellek végleges migrációja. Ez azt jelenti, hogy szinkronizálja az adatbázis állapotát a modellek.py fájlban a most létrehozott áttelepítések használatával 0001_initial.py fájlt. Ezt a folyamatot (amíg a szerver még fut) a következő paranccsal fejezheti be:

python manage.py migráció

Mi a Django sablonja?

A sablonok segítségével dinamikusan generálhat HTML-t Django projektje számára. Minden Django sablon rendelkezik a .html kiterjesztés, valamint statikus és dinamikus tartalom kombinációja. A Django-sablonok egyedi szintaxissal rendelkeznek, amely magában foglalja a változók és címkék létrehozásának új módjait egy HTML-dokumentumban.

Django sablon létrehozása

Ha sablonokat szeretne bemutatni a cikk e-kereskedelmi mintawebhelyén, létre kell hoznia egy új könyvtárat az eladói modulban. Ez az új "sablonok" nevű könyvtár lesz az eladók alkalmazásához tartozó összes HTML-dokumentum otthona – a kezdőlaptól kezdve.

A sellers_home.html fájl

Üdvözlöm az eladókat!

Miután létrehozta a sablonokat, láthatóvá kell tennie őket a Django számára úgy, hogy hozzáadja a sablonok könyvtárát a SABLONOK szakasza a settings.py fájlt. A frissített SABLONOK szakasz a következőképpen fog kinézni:

SABLONOK = [
{
'HÁTTÉR': 'django.template.backends.django. DjangoTemplates,
„DIRS”: [
# új kód, amely a sablonok helyére mutat
BASE_DIR / 'eladók' / 'sablonok'
],
'APP_DIRS': Igaz,
'OPCIÓK': {
'context_processors': [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
},
]

Most, hogy a Django tudja, hol találja meg a webhely sablonjait, a nézet segítségével renderelheti őket a felhasználói felületen.

Mi Django nézete?

A nézet a Django MVT architektúrájának második rétege, a sablon haszontalan, hacsak egy nézet nem jeleníti meg a felhasználói felületen. A nézet felelős a webes kérések elfogadásáért és a megfelelő válaszok visszaküldéséért (beleértve a sablonokat is). A nézet legalapvetőbb formájában egy Python-függvény, amely a view.py a Django projekt fájlját.

Django View létrehozása

Az view.py fájl a minta Django projekt eladói moduljában található. Amikor egy eladó felkeresi az Ön webhelyét, azt szeretné, ha az eladók kezdőlapjára menne. Ezt a kezdőlapot HTML-sablon segítségével hozhatja létre, hasonlóan a fenti sablonszakaszban létrehozotthoz.

A view.py fájl

a django.shortcuts import renderből
def index (kérés):
renderelés visszaküldése (kérés, 'sellers_home.html')

A fenti nézet fogad egy kérést, és visszaadja az eladók HTML-sablonját. Tehát minden alkalommal, amikor egy felhasználó felkeresi (vagy kéri) http://127.0.0.1:8000/sellers/ látni fogják az eladók kezdőlapját. Ez azután történik, hogy létrehozta a urls.py fájlt az eladói modulban.

Az Sellers urls.py fájl

a django.urls importálási útvonalról
tól től. nézetek importálása
urlpatterns = [
path('', views.index, name='index'),
]

És tartalmazza az eladói modul elérési útját urls.py fájl a urls.py fájl a fő Django könyvtárban található.

A webhely urls.py fájlja

innen: django.contrib import admin
a django.urls importból tartalmazza, elérési út
urlpatterns = [
path('sellers/', include('sellers.urls')),
path('admin/', admin.site.urls),
]

Most, hogy a nézet be van állítva, megbizonyosodhat arról, hogy a Django szerver továbbra is fut, és navigálhat ide http://127.0.0.1:8000/sellers/ böngészőjében az eladók kezdőlapjának megtekintéséhez.

Az eladók kezdőlapja

Django MVT Architecture vs. MVC architektúra

A Django MVT architektúrája teljesen eltér a népszerű MVC architektúrától.

Az MVT architektúra sablon része nagyjából ugyanúgy működik, mint az MVC architektúra nézete, míg az MVT architektúra nézete olyan tulajdonságokat jelenít meg, amelyek hasonlóak az MVC vezérlőjéhez építészet. A modellek azonban mindkét architektúrában ugyanúgy működnek.

Bevezetés az MVC architektúrába: példák magyarázata

Alkalmazza a Model-View-Controller tervezési elveit saját programjaira az azonnali eredmények érdekében. Így kezdheti el.

Olvassa el a következőt

A szerzőről