Vytváranie Django modelov: Tutoriál

Hark Labs2022-03-08 · 11 min read

Django je známy webový framework na rýchly vývoj bezpečných a udržiavateľných webových stránok a webových aplikácií. Postavený pomocou Python, Django zjednodušuje vývoj webu, čo umožňuje venovať viac času a pozornosti písaniu aplikácií bez toho, aby ste museli zakaždým znova vymýšľať koleso. Django je bezplatný a open-source projekt s robustnou oficiálnou dokumentáciou, skvelou podporou komunity a množstvom bezplatnej aj platenej podpory.

V tomto návode sa ponoríme do vytvárania modelov Django. V Django je model kľúčovým zdrojom informácií o vašich dátach. Modely popisujú polia a správanie dát, ktoré sa majú uložiť. Django používa model na generovanie databázových tabuliek pomocou ORM (Object Relational Mapping), ktoré sa tiež označujú ako modely.

Požiadavky

Pracujeme na operačnom systéme založenom na Unixe, najlepšie na cloudovom serveri Ubuntu 20.04 ako na systéme, na ktorom sme to testovali. Ak chcete nastaviť Django v podobnom prostredí, prečítajte si náš návod „Ako nainštalovať Django a nastaviť vývojové prostredie na Ubuntu 20.04.”

Krok 1. Vývojové prostredie Python

Django je postavený na Pythone. Potrebujeme teda robustné vývojové prostredie Python so všetkými nástrojmi potrebnými na prácu s aplikáciami v Pythone. Už sme o tom hovorili v venovanom návode. Tu si ukážeme krátku ukážku.

Najprv spustite terminál a zadajte nasledujúce príkazy:

$ 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

Ďalej nainštalujte pip – správcu balíkov pre Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Potom nainštalujte niekoľko ďalších vývojových balíkov:

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

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

Na vytvorenie virtuálneho prostredia potrebujeme aj Python venv modul:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Krok 2. Inštalácia MySQL Servera

MySQL je populárny relačný systém riadenia databáz. Je open-source, stabilný a bohatý na funkcie. Použijeme MySQL ako databázový server pre našu aplikáciu Django. Nainštalujte MySQL pomocou APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Ďalej overte inštaláciu:

$ systemctl status mysql

1	$ systemctl status mysql

Ide len o základné nastavenie MySQL s predvolenými možnosťami. Pozrite si podrobnejší návod na inštaláciu a konfiguráciu MySQL.

Krok 3. Nastavenie aplikácie Django

Teraz sme pripravení vytvoriť našu aplikáciu Django. Ak máte záujem o ďalšiu podrobnú ukážku Django, prečítajte si náš návod „Inštalácia webového frameworku Django na Ubuntu 20.04.”

Ďalej vytvorte vyhradený adresár pre aplikáciu. Názov adresára by mal odrážať názov projektu:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

V adresári projektu vytvorte virtuálne prostredie Python pomocou modulu venv:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktivujte virtuálne prostredie:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Nainštalujte Django pomocou pip:

$ pip install django

1	$ pip install django

Ďalej vytvorte nový projekt Django pomocou príkazu django-admin:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Krok 4. Konfigurácia aplikácie Django

Aplikácia Django obsahuje všetky predvolené konfigurácie. Pre náš cieľ musíme vykonať niekoľko úprav.

Začnite úpravou konfiguračného súboru settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

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

Potom zmeňte časové pásmo:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Pridajte stroje, ktoré majú povolený prístup k serveru aplikácie Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Potom aplikujte zmeny:

$ python manage.py migrate

1	$ python manage.py migrate

Nakoniec vytvorte superpoužívateľa pre našu webovú aplikáciu Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Krok 5. Pripojenie aplikácie Django k MySQL

Na pripojenie k MySQL potrebujeme dodatočnú knižnicu konektora Python, ktorá je kompatibilná s Django. Budeme používať mysqlclient.

Najprv sa uistite, že máme nainštalované potrebné balíky:

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

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

Ďalej nainštalujte mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Vytvorenie vyhradenej databázy

Pre našu aplikáciu musíme vytvoriť vyhradenú databázu a databázového používateľa. Spustite MySQL shell ako root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Vytvorte vyhradenú databázu pre našu aplikáciu Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Potom vytvorte vyhradeného databázového používateľa pre aplikáciu Django:

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

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

Nakoniec udeľte vyhradenému používateľovi plné oprávnenia k vyhradenej databáze:

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

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

Zmena konfigurácie Django na používanie MySQL

Teraz musíme upraviť niektoré konfigurácie Django, aby mohlo používať MySQL ako databázový server. Otvorte settings.py v textovom editore:

$ nano settings.py

1	$ nano settings.py

Prejdite nadol na sekciu DATABASES a vložte nasledujúci kód:

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',

}

Ďalej upravte konfiguračný súbor MySQL tak, aby obsahoval potrebné prihlasovacie údaje k databáze:

$ sudo nano /etc/mysql/my.cnf

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

Na koniec súboru pridajte nasledujúci blok:

[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

Reštartujte MySQL, aby sa zmeny prejavili:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

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

Krok 6. Vytvorenie modelu Django

Teraz sme pripravení vytvoriť nový model v našom projekte Django. Aktivujte virtuálne prostredie:

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

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

V tomto umiestnení povedzte Djangu, aby vytvorilo novú aplikáciu:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Po vytvorení by mal strom súborov vyzerať nejako takto. Tu bude súbor models.py obsahovať kódy pre náš vlastný model Django:

Skontrolujte aktuálny obsah súboru:

$ cat models.py

1	$ cat models.py

Na ukážku vytvoríme model pre blogové príspevky s názvom Post. Bude obsahovať nasledujúce polia:

title: Názov blogového príspevku.
slug: Ukladá a generuje platné URL adresy pre webové stránky.
content: Text blogového príspevku.
created_on: Dátum vytvorenia príspevku.
author: Používateľ, ktorý príspevok vytvoril.

Otvorte súbor models.py v textovom editore:

$ nano models.py

1	$ nano models.py

Importujme niektoré potrebné API pre náš model. V predvolenom nastavení importuje API models. Budeme tiež potrebovať slugify API na generovanie slugov, User pre autentifikáciu a reverse pre lepšie a flexibilnejšie vytváranie URL adries:

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

Ďalej pridajte metódu triedy s názvom Post. Bude obsahovať potrebné databázové polia ako title, slug, content, created_on, a 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()

Potrebujeme funkciu na generovanie URL a ukladanie príspevku. Je to dôležité, pretože to generuje unikátne odkazy zodpovedajúce unikátnym príspevkom:

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)

Nasledujúca časť povie modelu, ako zoradiť príspevky a zobraziť ich na webovej stránke. Túto logiku zakódujeme pomocou vnútornej triedy, Meta. Bude obsahovať dodatočnú logiku modelu, ktorá sa netýka definície databázových polí:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Nakoniec budeme mať funkciu modelu Comment v tomto súbore. Vyžaduje to pridanie ďalšej triedy Comment s použitím models.Model ako jej signatúry. Bude obsahovať nasledujúce databázové polia:

name: Meno komentujúceho.
email: E-mailová adresa komentujúceho.
text: Samotný obsah komentára.
post: Príspevok, ku ktorému bol komentár pridaný.
created_on: Čas vytvorenia komentára.

Kód bude vyzerať približne takto:

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)

V tomto bode bude náš súbor models.py vyzerať takto:

Nakoniec súbor uložte a zatvorte editor.

Krok 7. Aktualizácia nastavení Django

Model je vytvorený. Musíme však upraviť niektoré konfiguračné súbory, aby sme model uviedli do prevádzky. Vnútri settings.py, musíme pridať náš model pod INSTALLED_APPS.

Otvorte settings.py v textovom editore:

$ nano settings.py

1	$ nano settings.py

Zaregistrujte nový modul v sekcii INSTALLED_APPS:

Uložte súbor a zatvorte editor.

Krok 8. Migrácia zmien

Teraz, keď sme pridali všetky požadované modely, ďalším krokom je aplikovanie týchto zmien. Django aplikuje tieto schémy na našu MySQL databázu.

Nasledujúci príkaz vygeneruje všetky potrebné migračné súbory. Výstup zobrazí umiestnenie všetkých týchto súborov v adresári projektu:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Nasledujúci príkaz zobrazí zoznam všetkých existujúcich migrácií:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Upozorňujeme, že všetky migrácie sú označené okrem 0001_initial ktorá bola vytvorená ako súčasť modelov Post a Comment.

Nasledujúci príkaz ukáže, aký SQL dopyt Django vykoná na uskutočnenie migrácií:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Teraz už len musíme aplikovať migrácie. Tieto migrácie zapíšu zmeny do databázy:

$ python manage.py migrate

1	$ python manage.py migrate

Krok 9. Overenie zmien

Ak chcete overiť zmeny, pozrime sa na našu databázu MySQL. Spustite MySQL shell ako používateľ Django:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Ďalej zmeňte aktuálnu aktívnu databázu na databázu aplikácie Django:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Vypíšte všetky tabuľky z databázy:

$ SHOW TABLES;

1	$ SHOW TABLES;

Na záver, ak chcete vidieť obsah ktorejkoľvek z tabuliek, použite DESCRIBE dopyt:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Obmedzenia Django s MySQL

Pri používaní MySQL ako databázového servera pre vašu aplikáciu Django je potrebné mať na pamäti niekoľko vecí:

Podpora transakcií pri procesoch meniacich schému je obmedzená. To znamená, že ak migrácia zlyhá, vyžaduje si to manuálne vrátenie všetkých zmien pred pokusom o ďalšiu migráciu. Neexistuje spôsob, ako sa vrátiť do predchádzajúceho stavu, kedy k zlyhanej migrácii nedošlo.
Pri väčšine procesov meniacich schému MySQL úplne prepisuje tabuľky. V určitých situáciách to môže byť naozaj časovo náročné. V najhoršom prípade bude časová náročnosť úmerná počtu pridávaných riadkov alebo odstraňovaných stĺpcov. Podľa oficiálnej dokumentácie Django to môže trvať jednu minútu na milión riadkov.
MySQL uplatňuje limit znakov pre dĺžku názvov stĺpcov, tabuliek a indexov. Existuje tiež limit na celkovú veľkosť všetkých stĺpcov a pokrytí indexov. Django môže tieto limity prekročiť. Niektoré iné backendy ako MySQL dokážu zvládnuť vyšší limit Django.

Preto sa dôrazne odporúča zvážiť vaše možnosti a vybrať si tú najvhodnejšiu.

Záverečné myšlienky

Tento návod úspešne demonštruje, ako pridať moduly do existujúcej aplikácie Django. Ako backend pre aplikáciu sme použili MySQL. Ukazuje tiež niektoré kľúčové koncepty Django, ako sú modely, ako funguje migrácia a ako Django prekladá modely do databázových tabuliek MySQL.

Príjemné programovanie!

Hark Labs

Autor · CloudSigma

Preslav Dobrev je kreatívny dizajnér v spoločnosti CloudSigma, ktorý sa zameriava na konzistentnú firemnú identitu prostredníctvom tradičných a inovatívnych marketingových kanálov. Dokáže brilantne spájať umeleckú víziu so strategickým marketingom, čím vytvára pôsobivé príbehy značky.