Tworzenie modeli Django: Poradnik

Hark Labs2022-03-08 · 11 min read

Django to znany framework webowy do szybkiego tworzenia bezpiecznych i łatwych w utrzymaniu stron oraz aplikacji internetowych. Zbudowany przy użyciu Python, Django upraszcza tworzenie stron internetowych, pozwalając na zaoszczędzenie czasu i skupienie się na pisaniu aplikacji bez ponownego wymyślania koła za każdym razem. Django to darmowy projekt o otwartym kodzie źródłowym z solidną oficjalną dokumentacją, świetnym wsparciem społeczności oraz mnóstwem darmowego i płatnego wsparcia.

W tym poradniku zagłębimy się w tworzenie modeli Django. W Django model jest kluczowym źródłem informacji o Twoich danych. Modele opisują pola i zachowanie przechowywanych danych. Django używa modelu do generowania tabel bazy danych za pomocą ORM (Object Relational Mapping), również określanych jako modele.

Wymagania wstępne

Pracujemy na systemie operacyjnym opartym na systemie Unix, najlepiej serwerze chmurowym Ubuntu 20.04 jako systemie, na którym przeprowadziliśmy testy. Jeśli chcesz skonfigurować Django w podobnym środowisku, zapoznaj się z naszym samouczkiem „Jak zainstalować Django i skonfigurować środowisko programistyczne na Ubuntu 20.04.”

Krok 1. Środowisko programistyczne Python

Django jest zbudowane na Pythonie. Potrzebujemy więc solidnego środowiska programistycznego Python ze wszystkimi niezbędnymi narzędziami do pracy z aplikacjami Python. Omówiliśmy to już w dedykowanym poradniku. Tutaj przedstawimy krótką demonstrację.

Najpierw uruchom terminal i wykonaj następujące polecenia:

$ 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

Następnie zainstaluj pip – menedżer pakietów Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Następnie zainstaluj dodatkowe pakiety programistyczne:

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

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

Aby utworzyć środowisko wirtualne, potrzebujemy również modułu Python venv:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Krok 2. Instalacja serwera MySQL

MySQL to popularny relacyjny system zarządzania bazami danych. Jest to oprogramowanie o otwartym kodzie źródłowym, stabilne i bogate w funkcje. Użyjemy MySQL jako serwera bazy danych dla naszej aplikacji Django. Zainstaluj MySQL za pomocą APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Następnie zweryfikuj instalację:

$ systemctl status mysql

1	$ systemctl status mysql

To tylko podstawowa konfiguracja MySQL z domyślnymi opcjami. Zapoznaj się z bardziej szczegółowym przewodnikiem na temat instalacji i konfiguracji MySQL.

Krok 3. Konfiguracja aplikacji Django

Jesteśmy teraz gotowi do utworzenia naszej aplikacji Django. Jeśli interesuje Cię bardziej szczegółowa demonstracja Django, zapoznaj się z naszym samouczkiem „Instalacja frameworka webowego Django na Ubuntu 20.04.”

Następnie utwórz dedykowany katalog dla aplikacji. Nazwa katalogu powinna odzwierciedlać nazwę projektu:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

W katalogu projektu utwórz wirtualne środowisko Python za pomocą modułu venv:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktywuj środowisko wirtualne:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Zainstaluj Django za pomocą pip:

$ pip install django

1	$ pip install django

Następnie utwórz nowy projekt Django za pomocą polecenia django-admin:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Krok 4. Konfiguracja aplikacji Django

Aplikacja Django zawiera wszystkie domyślne konfiguracje. Na potrzeby naszego celu musimy wprowadzić pewne poprawki.

Zacznij od edycji pliku konfiguracyjnego settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

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

Następnie zmień strefę czasową:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Dodaj maszyny, które mają uprawnienia do dostępu do serwera aplikacji Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Następnie zastosuj zmiany:

$ python manage.py migrate

1	$ python manage.py migrate

Na koniec utwórz superużytkownika dla naszej aplikacji internetowej Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Krok 5. Łączenie aplikacji Django z bazą MySQL

Aby połączyć się z MySQL, potrzebujemy dodatkowej biblioteki łącznika Pythona, która jest kompatybilna z Django. Będziemy używać mysqlclient.

Najpierw upewnij się, że mamy zainstalowane niezbędne pakiety:

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

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

Następnie zainstaluj mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Tworzenie dedykowanej bazy danych

Dla naszej aplikacji musimy utworzyć dedykowaną bazę danych i użytkownika bazy danych. Uruchom powłokę MySQL jako root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Utwórz dedykowaną bazę danych dla naszej aplikacji Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Następnie utwórz dedykowanego użytkownika bazy danych dla aplikacji Django:

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

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

Na koniec nadaj dedykowanemu użytkownikowi pełne uprawnienia do dedykowanej bazy danych:

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

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

Zmiana konfiguracji Django w celu użycia MySQL

Teraz musimy zmodyfikować niektóre konfiguracje Django, aby mogło ono używać MySQL jako serwera bazy danych. Otwórz settings.py w edytorze tekstu:

$ nano settings.py

1	$ nano settings.py

Przewiń w dół do sekcji DATABASES i wklej następujący kod:

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

}

Następnie edytuj plik konfiguracyjny MySQL, aby zawierał niezbędne dane uwierzytelniające bazy danych:

$ sudo nano /etc/mysql/my.cnf

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

Dodaj następujący blok na końcu pliku:

[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

Uruchom ponownie MySQL, aby zmiany weszły w życie:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

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

Step 6. Creating a Django Model

Jesteśmy teraz gotowi do utworzenia nowego modelu w naszym projekcie Django. Aktywuj środowisko wirtualne:

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

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

W tej lokalizacji nakaż Django utworzenie nowej aplikacji:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Po utworzeniu drzewo plików powinno wyglądać mniej więcej tak. Tutaj plik models.py będzie zawierał kod dla naszego niestandardowego modelu Django:

Sprawdź aktualną zawartość pliku:

$ cat models.py

1	$ cat models.py

Dla celów demonstracyjnych utworzymy model dla postów na blogu o nazwie Post. Będzie on zawierał następujące pola:

title: Tytuł posta na blogu.
slug: Przechowuje i generuje prawidłowe adresy URL dla stron internetowych.
content: Tekst posta na blogu.
created_on: Data utworzenia posta.
author: Użytkownik, który utworzył post.

Otwórz plik models.py w edytorze tekstu:

$ nano models.py

1	$ nano models.py

Zaimportujmy kilka niezbędnych interfejsów API dla naszego modelu. Domyślnie importuje on API modeli. Będziemy również potrzebować API slugify do generowania uproszczonych nazw (slugów), User do uwierzytelniania oraz reverse do lepszego i bardziej elastycznego tworzenia adresów 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

Następnie dodaj metodę klasy o nazwie Post. Będzie ona zawierać niezbędne pola bazy danych, takie jak title, slug, content, created_on, oraz 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()

Potrzebujemy funkcjonalności do generowania adresów URL i zapisywania wpisów. Jest to ważne, ponieważ generuje unikalne linki pasujące do unikalnych wpisów:

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)

Kolejna sekcja poinstruuje model, jak sortować wpisy i wyświetlać je na stronie internetowej. Zakodujemy tę logikę za pomocą klasy wewnętrznej, Meta. Będzie ona zawierać dodatkową logikę modelu, która nie dotyczy definicji pól bazy danych:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Na koniec dodamy funkcjonalność modelu Comment w tym pliku. Wymaga to dodania kolejnej klasy Comment używającej models.Model jako swojej sygnatury. Będzie ona zawierać następujące pola bazy danych:

name: Nazwa komentującego.
email: Adres e-mail komentującego.
text: Treść samego komentarza.
post: Wpis, do którego dodano komentarz.
created_on: Czas utworzenia komentarza.

Kod będzie wyglądał mniej więcej tak:

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)

W tym momencie nasz plik models.py będzie wyglądał następująco:

Na koniec zapisz plik i zamknij edytor.

Krok 7. Aktualizacja ustawień Django

Model został utworzony. Musimy jednak zmodyfikować niektóre pliki konfiguracyjne, aby go uruchomić. Wewnątrz pliku settings.py, musimy dodać nasz model w sekcji INSTALLED_APPS.

Otwórz settings.py w edytorze tekstu:

$ nano settings.py

1	$ nano settings.py

Zarejestruj nowy moduł w sekcji INSTALLED_APPS:

Zapisz plik i zamknij edytor.

Krok 8. Migracja zmian

Teraz, gdy dodaliśmy wszystkie pożądane modele, kolejnym krokiem jest zastosowanie tych zmian. Django zastosuje te schematy w naszej bazie danych MySQL.

Poniższe polecenie wygeneruje wszystkie niezbędne pliki migracji. Wynik pokaże lokalizacje wszystkich tych plików w katalogu projektu:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Poniższe polecenie wyświetli listę wszystkich istniejących migracji:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Zauważ, że wszystkie migracje są zaznaczone z wyjątkiem 0001_initial, która została utworzona jako część modeli Post i Comment.

Poniższe polecenie pokaże, jakie zapytanie SQL wykona Django, aby przeprowadzić migracje:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Teraz wystarczy już tylko zastosować migracje. Te migracje zapiszą zmiany w bazie danych:

$ python manage.py migrate

1	$ python manage.py migrate

Krok 9. Weryfikacja zmian

Aby zweryfikować zmiany, przyjrzyjmy się naszej bazie danych MySQL. Uruchom powłokę MySQL jako użytkownik Django:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Następnie zmień bieżącą aktywną bazę danych na bazę danych aplikacji Django:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Wyświetl listę wszystkich tabel z bazy danych:

$ SHOW TABLES;

1	$ SHOW TABLES;

Na koniec, aby zobaczyć zawartość dowolnej z tabel, użyj zapytania DESCRIBE:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Ograniczenia Django w pracy z MySQL

Używając MySQL jako serwera bazy danych dla aplikacji Django, należy pamiętać o kilku kwestiach:

Wsparcie dla transakcji w procesach modyfikujących schemat jest bardzo ograniczone. Oznacza to, że jeśli migracja się nie powiedzie, konieczne jest ręczne cofnięcie wszystkich zmian przed podjęciem kolejnej próby migracji. Nie ma możliwości przywrócenia stanu do wcześniejszego punktu, w którym nieudana migracja nie miała miejsca.
W przypadku większości procesów modyfikujących schemat MySQL całkowicie przepisuje tabele. W niektórych sytuacjach może to być bardzo czasochłonne. W najgorszym przypadku złożoność czasowa będzie proporcjonalna do liczby dodawanych wierszy lub usuwanych kolumn. Według oficjalnej dokumentacji Django może to zająć jedną minutę na milion wierszy.
MySQL narzuca limit znaków dla długości nazw kolumn, tabel i indeksów. Istnieje również limit całkowitego rozmiaru wszystkich kolumn i pokrycia indeksów. Django może przekroczyć ten limit. Niektóre silniki bazodanowe inne niż MySQL radzą sobie z wyższym limitem Django.

Dlatego zdecydowanie zaleca się rozważenie dostępnych opcji i wybranie odpowiedniej.

Podsumowanie

Ten poradnik pomyślnie demonstruje, jak dodawać moduły do istniejącej aplikacji Django. Jako backendu dla aplikacji użyliśmy bazy MySQL. Przedstawia on również kluczowe pojęcia Django, takie jak modele, działanie migracji oraz sposób, w jaki Django tłumaczy modele na tabele bazy danych MySQL.

Miłego kodowania!

Hark Labs

Autor · CloudSigma

Preslav Dobrev jest projektantem kreatywnym w CloudSigma, skupiającym się na spójnej tożsamości biznesowej przy wykorzystaniu tradycyjnych i innowacyjnych kanałów marketingowych. Biegle łączy wizję artystyczną ze strategicznym marketingiem, tworząc wywierające wpływ narracje marki.