Django modellek létrehozása: Útmutató

Hark Labs2022-03-08 · 12 min read

Django egy jól ismert webes keretrendszer biztonságos és könnyen karbantartható webhelyek és webalkalmazások gyors fejlesztéséhez. A Python alapú Django leegyszerűsíti a webfejlesztést, így több idő és figyelem jut az alkalmazások írására anélkül, hogy minden egyes alkalommal újra fel kellene találni a spanyolviaszt. A Django egy ingyenes és nyílt forráskódú projekt robusztus hivatalos dokumentációval, nagyszerű közösségi támogatással, valamint rengeteg ingyenes és fizetős támogatási lehetőséggel.

Ebben az útmutatóban elmerülünk a Django modellek létrehozásában. A Django-ban a model az adatokkal kapcsolatos információk kulcsfontosságú forrása. A modellek leírják a tárolandó adatok mezőit és viselkedését. A Django a modellt használja az adatbázis-táblák létrehozásához az ORM (Object Relational Mapping) segítségével, amelyeket szintén modellekként emlegetnek.

Előfeltételek

Egy Unix-alapú operációs rendszeren dolgozunk, lehetőleg egy Ubuntu 20.04 felhőszerveren, mint azon a rendszeren, amelyen teszteltük. Ha hasonló környezetben szeretné beállítani a Django-t, kérjük, olvassa el a „Hogyan telepítsük a Django-t és állítsunk be fejlesztői környezetet Ubuntu 20.04-en.”

1. lépés: Python fejlesztői környezet

A Django a Pythonra épül. Ezért szükségünk van egy robusztus Python fejlesztői környezetre az összes szükséges eszközzel a Python alkalmazásokkal való munkához. Ezt már tárgyaltuk egy dedikált útmutatóban. Itt egy rövid bemutatót tartunk.

Először indítson el egy terminált, és futtassa a következő parancsokat:

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

Ezután telepítse a pip – a Python csomagkezelőt:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Ezután telepítsen néhány további fejlesztői csomagot:

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

A virtuális környezet létrehozásához szükségünk van a Python venv modulra is:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

2. lépés: A MySQL szerver telepítése

A MySQL egy népszerű relációs adatbázis-kezelő rendszer. Nyílt forráskódú, stabil és funkciókban gazdag. A MySQL-t fogjuk használni adatbázis-szerverként a Django alkalmazásunkhoz. Telepítse a MySQL-t az APT segítségével:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Ezután ellenőrizze a telepítést:

$ systemctl status mysql

1	$ systemctl status mysql

Ez csak egy alapvető MySQL beállítás az alapértelmezett opciókkal. Tekintse meg a részletesebb útmutatót a MySQL telepítéséről és konfigurálásáról.

3. lépés: A Django alkalmazás beállítása

Most már készen állunk a Django alkalmazásunk létrehozására. Ha érdekli a Django további részletes bemutatása, kérjük, olvassa el a „A Django webes keretrendszer telepítése Ubuntu 20.04-en.”

Ezután hozzon létre egy dedikált könyvtárat az alkalmazás számára. A könyvtár nevének tükröznie kell a projekt nevét:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

A projektkönyvtáron belül hozzon létre egy Python virtuális környezetet a venv modul használatával:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktiválja a virtuális környezetet:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Telepítse a Django-t a következővel: pip:

$ pip install django

1	$ pip install django

Ezután hozzon létre egy új Django projektet a(z) django-admin paranccsal:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

4. lépés: A Django alkalmazás konfigurálása

A Django alkalmazás tartalmazza az összes alapértelmezett konfigurációt. A célunk eléréséhez el kell végeznünk néhány módosítást.

Kezdje a konfigurációs fájl szerkesztésével: settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

Ezután módosítsa az időzónát:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Adja hozzá azokat a gépeket, amelyek hozzáférhetnek a Django alkalmazásszerverhez:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Ezután alkalmazza a változtatásokat:

$ python manage.py migrate

1	$ python manage.py migrate

Végül hozzon létre egy szuperfelhasználót a Django webalkalmazásunkhoz:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

5. lépés: Django alkalmazás csatlakoztatása a MySQL-hez

A MySQL-hez való csatlakozáshoz egy további, a Django-val kompatibilis Python konnektor könyvtárra van szükségünk. A következőt fogjuk használni: mysqlclient.

Először ellenőrizze, hogy a szükséges csomagok telepítve vannak-e:

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

Ezután telepítse a következőt: mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Dedikált adatbázis létrehozása

Az alkalmazásunkhoz létre kell hoznunk egy dedikált adatbázist és egy adatbázis-felhasználót. Indítsa el a MySQL shellt mint root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Hozzon létre egy dedikált adatbázist a Django alkalmazásunkhoz:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Ezután hozzon létre egy dedikált adatbázis-felhasználót a Django alkalmazáshoz:

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Végül adjon teljes jogosultságot a dedikált felhasználónak a dedikált adatbázison:

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

A Django konfiguráció módosítása a MySQL használatához

Most módosítanunk kell néhány Django konfigurációt, hogy az a MySQL-t használhassa adatbázis-szerverként. Nyissa meg a settings.py fájlt egy szövegszerkesztőben:

$ nano settings.py

1	$ nano settings.py

Görgessen le a DATABASES részhez, és illessze be a következő kódot:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

Ezután szerkessze a MySQL konfigurációs fájlt, hogy az tartalmazza a szükséges adatbázis-hitelesítő adatokat:

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Adja hozzá a következő blokkot a fájl végéhez:

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Indítsa újra a MySQL-t a változtatások érvénybe léptetéséhez:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

6. lépés: Django modell létrehozása

Most már készen állunk egy új modell létrehozására a Django projektünkben. Aktiválja a virtuális környezetet:

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

Ezen a helyen utasítsa a Django-t egy új alkalmazás létrehozására:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

A létrehozás után a fájlstruktúrának valahogy így kell kinéznie. Itt a models.py fájl fogja tartalmazni az egyéni Django modellünk kódjait:

Ellenőrizze a fájl jelenlegi tartalmát:

$ cat models.py

1	$ cat models.py

A bemutatóhoz egy blogbejegyzésekhez tartozó modellt fogunk létrehozni, melynek neve Post. Ez a következő mezőket fogja tartalmazni:

title: A blogbejegyzés címe.
slug: Érvényes URL-eket tárol és generál a weboldalakhoz.
content: A blogbejegyzés szövege.
created_on: A bejegyzés létrehozásának dátuma.
author: A bejegyzést létrehozó felhasználó.

Nyissa meg a models.py fájlt egy szövegszerkesztőben:

$ nano models.py

1	$ nano models.py

Importáljunk néhány szükséges API-t a modellünkhöz. Alapértelmezés szerint a models API-t importálja. Szükségünk lesz még a slugify API-ra a slug-ok generálásához, a User API-ra a hitelesítéshez, valamint a reverse API-ra a jobb és rugalmasabb URL-létrehozáshoz:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

Ezután adja hozzá a Post nevű osztálymetódust. Ez tartalmazni fogja a szükséges adatbázis-mezőket, mint például a title, slug, content, created_on, és author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Szükségünk van az URL-generálás és a bejegyzés mentésének funkciójára. Ez azért fontos, mert egyedi linkeket generál, amelyek az egyedi bejegyzésekhez kapcsolódnak:

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

A következő szakasz megmondja a modellnek, hogyan rendezze a bejegyzéseket és hogyan jelenítse meg azokat a weboldalon. A logikát egy belső osztállyal kódoljuk, a Meta osztállyal. Ez további modell-logikát fog tartalmazni, amely nem érinti az adatbázis meződefinícióját:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Végül pedig szükségünk lesz a Comment modell funkciójára ebben a fájlban. Ehhez egy másik, Comment nevű osztályt kell hozzáadnunk a models.Model szignatúrával. Ez a következő adatbázismezőket fogja tartalmazni:

name: A hozzászóló neve.
email: A hozzászóló e-mail-címe.
text: Magának a hozzászólásnak a tartalma.
post: A bejegyzés, amelyhez a hozzászólás készült.
created_on: A hozzászólás létrehozásának ideje.

A kód valahogy így fog kinézni:

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

Ezen a ponton a models.py fájlunk így fog kinézni:

Végül mentse el a fájlt, és zárja be a szerkesztőt.

7. lépés: A Django beállításainak frissítése

A modell elkészült. Azonban módosítanunk kell néhány konfigurációs fájlt, hogy a modellt működésbe hozzuk. A settings.py fájlon belül hozzá kell adnunk a modellünket az alábbi szekcióhoz: INSTALLED_APPS.

Nyissa meg a settings.py fájlt egy szövegszerkesztőben:

$ nano settings.py

1	$ nano settings.py

Regisztrálja az új modult az alábbi szekcióban: INSTALLED_APPS:

Mentse el a fájlt, és zárja be a szerkesztőt.

8. lépés: A változtatások migrálása

Most, hogy hozzáadtuk az összes kívánt modellt, a következő lépés a változtatások alkalmazása. A Django alkalmazni fogja ezeket a sémákat a MySQL adatbázisunkra.

A következő parancs létrehozza az összes szükséges migrációs fájlt. A kimenet megmutatja ezeknek a fájloknak a helyét a projektkönyvtáron belül:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

A következő parancs kilistázza az összes meglévő migrációt:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Vegye figyelembe, hogy az összes migráció meg van jelölve, kivéve a 0001_initial jelű, a következő modellekhez létrehozott migrációt: Post és Comment.

A következő parancs megmutatja, hogy a Django milyen SQL-lekérdezést fog végrehajtani a migrációk elvégzéséhez:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Most már csak alkalmaznunk kell a migrációkat. Ezek a migrációk beírják a változtatásokat az adatbázisba:

$ python manage.py migrate

1	$ python manage.py migrate

9. lépés: A változtatások ellenőrzése

A változtatások ellenőrzéséhez vessünk egy pillantást a MySQL adatbázisunkra. Indítsa el a MySQL shellt Django felhasználóként:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Ezután váltson át az aktuális aktív adatbázisról a Django alkalmazás adatbázisára:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Listázza az adatbázis összes tábláját:

$ SHOW TABLES;

1	$ SHOW TABLES;

Végezetül, bármelyik tábla tartalmának megtekintéséhez használja a DESCRIBE lekérdezést:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

A Django korlátai MySQL használata esetén

Ha a MySQL-t használja adatbázis-szerverként a Django alkalmazásához, érdemes néhány dolgot szem előtt tartani:

A sémamódosító folyamatok körüli tranzakciók támogatása meglehetősen korlátozott. Ez azt jelenti, hogy ha egy migráció meghiúsul, a következő migrációs kísérlet előtt manuálisan kell visszavonni az összes változtatást. Nincs lehetőség egy korábbi állapotra való visszaállításra, amikor a sikertelen migráció még nem történt meg.
A legtöbb sémamódosító folyamat esetében a MySQL teljesen újraírja a táblákat. Bizonyos helyzetekben ez rendkívül időigényes lehet. Legrosszabb esetben az időbeli összetettség arányos lesz a hozzáadandó sorok vagy az eltávolítandó oszlopok számával. A hivatalos Django dokumentáció szerint ez egymillió soronként akár egy percet is igénybe vehet.
A MySQL karakterkorlátot kényszerít ki az oszlopok, táblák és indexek neveinek hosszára. Emellett korlátozva van az összes oszlop és index lefedettségének teljes mérete is. A Django túllépheti ezt a korlátot. A MySQL-en kívül néhány más backend képes kezelni a Django magasabb korlátját.

Ezért erősen ajánlott mérlegelni a lehetőségeket, és a megfelelőt választani.

Záró gondolatok

Ez az útmutató sikeresen bemutatja, hogyan adhatunk modulokat egy meglévő Django alkalmazáshoz. Az alkalmazás backendjeként a MySQL-t használtuk. Emellett bemutat néhány kulcsfontosságú Django fogalmat is, mint például a modellek, a migráció működése, és hogy a Django hogyan fordítja le a modelleket MySQL adatbázis-táblákká.

Kellemes kódolást!

Hark Labs

Szerző · CloudSigma

Preslav Dobrev a CloudSigma kreatív tervezője, aki hagyományos és innovatív marketingcsatornák segítségével következetes vállalati identitás kialakítására összpontosít. Kiemelkedően képes ötvözni a művészi látásmódot a stratégiai marketinggel, hogy hatásos márkatörténeteket hozzon létre.