Průvodce vytvořením aplikace pro zkracování adres URL s Django
Nejefektivnější metoda, jak se naučit Django či jakoukoli jinou dovednost, spočívá v praktickém využití nabytých znalostí prostřednictvím vytváření funkčních projektů.
Django představuje jeden z nejpopulárnějších frameworků pro tvorbu webových aplikací v Pythonu. Díky svým integrovaným funkcím a rozsáhlému výběru balíčků třetích stran si získal celosvětovou oblibu.
Je známé svou rychlostí, spolehlivostí a množstvím vestavěných nástrojů, jako je například systém ověřování uživatelů, který vám umožní soustředit se na klíčové funkce vaší aplikace. Dále můžete snadno implementovat externí balíčky pro složitější úkoly, jako je například Django-allauth, který umožňuje registraci uživatelů pomocí sociálních sítí.
Nicméně, Django je tak rozsáhlý rámec, že pro nováčky může být obtížné s ním začít. Django je komplexní nástroj.
V tomto návodu si proto společně krok za krokem vytvoříme plně funkční Django aplikaci.
Po dokončení tohoto tutoriálu budete schopni:
- Vytvořit aplikaci pro zkracování URL adres.
- Pochopit architekturu Django MVT.
- Osvojit si pracovní postup při vytváření Django projektů.
Požadavky pro začátek
Následující požadavky jsou doporučené pro snadnější sledování tohoto návodu. Pokud s některými z nich nemáte zkušenosti, nemusíte se obávat. Nejdůležitější je začít.
- Základní znalost příkazů UNIX (ls, cd, rm, touch).
- Základní porozumění třídám a funkcím v Pythonu.
- Python nainstalovaný na vašem počítači (samozřejmost, ale museli jsme ji zmínit).
- Zkušenosti s vývojem v Django jsou výhodou.
Veškerý kód z tohoto tutoriálu je dostupný v tomto Github repozitáři.
Nyní, když máte všechny potřebné informace, můžeme se pustit do práce.
Specifikace projektu
V tomto tutoriálu si vytvoříme zkracovač URL adres. Zkracovač URL je služba, která transformuje dlouhou URL adresu na kratší, snáze sdílitelnou verzi.
Například, pokud chcete sdílet tweet s odkazem na váš web, ale máte omezený počet znaků, můžete využít zkracovač URL adres.
Podívejme se na to graficky.
Zkracovač URL přijme dlouhou URL adresu a vygeneruje krátkou URL adresu. Toto je přesně to, co se naučíte vytvářet v tomto návodu.
Během tohoto projektu si procvičíte používání architektury MVT, osvojíte si základy návrhu databáze pomocí Django modelů a naučíte se, jak uživatelům zobrazovat data pomocí views, URL a šablon.
Struktura Django projektu
Webové aplikace v Django jsou postaveny na principu jednoho projektu, který se skládá z několika samostatných aplikací. Každá aplikace má své specifické funkce a může fungovat nezávisle.
Představte si komplexní webovou aplikaci, jako je například Stack Overflow. Její funkčnost je rozdělena do dvou hlavních oblastí:
- Správa uživatelů: Přihlášení, Odhlášení, Hodnocení, Oprávnění.
- Fórum: Otázky, Odpovědi, Štítky, Filtry.
Podle struktury Django by se projekt nazýval StackOverflow a obsahoval by dvě hlavní aplikace: aplikaci pro správu uživatelů a aplikaci pro fórum.
Každá z těchto aplikací má nezávislé funkce a obsahuje veškerý kód potřebný pro svou správnou činnost.
To zahrnuje modely (struktura databáze), views (zpracování požadavků a generování odpovědí), specifické URL schémata a samozřejmě šablony a statické soubory (obrázky, CSS, JavaScript). Každá aplikace Django je tak potenciálně znovu použitelná, protože dokáže fungovat sama o sobě.
Zkráceně, projekt označuje soubor konfigurací a aplikací, které tvoří webovou aplikaci. Aplikace Django je pak samostatnou součástí projektu, která je navržena pro vykonávání konkrétního úkolu.
Konfigurace Django projektu
V této části si nastavíme Django projekt. Budeme používat nástroje jako virtuální prostředí pro správu závislostí Pythonu a důležité skripty Django, jako jsou django-admin a manage.py.
Virtuální prostředí
Vřele doporučujeme pracovat s virtuálním prostředím při vývoji Django aplikací. Jedná se o efektivní způsob, jak udržovat specifickou sadu závislostí. Hlavním účelem je izolovat balíčky potřebné pro vývoj od globálních balíčků.
Vytvořme si virtuální prostředí pomocí vestavěného příkazu v Pythonu.
Poznámka: Tato metoda vyžaduje Python 3.6 nebo novější.
python -m venv .venv
Tento příkaz používá `python -m` nebo `python --mod`. V podstatě spouští modul nebo knihovnu jako skript. V našem případě je venv knihovna, kterou spouštíme, a .venv je název virtuálního prostředí, které chceme vytvořit.
Zjednodušeně řečeno, tento příkaz říká:
Pythone, spusť jako skript knihovnu venv a vytvoř virtuální prostředí s názvem .venv.
Nyní aktivujte vytvořené virtuální prostředí pomocí tohoto příkazu:
source .venv/bin/activate
Pro ověření, že v novém virtuálním prostředí nejsou nainstalovány žádné balíčky, spusťte:
pip freeze
Pokud jste správně aktivovali virtuální prostředí, nezobrazí se žádný výstup. Je to proto, že jsme dosud nic neinstalovali.
Instalace Djanga
Pro vytvoření naší aplikace pro zkracování URL adres začneme instalací balíčku Django. Jelikož se jedná o balíček třetí strany, musíme jej nainstalovat pomocí Pip (Pip Installs Packages).
$ pip install django
Collecting django
Downloading Django-3.2.1-py3-none-any.whl (7.9 MB)
|████████████████████████████████| 7.9 MB 344 kB/s
Collecting asgiref<4,>=3.3.2
Using cached asgiref-3.3.4-py3-none-any.whl (22 kB)
Collecting sqlparse>=0.2.2
Using cached sqlparse-0.4.1-py3-none-any.whl (42 kB)
Collecting pytz
Using cached pytz-2021.1-py2.py3-none-any.whl (510 kB)
Installing collected packages: asgiref, sqlparse, pytz, django
Successfully installed asgiref-3.3.4 django-3.2.1 pytz-2021.1 sqlparse-0.4.1
Poznámka: Symbol $ představuje váš shell prompt.
Pro ověření správné instalace znovu zkontrolujeme nainstalované balíčky v našem virtuálním prostředí.
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1
Není problém, pokud se verze, které získáte, liší od těch uvedených zde. Pokud je Django ve verzi 3.x, můžete bez obav pokračovat.
Zahájení Django projektu
Po instalaci Djanga je čas vytvořit strukturu našeho zkracovače URL adres. Vzpomínáte si, co je Django projekt? Vytvoříme ho spuštěním následujícího příkazu:
django-admin startproject config
V tomto příkazu django-admin je nástroj příkazového řádku, který provádí potřebné kroky k vytvoření Django projektu. Část "startproject" je příkaz spuštěný pomocí django-admin a config je název projektu, který si vytváříme.
Je důležité zdůraznit, že config může být libovolný název. Důvod, proč používáme config, je jen z praktických důvodů. Je vhodné střídat projekty a mít stále stejné pojmenování. Nebojte se proto použít jiné názvy projektů dle libosti.
Nyní vidíte, že máte složku config/ a uvnitř mnoho souborů. Později si probereme strukturu souborů projektu. Nyní vstupte do adresáře projektu a spusťte lokální server.
cd config/
Nejdůležitějším souborem, který budete používat, je skript manage.py. Má stejnou funkcionalitu jako django-admin, ale jeho hlavní výhodou je, že umožňuje spravovat nastavení při spuštění projektu.
Nyní se podíváme, zda vše funguje správně.
python manage.py runserver
Vytvoření aplikace pro zkracování URL
Je čas vytvořit hlavní aplikaci našeho projektu. Pro tento účel použijeme soubor manage.py.
python manage.py startapp urlshortener
Tím se vytvoří aplikace Django s názvem urlshortener. Pokud spustíte strom příkaz, dostanete něco takového.
.
├── config
│ ├── asgi.py
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── manage.py
└── urlshortener
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── tests.py
└── views.py
Pojďme si ujasnit různé soubory, které jsme si do této chvíle vytvořili. "config" je název našeho projektu, je to konvence. V config najdete soubor settings.py, kde definujete nastavení projektu. urls.py je celková konfigurace URL v projektu. Definuje URL cesty pro všechny aplikace v projektu.
Soubory asgi.py a wsgi.py prozatím necháme stranou. Jsou určeny pro konfiguraci aplikace v produkčním prostředí.
manage.py je Python skript, který umožňuje spouštět veškeré dostupné příkazy Django-admin.
Pokud se podíváte do složky urlshortener, což je název aplikace, kterou jsme právě vytvořili, uvidíte zvláštní složku s názvem "migrations/" a několik dalších souborů, které jsou nezbytné pro logiku každé aplikace.
apps.py obsahuje konfiguraci aplikace. Obvykle není třeba se s ním zaobírat, pokud neděláte pokročilé věci.
admin.py slouží k registraci vašich modelů, aby byly viditelné v administračním panelu Django.
models.py je klíčový soubor. V něm definujete modely, které (jednoduše řečeno) představují strukturu ukládání dat. O modelech si povíme více později.
Migrations/ je složka, kam se ukládají migrace Django. Později se na ni podíváme podrobněji.
tests.py je soubor, kde se ukládají testy. V tomto tutoriálu se testováním nebudeme zabývat.
views.py je soubor, kde jsou uloženy views. Zjednodušeně řečeno, definuje interakci uživatele s aplikací.
Instalace Django aplikace
Předtím než budeme pokračovat, otevřete soubor settings.py a upravte proměnnou INSTALLED_APPS přidáním aplikace urlshortener.
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# Custom apps
'urlshortener',
]
Toto je běžný postup při vytváření aplikací. Nezapomeňte ji vždy nainstalovat v nastavení projektu.
Principy architektury MVT
Architektura Model, View, Template je softwarový design pattern, který vývojáři v Django využívají pro tvorbu webových aplikací.
Je založena na 3 hlavních konceptech: Model (data), View (interakce uživatele s daty), Template (zobrazení dat uživateli).
Modely jsou Python třídy, které definují strukturu a chování dat. Obvykle každý model odpovídá jedné tabulce v databázi.
Views jsou jednoduše řečeno volatelné objekty, které přijímají požadavek od uživatele a generují odpověď. Mezi tím probíhá obchodní logika. Chápu, že pojem „obchodní logika“ může být nejasný, proto si ho vyjasníme. Obchodní logika je způsob, jak se data vytvářejí, ukládají a mažou, nic víc.
A konečně, šablony jsou textové dokumenty (obvykle HTML), které se zobrazují uživatelům. Jejich účelem je prezentovat data co nejjasněji. Django obsahuje vlastní mini-jazyk, nazývaný Django Template Language (DTL), který umožňuje vkládat Python kód do textových dokumentů.
Tvorba modelu zkracovače
Nyní, když máte základní přehled o architektuře MVT, se můžeme pustit do vytváření zkracovače URL v Django od začátku.
Nejprve si definujeme model zkracovače v souboru models.py.
'''
Url shortener model
'''
from django.db import models
# Create your models here.
class Shortener(models.Model):
'''
Creates a short url based on the long one
created -> Hour and date a shortener was created
times_followed -> Times the shortened link has been followed
long_url -> The original link
short_url -> shortened link https://domain/(short_url)
'''
created = models.DateTimeField(auto_now_add=True)
times_followed = models.PositiveIntegerField(default=0)
long_url = models.URLField()
short_url = models.CharField(max_length=15, unique=True, blank=True)
class Meta:
ordering = ["-created"]
def __str__(self):
return f'{self.long_url} to {self.short_url}'
Vím, je to poměrně rozsáhlá třída s mnoha neznámými prvky, ale nezoufejte. Projdeme si krok za krokem všechny klíčové části.
Popis modelu
Nejprve importujeme modul models. Tento modul obsahuje veškerou funkcionalitu, kterou potřebujeme pro tvorbu Django modelu.
Když se podíváme na model "Shortener", první věcí, které si musíme všimnout, je, že dědí od models.Model. Ve skutečnosti každý model v libovolné Django aplikaci musí být podtřídou models.Model třídy.
Následně definujeme všechna pole, která bude model v databázi obsahovat. Pole "created" je datum a čas vytvoření zkráceného odkazu, pro tento účel používáme DateTimeField. Argument auto_now_add=True zajistí, že se pole změní pouze při vytvoření instance.
Druhé pole, times_followed, odkazuje na počet použití zkrácené URL adresy. Je to PositiveIntegerField a nastavujeme výchozí hodnotu nula. To znamená, že při každém vytvoření instance, bude Django automaticky vyplňovat toto pole nulou.
Na druhé straně long_url odkazuje na URL adresu zadanou uživatelem. Jedná se o URLField, protože chceme, aby uživatel zadával pouze znaky ve tvaru: http://vasweb.cz.
Poslední pole je short_url a obsahuje zajímavé detaily. Je stanoveno, že může obsahovat maximálně 15 znaků, musí být unikátní, tzn. že se hodnoty v tomto poli nesmí opakovat. Nakonec nastavíme, že může být ponecháno prázdné, což znamená, že při práci s formuláři uživatelé nebudou muset psát svůj vlastní zkrácený kód.
Vnitřní třída Meta nám udává, jak se má třída chovat, a nastavíme, že řazení objektů zkracovače (Shortener.objects.all()) bude podle nejnověji vytvořených.
Metoda __str__ říká, jak má být model zobrazen. Pokud tedy máme objekt s long_url = "https://etechblog.cz.com/" a zkrácenou částí "123456", tak po vytisknutí uvidíme:
https://etechblog.cz.com/ to 123456
Nyní je čas najít způsob, jak ukládat krátký odkaz náhodným způsobem.
Tvorba zkracovací funkce
Vytvoříme 2 vlastní funkce. První vygeneruje náhodný kód a druhá zajistí, že se náhodné kódy v modelu Shortener nebudou opakovat. Pro tento účel vytvořte soubor utils.py v aplikaci "urlshortener".
touch utils.py
V tomto souboru použijeme funkci choice z vestavěného modulu random. Ta nám umožní snadno vybrat náhodné znaky pro vytvoření kódu.
'''
Utilities for Shortener
'''
from django.conf import settings
from random import choice
from string import ascii_letters, digits
# Try to get the value from the settings module
SIZE = getattr(settings, "MAXIMUM_URL_CHARS", 7)
AVAIABLE_CHARS = ascii_letters + digits
def create_random_code(chars=AVAIABLE_CHARS):
"""
Creates a random string with the predetermined size
"""
return "".join(
[choice(chars) for _ in range(SIZE)]
)
Jak vidíte, tato funkce vrací náhodný řetězec o délce určené v souboru nastavení, nebo ve výchozí hodnotě 7. Funkce getattr slouží k získání proměnné z modulu settings, aniž by vyvolala chybu, pokud proměnná není zadána.
Pojďme si to trochu spočítat. Pokud máme 7 míst, kde může být až 62 různých znaků, tak možné permutace jsou:
Díky tomuto rychlému výpočtu vidíme, že zkrácená část může být vyplněna až 2,5 biliony různých kódů. Takže můžeme z hlavy vypustit obavy z duplicitních náhodných URL.
I když existuje takové množství permutací, stále je zde malá šance na získání opakovaných zkrácených částí. To je problém, protože jsme pole shortened_url nastavili jako unikátní. Proto je následující funkce tak užitečná.
def create_shortened_url(model_instance):
random_code = create_random_code()
# Gets the model class
model_class = model_instance.__class__
if model_class.objects.filter(short_url=random_code).exists():
# Run the function again
return create_shortened_url(model_instance)
return random_code
Pojďme se podívat, co se tu děje. Funkce přijímá jako argument instanci modelu "Shortener". Nejprve funkce vygeneruje náhodný kód pomocí funkce create_random_code. Poté získá třídu modelu a zkontroluje, zda neexistuje jiný objekt se stejnou hodnotou short_url. Pokud ano, spustí se funkce znovu, pokud je vše v pořádku, vrátí náhodný kód.
Později si tuto funkci podrobněji prohlédneme pomocí shellu.
Po vytvoření užitkové funkce ji využijeme k tvorbě náhodných kódů v modelu zkracovače.
Úprava způsobu ukládání
Na konci třídy "Shortener" upravíme metodu save modelu. Tato metoda se volá pokaždé, když se objekt ukládá do databáze, podíváme se, jak ji využít.
# Import the function used to create random codes
from .utils import create_shortened_url
# At the end of the Shortener model
def save(self, *args, **kwargs):
# If the short url wasn't specified
if not self.short_url:
# We pass the model instance that is being saved
self.short_url = create_shortened_url(self)
super().save(*args, **kwargs)
Metodu save přepisujeme, což znamená, že zavádíme novou funkcionalitu do již existující metody nadřazené třídy. V podstatě tím Django říkáme, že pokaždé, když se uloží objekt "Shortener" a short_url není definována, tak se musí vyplnit náhodným kódem.
Provedení migrací
Nyní je čas provést a spustit migrace modelu Shortener. Provedeme to spuštěním následujících příkazů v kořenové složce projektu.
$ python manage.py makemigrations
Migrations for 'urlshortener':
urlshortener/migrations/0001_initial.py
- Create model Shortener
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions, urlshortener
Running migrations:
......
# Apply the URL shortener migrations
Applying urlshortener.0001_initial... OK
Zatím se nemusíte starat o to, co migrace znamenají. Jen mějte na paměti, že po spuštění těchto dvou příkazů, Django vytvoří db.sqlite databázi na základě vámi definovaných modelů.
Vytvořme si několik objektů pomocí Django shellu.
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://etechblog.cz.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://etechblog.cz.com' >>> print(s) https://etechblog.cz.com to kdWFVIc
V podstatě takto budou fungovat všechny objekty zkracovače.
Tvorba Views
Jak jsme již zmínili, view je jednoduchá funkce, která přijímá požadavek a vrací odpověď. Podívejme se, jak vytvořit jednoduchý view „Ahoj světe“.
Základní odpověď šablony
V souboru "urlshortener/views.py" vytvořte funkci home_view.
'''
Shortener views
'''
from django.shortcuts import render, get_object_or_404 # We will use it later
from django.http import HttpResponse
# Create your views here.
def home_view(request):
return HttpResponse("Hello world")
Vrací jednoduchou zprávu "Ahoj světe". Později uvidíte, jak bude vypadat v prohlížeči. Nyní vytvořte soubor "urls.py", do kterého umístíme URL schémata aplikace.
vytvořte urls.py
Vložte následující kód.
'''
Urls for shortener app urlshortener/urls.py
'''
from django.urls import path
# Import the home view
from .views import home_view
appname = "shortener"
urlpatterns = [
# Home view
path("", home_view, name="home")
]
Proměnná appname deklaruje jmenný prostor aplikace urlshortener.
Rychlé vysvětlení: importujeme funkci path, která vrací prvek, který má být zahrnut do URL schémat aplikace. Atribut name je jmenný prostor cesty, který je možné volat uvnitř šablon.
Nyní si upravíme celkové URL projektu.
# config/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
# Shortener Urls
path('', include('urlshortener.urls'))
]
Nyní znovu spusťte server.
python manage.py runserver
Po spuštění serveru se zobrazí jednoduchá zpráva "Ahoj světe". Je to proto, že jste do celkového projektu zahrnuli URL schémata z aplikace zkracovače URL.
Toto je pouze začátek. Nyní je čas vytvořit formulář, který umožní uživatelům vytvářet zkrácené URL adres.
Tvorba formulářů
V Django formulář je jednoduchá třída, která umožňuje získávat vstup od uživatele.
Vytvoříme soubor forms.py. Je zvykem ukládat všechny formuláře aplikace do tohoto souboru.
cd urlshortener/ touch forms.py
V tomto souboru vytvoříme třídu "ShortenerForm", která bude dědit z "ModelForm".
'''
Shortener Forms urlshortener/forms.py
'''
from django import forms
from .models import Shortener
class ShortenerForm(forms.ModelForm):
long_url = forms.URLField(widget=forms.URLInput(
attrs={"class": "form-control form-control-lg", "placeholder": "Your URL to shorten"}))
class Meta:
model = Shortener
fields = ('long_url',)
Jedná se o modelový formulář, protože jeho účelem je vytvářet modelové objekty z uživatelského vstupu. Používáme argument widget, který nám umožňuje specifikovat atribut "class" (třída v CSS, nikoliv Python). To proto, že později stylizujeme aplikaci pomocí Bootstrapu.
Kompletace View
Po vytvoření formuláře je čas dát aplikaci finální obchodní logiku.
Otevřete soubor views.py v aplikaci zkracovače a upravte view home_view. Můžete se podívat na Github repo, abyste získali představu o struktuře projektu.
Aplikace pro zkracování URL adres má dvě view:
Začneme domácím view, který je nejsložitější. Budete muset importovat model a formulář Shortener. Budeme používat funkci, protože chceme, abyste pochopili tok dat ve view. Budeme používat i cestu pro šablonu (kterou ještě nemáme vytvořenou).
Domovský View
'''
Shortener views
'''
from django.shortcuts import render # We will use it later
from django.http import HttpResponse, Http404, HttpResponseRedirect
# Model
from .models import Shortener
# Custom form
from .forms import ShortenerForm
# Create your views here.
def home_view(request):
template="urlshortener/home.html"
context = {}
# Empty form
context['form'] = ShortenerForm()
if request.method == 'GET':
return render(request, template, context)
elif request.method == 'POST':
used_form = ShortenerForm(request.POST)
if used_form.is_valid():
shortened_object = used_form.save()
new_url = request.build_absolute_uri('/') + shortened_object.short_url
long_url = shortened_object.long_url
context['new_url'] = new_url
context['long_url'] = long_url
return render(request, template, context)
context['errors'] = used_form.errors
return render(request, template, context)
View je založen na dvou podmínkách:
