Przewodnik po tworzeniu aplikacji do skracania adresów URL za pomocą Django

Najlepszym sposobem na nauczenie się Django lub jakiejkolwiek innej umiejętności jest zastosowanie posiadanej wiedzy poprzez tworzenie projektów funkcjonalnych.

Django jest najczęściej używanym frameworkiem do tworzenia stron internetowych w Pythonie. Jego wbudowane funkcje i obszerna liczba pakietów innych firm sprawiły, że jest to jeden z najbardziej lubianych frameworków internetowych na całym świecie.

Jest szybki, niezawodny i ma wiele wbudowanych funkcji. Na przykład system uwierzytelniania dziur, który pozwala skupić się na głównych funkcjach aplikacji. Możesz także zainstalować pakiety zewnętrzne, aby wykonywać jeszcze bardziej złożone zadania, takie jak Django-allauth , który pozwala rejestrować użytkowników na ich kontach społecznościowych.

Ale ujawnijmy kilka faktów. Django jest tak ogromnym frameworkiem, że czasami trudno jest go zacząć.

Więc dzisiaj zamierzasz zbudować od podstaw całkowicie funkcjonalną aplikację Django.

Pod koniec tego samouczka:

• Napisałem aplikację do skracania adresów URL
• Zrozum wzorzec Django MVT
• Nauczyłem się przepływu pracy przy tworzeniu projektu

Wymagania wstępne

Wszystkie poniższe wymagania są opcjonalne i pomogą Ci je śledzić wraz z samouczkiem. Ale jeśli nie masz doświadczenia z żadnym z nich, nie martw się. Najważniejszym krokiem jest pierwszy.

• Podstawowa znajomość poleceń UNIX (ls, cd, rm, touch)
• Podstawowe zrozumienie klas i funkcji Pythona
• Python zainstalowany na twoim komputerze (może oczywiste, ale musiałem go dołączyć)
• Byłoby świetnie, gdybyś już coś zbudował z Django

Cały działający kod będzie dostępny w tym repozytorium Github.

Teraz, gdy masz krystalicznie czyste poprzednie koncepcje, przejdźmy do sprawy.

Oświadczenie o projekcie

W tym samouczku zbudujesz skracacz adresów URL. Zasadniczo skracacz adresów URL to usługa, która pobiera długi adres URL i zamienia go w kompaktowy.

Na przykład, jeśli chcesz udostępnić tweeta i chcesz dołączyć link do swojej witryny, ale napotykasz limit znaków, możesz użyć skracacza adresów URL.

Zobaczmy to z grafiką.

Jak widać, skracacz adresów URL otrzymuje długi adres URL i zwraca krótki. To jest dokładnie to, co zamierzasz dzisiaj zbudować.

Dzięki temu projektowi przećwiczysz użycie wzorca MVT, poznasz podstawy projektowania baz danych z modelami Django oraz nauczysz się wyświetlać informacje użytkownikowi za pomocą widoków, adresów URL i szablonów.

Struktura projektu Django

Zasadniczo witryna Django jest zbudowana na jednym projekcie i wielu oddzielnych aplikacjach . Każda z tych aplikacji ma określoną funkcjonalność i może działać samodzielnie.

Wyobraźmy sobie złożoną aplikację internetową, taką jak Stackoverflow. Jego funkcjonalność opiera się na dwóch głównych aspektach.

• Zarządzanie użytkownikami: logowanie, wylogowanie, reputacja, uprawnienia
• Forum: pytania, odpowiedzi, tagi, filtry

Tak więc, zgodnie ze strukturą witryny Django, projekt miałby nazwę StackOverflow, która ma dwie główne aplikacje. Aplikacja użytkowników i aplikacja forum .

Każda z tych aplikacji ma niezależną funkcjonalność. Oznacza to, że oba zawierają cały kod, którego potrzebują do poprawnego działania.

Obejmuje to modele (struktura bazy danych), widoki (żądania i odpowiedzi), określone wzorce adresów URL oraz oczywiście szablony i pliki statyczne (obrazy, CSS, JavaScript). Oznacza to, że każda aplikacja Django może być ponownie wykorzystana, ponieważ jest w stanie działać samodzielnie.

W skrócie, projekt odnosi się do zestawu konfiguracji i aplikacji, które mają na celu zbudowanie aplikacji internetowej. Z drugiej strony aplikacja Django jest częścią projektu, która jest samowystarczalna (posiada wszystko, czego potrzebuje do działania), a jej celem jest wykonanie określonej operacji.

Skonfiguruj projekt Django

W tej sekcji masz zamiar skonfigurować projekt Django. W tym celu będziesz używać różnych narzędzi, takich jak środowisko wirtualne, do organizowania zależności Pythona i najważniejszych skryptów Django. Django-admin i manage.py

Wirtualne środowisko

Zawsze polecam pracę ze środowiskami wirtualnymi podczas budowania aplikacji z Django. Jest to najskuteczniejszy sposób na utrzymanie określonego zestawu zależności. Ale jego głównym celem jest odizolowanie pakietów rozwojowych od globalnych.

Stwórzmy więc wirtualne środowisko z wbudowanym poleceniem formularza Python.

Uwaga: ta metoda wymaga do działania Pythona 3.6 lub nowszych wersji.

 python -m venv .venv

To polecenie używa polecenia python -m lub python -mod . Zasadniczo uruchamia moduł lub bibliotekę jako skrypt. Zgodnie ze znaczeniem tego polecenia, venv jest biblioteką, którą uruchamiamy, a .venv odnosi się do nazwy środowiska wirtualnego, które chcemy stworzyć.

Więc w prostym języku to polecenie oznacza.

Hej Python, uruchom jako skrypt wbudowaną bibliotekę venv i utwórz nazwę virtualenv .venv

Teraz nadszedł czas, aby aktywować właśnie utworzone środowisko wirtualne za pomocą następującego polecenia.

 source .venv/bin/activate

Aby zapewnić, że masz zero pakietów zainstalowanych w nowym venv, uruchamiasz.

 pip freeze

Jeśli poprawnie aktywowałeś środowisko wirtualne, nie otrzymasz żadnych danych wyjściowych. To dlatego, że jeszcze niczego nie zainstalowaliśmy.

Wejdźmy do Django

Aby stworzyć naszą aplikację do skracania adresów URL, zaczniemy od zainstalowania pakietu Django. Django jest pakietem innej firmy, dlatego musimy go zainstalować za 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

Uwaga: Pamiętaj, że $ to nic innego jak symbol Twojej powłoki.

Aby sprawdzić, czy instalacja przebiegła poprawnie, ponownie sprawdzamy zainstalowane pakiety naszego venv.

 $ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1

Nie martw się, jeśli wersje, które otrzymujesz, różnią się od moich. Jeśli Django nadal działa w wersji 3.x, możesz kontynuować bez problemu.

Rozpoczęcie projektu Django

Po zainstalowaniu Django nadszedł czas na stworzenie struktury witryny skracacza adresów URL. Pamiętasz, czym jest projekt Django? Stwórzmy jeden, uruchamiając następujące polecenie.

 django-admin startproject config

Wyjaśniając wszystko na temat tego polecenia, django-admin to narzędzie wiersza poleceń, które wykonuje wszystkie zadania potrzebne do stworzenia projektu Django. Część „startproject” to polecenie uruchamiane przez narzędzie Django-admin, a config to nazwa projektu, który zamierzamy utworzyć.

Należy podkreślić, że konfiguracja może mieć dowolną nazwę. Powodem, dla którego używam config jako nazwy tego projektu, jest właśnie wygoda. Fajnie jest przełączać się między projektami i nadal mieć tę samą konwencję nazewnictwa. Nie bój się więc używać innych nazw projektów, kiedy tylko chcesz.

Jak możesz zauważyć, masz teraz folder config/, aw środku jest wiele plików. Później zobaczymy strukturę plików projektu. Na razie wejdźmy do katalogu projektu i uruchommy lokalny serwer.

 cd config/

Najważniejszym plikiem, którego będziesz używać, jest skrypt manage.py . Ma taką samą funkcjonalność jak django-admin , ale główną zaletą korzystania z niego jest możliwość zarządzania ustawieniami podczas uruchamiania projektu.

Zobaczmy teraz, czy wszystko działa poprawnie.

 python manage.py runserver

Tworzenie aplikacji do skracania adresów URL

Czas stworzyć główną aplikację projektu. Do wykonania tego zadania użyjesz pliku manage.py .

 python manage.py startapp urlshortener

Tworzy to aplikację Django o nazwie urlshortener . Jeśli uruchomisz polecenie tree, otrzymasz coś takiego.

 . ├── 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

Wyjaśnijmy różne pliki utworzone do tego momentu. „config” to nazwa naszego projektu i jest tak nazwana tylko na konwencję. Wewnątrz pliku config otrzymujesz settings.py , jest to plik, w którym ustawiasz wszystkie ustawienia swojego projektu. urls.py to ogólna konfiguracja adresów URL w projekcie. Definiuje ścieżki URL wszystkich aplikacji wewnątrz projektu.

Nie przejmuj się zbytnio asgi.py i wsgi.py Są to pliki, które umożliwiają skonfigurowanie aplikacji we wdrożeniu.

manage.py to skrypt Pythona, który umożliwia uruchamianie wszystkich dostępnych poleceń Django-admin.

urlshortener do urlshortener który jest nazwą właśnie utworzonej aplikacji, możesz zauważyć, że istnieje dziwny folder o nazwie „migrations/” i kilka innych plików, które są kluczowe dla logiki każdej aplikacji.

apps.py to miejsce, w którym znajduje się konfiguracja aplikacji. Zwykle nie zadzierasz z tym, z wyjątkiem tego, że robisz całkiem zaawansowane rzeczy.

admin.py to miejsce, w którym rejestrujesz swoje modele, aby były widoczne w panelu administracyjnym Django.

models.py jest najważniejszy. Wewnątrz tego modułu musisz zdefiniować modele, które (mówiąc niejasno) są sposobem przechowywania danych. Więcej o modelach dowiesz się później.

migrations/ to folder, w którym przechowywane są migracje Django. Przyjrzymy się dokładniej później.

tests.py to plik, w którym przechowywane są testy. W tym samouczku nie będziemy omawiać testowania.

views.py to plik przechowujący widoki. Zasadniczo określa, w jaki sposób użytkownik będzie wchodzić w interakcję ze wszystkimi aspektami Twojej aplikacji.

Instalowanie aplikacji Django

Przed kontynuowaniem otwórz plik settings.py i zmodyfikuj zmienną INSTALLED_APPS , dodając aplikację 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', ]

Jest to rutynowy proces podczas tworzenia aplikacji. Więc za każdym razem, gdy to robisz, nie zapomnij zainstalować go w ustawieniach projektu.

Zrozumienie wzorca MVT

Wzorzec Model, Widok, Szablon to wzorzec projektowania oprogramowania, którego programiści Django używają do tworzenia aplikacji internetowych.

Opiera się na 3 głównych koncepcjach. Model (dane), Widok (interakcja użytkownika z danymi), Szablon (Jak użytkownicy widzą dane).

Modele to klasy Pythona, które definiują wszystkie pola i zachowanie danych, które chcesz przechowywać. Zwykle każdy model odnosi się do unikalnej tabeli w bazie danych

Widoki w swoim najprostszym wyrażeniu to wywoływalne, które przyjmują żądanie od użytkownika i generują odpowiedź. Pomiędzy tym procesem zachodzi logika biznesowa. Wiem, że „logika biznesowa” jest dość niejasnym pojęciem, więc wyjaśnię dokładnie, co to jest. Logika biznesowa to sposób tworzenia, przechowywania i usuwania danych, to wszystko.

Wreszcie szablony to dokumenty tekstowe (zwykle HTML), które są pokazywane użytkownikom. Jego celem jest prezentacja danych tak czystych, jak to tylko możliwe. Django zawiera mini-język zwany językiem szablonów Django (DTL), który pozwala na włączenie części mocy Pythona do dokumentów tekstowych.

Utwórz model Shortener

Po szybkim zrozumieniu wzorca MVT, przejdźmy do tworzenia od podstaw skracacza adresów URL Django.

Przede wszystkim zdefiniujmy model models.py wewnątrz pliku 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}'

Ja wiem. To dość duża klasa, w której dzieje się wiele dziwnych rzeczy, ale nie rozpaczaj. Przejdę krok po kroku do każdej ważnej rzeczy.

Wyjaśnienie modelu

Przede wszystkim importujemy moduł models . Ten moduł zawiera wszystkie funkcje potrzebne do stworzenia modelu Django.

Patrząc na model „Shortener”, pierwszą rzeczą, na którą należy zwrócić uwagę, jest to, że rozszerza models.Model . W rzeczywistości każdy model w dowolnej aplikacji Django musi być podklasą klasy models.Model .

Następnie definiujemy wszystkie pola, które model będzie miał w bazie danych. Pole „utworzone” to data i godzina utworzenia skróconego linku, dlatego do stworzenia tego rodzaju funkcjonalności używamy DateTimeField . Używamy argumentu auto_now_add=True, ponieważ chcemy, aby pole było zmieniane tylko podczas tworzenia instancji.

Drugie pole times_followed odnosi się do czasów użycia skróconego adresu URL. Jest to PositiveIntegerField i domyślnie określamy zero. Oznacza to, że za każdym razem, gdy instancja times_followed pole times_followed , Django wypełni to pole wartością 0.

Z drugiej strony long_url odnosi się do adresu URL wprowadzanego przez użytkownika. Jest to URLField , ponieważ chcemy, aby użytkownik wprowadzał tylko znaki z formularza: http://yoursite.com .

Ostatnie pole to short_url i zawiera interesujące szczegóły. Określamy, że może mieć tylko 15 znaków, musi być unikalny, co oznacza, że ​​w tym polu nie mogą się powtarzać elementy. Na koniec zaznaczamy, że można go pozostawić pustym, co oznacza, że ​​podczas pracy z formularzami użytkownicy nie będą musieli pisać własnego kodu skróconego.

Wewnętrzna klasa Meta mówi nam, jak klasa ma się zachowywać, a my ustawiamy, że kolejność (wywołując Shortener.objects.all() ) obiektów skracania będzie odróżniona od najnowszych.

Metoda __str__ mówi, jak ma być wydrukowany model. Więc jeśli mamy obiekt z long_url = „https://geekflare.com/” i skróconą częścią „123456” i drukujemy go.

 https://geekflare.com/ to 123456

Teraz nadszedł czas, aby znaleźć sposób na zapisanie krótkiego linku w losowy sposób.

Tworzenie funkcjonalności skracania

Zamierzamy stworzyć 2 niestandardowe funkcje. Pierwszy wygeneruje losowy kod, a drugi zapobiegnie otrzymywaniu powtarzających się losowych kodów z modelu Shortener. Aby to zrobić, utwórz plik utils.py w aplikacji „urlshortener”.

 touch utils.py

Wewnątrz tego pliku użyjemy funkcji select z wbudowanego modułu random. Ułatwia to zadanie wyboru losowych znaków do stworzenia kodu.

 ''' 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 widać, funkcja ta zwraca losowy ciąg o długości określonej w pliku ustawień lub domyślnie 7. Używasz funkcji getattr, aby pobrać zmienną z modułu ustawień, ale bez zgłaszania błędu, jeśli zmienna nie jest określona.

Zróbmy trochę matematyki. Jeśli mamy 7 miejsc, w których na każde miejsce może być do 62 dostępnych znaków, możliwe permutacje to:

Tak więc na podstawie tych szybkich obliczeń skróconą część można wypełnić do 2,5 biliona różnych kodów. Możemy więc zapomnieć o wydostaniu się z losowo skróconych adresów URL.

Chociaż może istnieć tak wiele permutacji, istnieje małe prawdopodobieństwo, że powtórzą się skrócone części. Jest to problem, ponieważ ustawiliśmy pole shortened_url aby było unikalne. Dlatego poniższa funkcja jest tak przydatna.

 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

Zobaczmy, co się tutaj dzieje. Funkcja przyjmuje jako argument instancję modelu „Shortener”. Po pierwsze, funkcja generuje losowy kod za pomocą funkcji create_random_code . Następnie pobiera klasę modelu i sprawdza, czy istnieje inny obiekt, który ma ten sam short_url . Jeśli tak, uruchamia się jeszcze raz, ale jeśli wszystko jest w porządku, zwraca random_code.

Później wejdziesz w interakcję z powłoką, aby dokładnie przyjrzeć się tej funkcji.

Po utworzeniu funkcji użytkowej wykorzystajmy ją do tworzenia losowych kodów w modelu skracania.

Modyfikowanie metody zapisywania

Na końcu klasy „Shortener” zmodyfikujesz metodę zapisu modelu. Metoda save jest wywoływana za każdym razem, gdy obiekt jest zapisywany w bazie danych, więc tutaj zobaczymy, jak z niej korzystać.

 # 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)

Metoda save jest nadpisywana, co oznacza, że ​​wprowadzasz nową funkcjonalność do istniejącej wcześniej metody nadrzędnej. Zasadniczo mówi Django, że za każdym razem, gdy obiekt „Shortener” jest zapisywany, a short_url nie jest określony, musi być wypełniony losowym kodem.

Uruchamianie migracji

Teraz czas na wykonanie i uruchomienie migracji modelu Shortener. Aby to zrobić, uruchom następujące polecenia w głównym folderze 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

Na razie nie musisz się martwić, czym są migracje. Pamiętaj tylko, że po uruchomieniu tych dwóch poleceń Django tworzy plik bazy danych db.sqlite na podstawie zdefiniowanych modeli.

Stwórzmy kilka obiektów za pomocą powłoki Django.

 $ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://geekflare.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://geekflare.com' >>> print(s) https://geekflare.com to kdWFVIc

Tak właśnie będą działać wszystkie skracacze.

Pisanie poglądów

Jak powiedziałem wcześniej, widok to prosta funkcja, która przyjmuje żądanie i zwraca odpowiedź. Zobaczmy więc, jak stworzyć powitalny światopogląd.

Podstawowa odpowiedź szablonu

Wewnątrz pliku „urlshortener/views.py” utwórz funkcję home_view . aaa

 ''' 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")

Zwraca prosty komunikat „Witaj świecie”. Później zobaczysz, jak to wygląda w przeglądarce. Teraz utwórz „urls.py”, będą tam stały wszystkie wzorce adresów URL aplikacji.

touch urls.py


Dodaj następujący kod.

 ''' 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") ]

Zmienna appname deklaruje (jak sugeruje jej nazwa) przestrzeń nazw aplikacji urlshortener.

Wyjaśniając szybko, że importujemy funkcję path, która zwraca element do uwzględnienia we wzorcach url aplikacji. Atrybut name jest przestrzenią nazw ścieżki, którą w razie potrzeby można wywołać wewnątrz szablonów.

Teraz zmodyfikujmy ogólne adresy 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')) ]

Teraz ponownie uruchommy serwer.

 python manage.py runserver

Jeśli uruchomisz serwer, otrzymasz prostą wiadomość „Hello world”. Dzieje się tak, ponieważ dołączasz wzorce url z aplikacji do skracania adresów URL do całego projektu.

To tylko punkt wyjścia. Teraz nadszedł czas na stworzenie formularza, który umożliwi użytkownikowi samodzielne tworzenie skróconych adresów URL.

Tworzenie formularzy

W Django formularz jest prostą klasą, która pozwala na uzyskanie danych wejściowych od Użytkownika.

Zamierzasz utworzyć plik types.py. Jest to konwencja przechowywania wszystkich form aplikacji w tym pliku.

 cd urlshortener/ touch forms.py

Wewnątrz tego pliku utworzysz klasę „ShortenerForm”, która rozciąga się od „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',)

Jest to formularz modelu, ponieważ jego celem jest utworzenie obiektu modelu na podstawie danych wejściowych użytkownika. Korzystamy również z argumentu widżetu, który pozwala nam określić atrybut „class” (klasa w CSS, a nie python). Dzieje się tak dlatego, że później będziemy stylizować aplikację za pomocą bootstrapu.

Wykańczanie widoków

Po zbudowaniu formularzy czas na stworzenie ostatecznej logiki biznesowej aplikacji.

Przejdź do pliku views.py w aplikacji skracającej i zmodyfikuj widok home_view . W tej chwili możesz sprawdzić repozytorium Github, aby zorientować się, jak wygląda struktura projektu.

Istnieją dwa widoki aplikacji do skracania adresów URL:

1. Widok strony głównej: pokazuje skrócony formularz i nowy adres URL, jeśli formularz został już przesłany.
2. Widok przekierowania: przekierowuje do długiego adresu URL i dodaje 1 do obserwowanych czasów.

Zacznijmy od widoku głównego, który jest najbardziej złożony. Będziesz musiał zaimportować model i formularz Shortener. Nadal używasz funkcji, ponieważ chcę, abyś zrozumiał cały przepływ danych w widoku. Ponadto będziesz używać ścieżki do szablonu (który nie został jeszcze utworzony).

Widok domu

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

Widok opiera się na dwóch warunkach warunkowych:

1. Gdy metoda HTTP równa się GET: Przekazujemy tylko jako kontekst, formularz Shortener używany do tworzenia obiektów Shortener.
2. Gdy metoda HTTP równa się POST: Nadal przekazujemy formularz w kontekście, ponieważ chcemy, aby użytkownik mógł wprowadzić inny adres URL. Ale przekazujemy żądanie Post do innego formularza o nazwie used_form.

build_absolute_uri sposobem na dynamiczne uzyskanie pełnego adresu URL witryny jest użycie metody obiektu żądania build_absolute_uri .

 >>> print(request.build_absolute_uri('/')) 'https://localhost:8080/'

Jako bezpieczny sposób przetwarzania błędnego żądania (użytkownik nie wprowadził poprawnego adresu URL), otrzymujemy błędy formularza, przekazujemy je jako kontekst i renderujemy szablon w normalny sposób. Później zobaczysz, jak zaimplementować wyświetlanie błędów w szablonie.

Przekieruj widok

redirect_url_view jest nieco prostszy. Jest to widok szczegółowy, co oznacza, że ​​widok działa tylko z obiektem.

Ta funkcja przyjmuje jako parametry żądanie użytkownika i skróconą część adresu URL. Nie jest konieczne potwierdzanie typu żądania, które otrzymujemy, ponieważ w tym widoku nie pracujemy z formularzami.

 def redirect_url_view(request, shortened_part): try: shortener = Shortener.objects.get(short_url=shortened_part) shortener.times_followed += 1 shortener.save() return HttpResponseRedirect(shortener.long_url) except: raise Http404('Sorry this link is broken :(')

Chronimy widok za pomocą instrukcji try/except na wypadek, gdyby skrócona część nie została znaleziona w bazie danych. Jeśli obiekt zostanie znaleziony, dodaje 1 do pola times_followed i przekierowuje za pomocą funkcji HttpResponseRedirect do adresu URL witryny odpowiadającego times_followed kodowi.

Aktualizowanie adresów URL

Po utworzeniu dwóch widoków aplikacji nadszedł czas, aby utworzyć wzorce końcowego adresu URL, dodając ścieżkę do redirect_url_view .

Jak zwykle zaczynasz od zaimportowania widoków, a następnie utworzenia funkcji ścieżki i przekazania jej jako argumentów:

• Trasa URL
• Widok wskazujący na ścieżkę
• Nazwa ścieżki

 ''' Urls for shortener app urlshortener/urls.py ''' from django.urls import path # Import the home view from .views import home_view, redirect_url_view appname = "shortener" urlpatterns = [ # Home view path('', home_view, name='home'), path('<str:shortened_part>', redirect_url_view, name='redirect'), ]

Przy tej konfiguracji adresu URL routing aplikacji wygląda tak.

• localhost:8000/ Gospodarz localhost:8000/ : Widok domowy
• localhost:8000/URL-code : Przekierowanie do długiego adresu URL

Tworzenie szablonów

Już prawie jesteś. Jedyną rzeczą, która oddziela Cię od zbudowania tej aplikacji, jest interfejs użytkownika. W tym celu używamy szablonów Django.

Szablony służą do renderowania przejrzystego interfejsu użytkownikowi aplikacji. Pliki te są tworzone wewnątrz aplikacji w podwójnej strukturze folderów w postaci: „szablony/nazwa aplikacji”

 # urlshortener directory mkdir -p templates/urlshortener/

Uwaga: Podwójna struktura folderów i język szablonów Django wykraczają poza zakres tego samouczka, ale możesz o nich przeczytać w oficjalnej dokumentacji.

Szablon bazowy

Django umożliwia dziedziczenie szablonów. Oznacza to, że możemy mieć szablon bazowy i rozszerzać go w celu przestrzegania zasady DRY (Don't repeat yourself).

 cd templates/urlshortener touch base.html

Plik base.html jest konwencją i oznacza, że ​​każdy inny szablon w aplikacji musi być rozszerzeniem tego.

 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Django Url shortener</title> <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous" /> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css" integrity="sha512-iBBXm8fW90+nuLcSKlbmrPcLa0OT92xO1BIsZ+ywDWZCvqsWgccV3gFoRBv0z+8dLJgyAHIhR35VZc2oM/gI1w==" crossorigin="anonymous" /> </head> <body> {% block body %} {% endblock body %} <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous" ></script> </body> </html>

Zamierzamy użyć bootstrap CDN, aby stworzyć szybki i ładny interfejs bez potrzeby używania plików CSS lub javascript.

Jeśli chcesz dowiedzieć się więcej o tagach DTL, możesz to zrobić za pomocą oficjalnych dokumentów.

Szablon domu

Szablon domowy, dziedziczony z pliku base.html. Oznacza to, że ten szablon zawiera cały kod HTML z pliku nadrzędnego.

 {% extends 'urlshortener/base.html' %} {% block body %} <div class="container"> <div class="card mt-5"> <div class="card-header text-center py-3"> <h1>URL Shortner Application <i class="fas fa-link px-2"></i></h1> </div> <div class="px-3 py-4"> <form action="" method="POST"> {% csrf_token %} <div class="row g-1"> <div class="col-10">{{form.long_url}}</div> <div class="col-2"> <button class="btn btn-success btn-lg w-100" type="submit"> Shorten </button> </div> </div> </form> </div> </div> {% if errors %} <div class="alert alert-danger mt-4" role="alert"> <p>{{errors}}</p> </div> {% endif %} {% if new_url %} <div class="mx-auto text-center mt-5"> <h2 class="text-danger">Your shortened Url</h2> <p>You can copy the Link below and share it with your friends</p> <p class="">{{new_url}}</p> <p><span class="text-danger">Previous URL:</span> {{long_url}}</p> </div> {% endif %} </div> {% endblock body %}

Szybko wyjaśnię przepływ danych w tym szablonie:

• Wyświetlony zostanie formularz skracania. Wewnątrz ustawiony jest token crsf (przyczyny bezpieczeństwa) i wyświetlane jest tylko długie pole adresu URL formularza. Pamiętaj, że to pole ma klasę CSS „form-control form-control-lg”, ponieważ ustawiamy to w formularzu.
• Jeśli zostaną znalezione jakieś błędy, pokaż je
• Jeśli operacja POST powiedzie się, zostanie wyświetlony nowy adres URL.

Ostateczna aplikacja

Gratulacje! . Zbudowałeś kompletną funkcjonalną aplikację do skracania adresów URL za pomocą Django.

Oto kilka zrzutów ekranu, jak wygląda aplikacja.

Zdobądź tylko:

Błąd skracania adresu URL:

Udany skrócony adres URL:

Przekierowany adres URL:

Co myślisz o udostępnieniu komuś wersji demonstracyjnej tej aplikacji do skracania adresów URL? Sprawdź, jak udostępnić aplikację Django Demo w Internecie.

Wyzwanie

Jeśli czujesz się komfortowo ze swoimi umiejętnościami Django, dlaczego nie ćwiczyć z wyzwaniem?.

Sklonuj kod tej aplikacji i stwórz system uwierzytelniania, w którym tylko zarejestrowani użytkownicy mogą skracać swoje adresy URL.

Kiedy skończysz, wyślij pull request i wyślij mi wiadomość ping na Twitterze, aby zaprezentować swoje osiągnięcia.

Zawijanie

Dotarłeś do końca tego samouczka. Wierz lub nie, ale właśnie przejrzałeś wszystkie główne aspekty tworzenia projektu Django. Mam nadzieję, że okazało się to niezwykle przydatne.

W tym samouczku:

• Dowiedz się o przepływie pracy przy tworzeniu aplikacji Django.
• Zbudowałem projekt CV
• Zrozumieć różnice i strukturę projektów Django i aplikacji Django.
• Odkryto wzór MVT.
• Utworzone widoki bazowe funkcji
• Używał Django ORM (Object Relational Mapper) do tworzenia prostych modeli

To wszystko, framework sieciowy Django ma wiele do omówienia, więc bądź w kontakcie, aby uzyskać więcej niesamowitych samouczków.