Vytváření Django modelů: Tutoriál

Hark Labs2022-03-08 · 11 min read

Django je známý webový framework pro rychlý vývoj zabezpečených a snadno udržovatelných webových stránek a webových aplikací. Vytvořený pomocí Python, Django zjednodušuje vývoj webu, což umožňuje věnovat více času a pozornosti psaní aplikací, aniž byste museli pokaždé znovu vymýšlet kolo. Django je bezplatný projekt s otevřeným zdrojovým kódem, robustní oficiální dokumentací, skvělou podporou komunity a spoustou bezplatné i placené podpory.

V tomto návodu se ponoříme do vytváření modelů v Django. V Django je model klíčovým zdrojem informací o vašich datech. Modely popisují pole a chování ukládaných dat. Django používá model ke generování databázových tabulek pomocí ORM (Object Relational Mapping), které se také označují jako modely.

Požadavky

Pracujeme na operačním systému založeném na Unixu, nejlépe na cloudovém serveru Ubuntu 20.04 jakožto systému, na kterém jsme vše testovali. Pokud chcete Django nastavit v podobném prostředí, podívejte se na náš návod „How To Install Django and Set Up a Development Environment on Ubuntu 20.04.”

Krok 1. Vývojové prostředí Pythonu

Django je postaven na Pythonu. Potřebujeme tedy robustní vývojové prostředí Pythonu se všemi potřebnými nástroji pro práci s aplikacemi v Pythonu. Již jsme se tím zabývali ve vyhrazeném návodu. Zde si ukážeme krátkou demonstraci.

Nejprve spusťte terminál a zadejte následující pří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

Dále nainstalujte pip – správce balíčků pro Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Poté nainstalujte některé další vývojové balíčky:

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

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

K vytvoření virtuálního prostředí potřebujeme také Python modul venv :

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Krok 2. Instalace MySQL Serveru

MySQL je populární relační systém řízení bází dat. Je open-source, stabilní a bohatý na funkce. Jako databázový server pro naši aplikaci v Django použijeme MySQL jako databázový server pro naši aplikaci v Django. Nainstalujte MySQL pomocí APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Poté ověřte instalaci:

$ systemctl status mysql

1	$ systemctl status mysql

Jedná se pouze o základní nastavení MySQL s výchozími možnostmi. Podívejte se na podrobnější návod na instalaci a konfiguraci MySQL.

Krok 3. Nastavení aplikace Django

Nyní jsme připraveni vytvořit naši aplikaci v Django. Pokud máte zájem o další podrobnou ukázku Django, podívejte se na náš návod „Installing the Django Web Framework on Ubuntu 20.04.”

Dále vytvořte vyhrazený adresář pro aplikaci. Název adresáře by měl odrážet název projektu:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

V adresáři projektu vytvořte virtuální prostředí Pythonu pomocí modulu venv :

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktivujte virtuální prostředí:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Nainstalujte Django pomocí pip:

$ pip install django

1	$ pip install django

Dále vytvořte nový projekt Django pomocí django-admin příkazu:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Krok 4. Konfigurace aplikace Django

Aplikace Django obsahuje všechny výchozí konfigurace. Pro náš účel musíme provést několik úprav.

Začněte úpravou konfiguračního souboru settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

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

Poté změňte časové pásmo:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Přidejte stroje, které mají povolen přístup k aplikačnímu serveru Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Poté změny aplikujte:

$ python manage.py migrate

1	$ python manage.py migrate

Nakonec vytvořte superuživatele pro naši webovou aplikaci Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Krok 5. Připojení aplikace Django k MySQL

Pro připojení k MySQL potřebujeme další knihovnu konektoru pro Python, která je kompatibilní s Django. Budeme používat mysqlclient.

Nejprve se ujistěte, že máme nainstalované potřebné balíčky:

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

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

Dále nainstalujte mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Vytvoření vyhrazené databáze

Pro naši aplikaci musíme vytvořit vyhrazenou databázi a databázového uživatele. Spusťte MySQL shell jako root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Vytvořte vyhrazenou databázi pro naši aplikaci Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Poté vytvořte vyhrazeného databázového uživatele pro aplikaci Django:

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

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

Nakonec udělte vyhrazenému uživateli plná oprávnění k vyhrazené databázi:

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

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

Změna konfigurace Django pro použití MySQL

Nyní musíme upravit některé konfigurace Django, aby mohl používat MySQL jako databázový server. Otevřete settings.py v textovém editoru:

$ nano settings.py

1	$ nano settings.py

Přejděte dolů k sekci DATABASES a vložte následující 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',

}

Dále upravte konfigurační soubor MySQL tak, aby obsahoval potřebné přihlašovací údaje k databázi:

$ sudo nano /etc/mysql/my.cnf

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

Na konec souboru přidejte následující 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

Restartujte MySQL, aby se změny projevily:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

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

Krok 6. Vytvoření modelu Django

Nyní jsme připraveni vytvořit nový model v našem projektu Django. Aktivujte virtuální prostředí:

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

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

V tomto umístění řekněte Djangu, aby vytvořil novou aplikaci:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Po vytvoření by měl strom souborů vypadat nějak takto. Zde bude soubor models.py obsahovat kódy pro náš vlastní model Django:

Zkontrolujte aktuální obsah souboru:

$ cat models.py

1	$ cat models.py

Pro demonstraci vytvoříme model pro blogové příspěvky s názvem Post. Bude obsahovat následující pole:

title: Název blogového příspěvku.
slug: Ukládá a generuje platné adresy URL pro webové stránky.
content: Text blogového příspěvku.
created_on: Datum vytvoření příspěvku.
author: Uživatel, který příspěvek vytvořil.

Otevřete soubor models.py v textovém editoru:

$ nano models.py

1	$ nano models.py

Importujme některá nezbytná rozhraní API pro náš model. Ve výchozím nastavení importuje rozhraní API pro modely. Budeme také potřebovat slugify API pro generování slugů, User pro autentizaci a reverse pro lepší a flexibilnější vytváření URL:

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

Dále přidejte metodu třídy s názvem Post. Bude obsahovat potřebná databázová pole jako 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()

Potřebujeme funkcionalitu pro generování URL a ukládání příspěvku. Je to důležité, protože to generuje unikátní odkazy odpovídající unikátním příspěvkům:

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)

Další sekce řekne modelu, jak řadit příspěvky a jak je zobrazovat na webové stránce. Tuto logiku zakódujeme pomocí vnitřní třídy Meta. Bude obsahovat dodatečnou logiku modelu, která se netýká definice 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

Nakonec budeme mít v tomto souboru funkci modelu Comment. Vyžaduje to přidání další třídy Comment s použitím models.Model jako její signatury. Bude obsahovat následující databázová pole:

name: Jméno komentujícího.
email: E-mailová adresa komentujícího.
text: Samotný obsah komentáře.
post: Příspěvek, ke kterému byl komentář přidán.
created_on: Čas vytvoření komentáře.

Kód bude vypadat přibližně 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 okamžiku bude náš soubor models.py vypadat takto:

Nakonec soubor uložte a zavřete editor.

Krok 7. Aktualizace nastavení Django

Model je vytvořen. Musíme však upravit některé konfigurační soubory, abychom model uvedli do provozu. Uvnitř settings.py musíme přidat náš model pod INSTALLED_APPS.

Otevřete settings.py v textovém editoru:

$ nano settings.py

1	$ nano settings.py

Zaregistrujte nový modul v sekci INSTALLED_APPS:

Uložte soubor a zavřete editor.

Krok 8. Migrace změn

Nyní, když jsme přidali všechny požadované modely, dalším krokem je aplikace těchto změn. Django aplikuje tato schémata na naši MySQL databázi.

Následující příkaz vygeneruje všechny potřebné migrační soubory. Výstup zobrazí umístění všech těchto souborů v adresáři projektu:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Následující příkaz vypíše všechny existující migrace:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Všimněte si, že všechny migrace jsou označeny kromě 0001_initial, která byla vytvořena jako součást modelů Post a Comment.

Následující příkaz ukáže, jaký SQL dotaz Django provede pro spuštění migrací:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Nyní už stačí pouze aplikovat migrace. Tyto migrace zapíší změny do databáze:

$ python manage.py migrate

1	$ python manage.py migrate

Step 9. Verifying Changes

To verify the changes, let’s have a look at our MySQL database. Start the MySQL shell as the Django user:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Next, change the current active database to the Django app database:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

List all the tables from the database:

$ SHOW TABLES;

1	$ SHOW TABLES;

Lastly, to see the content of any of the tables, use the DESCRIBE query:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Django Limitations with MySQL

When using MySQL as the database server for your Django app, there are a few things to keep in mind:

There’s not much support for transactions around schema-altering processes. Meaning, if a migration fails, it requires manually unpicking all the changes before trying another migration. There’s no way to roll back to an earlier point when the failed migration didn’t take place.
For most of the schema-altering processes, MySQL completely rewrites tables. In certain situations, it can be really time-consuming. At worst, the time complexity will be proportional to the number of rows to be added or columns to be removed. According to the official Django documentation, it could take one minute per million rows.
MySQL enforces a character limit for the name lengths of columns, tables, and indices. There’s also a limit on the total size of all columns and index covers. Django can go higher than the limit. Some backends other than MySQL can handle the higher limit of Django.

That’s why it’s strongly recommended to weigh your options and choose the appropriate one.

Final Thoughts

This guide successfully demonstrates how to add modules to an existing Django app. We used MySQL as the backend for the app. It also showcases some key Django concepts like models, how migration works, and how Django translates models into MySQL database tables.

Happy Computing!

Hark Labs

Autor · CloudSigma

Preslav Dobrev je kreativní designér ve společnosti CloudSigma, který se zaměřuje na konzistentní firemní identitu prostřednictvím tradičních i inovativních marketingových kanálů. Je zdatný v propojování umělecké vize se strategickým marketingem za účelem vytváření působivých příběhů značky.