Den beste måten å lære Django, eller en hvilken som helst ferdighet, er ved å bruke kunnskapen du har ved å lage funksjonelle prosjekter.
Django er det mest brukte Python-nettutviklingsrammeverket. Dens innebygde funksjoner og omfattende mengde tredjepartspakker har gjort den til en av de mest populære nettrammene over hele verden.
Den er rask, pålitelig og har mange innebygde funksjoner. For eksempel et hullautentiseringssystem som lar deg fokusere på hovedfunksjonene i appen din. Du kan også installere eksterne pakker for å utføre enda mer komplekse oppgaver, som Django-allauth, som lar deg registrere brukere med deres sosiale kontoer.
Men la oss avsløre noen fakta. Django er et så stort rammeverk som noen ganger er utfordrende å komme i gang med det.
Så i dag skal du bygge fra bunnen av en helt funksjonell Django-applikasjon.
Ved slutten av denne opplæringen vil du:
- Har skrevet en URL-forkorter-app
- Forstå Django MVT-mønsteret
- Har lært arbeidsflyten for å lage et prosjekt
Innholdsfortegnelse
Forhåndskrav
Alle de følgende kravene er valgfrie og vil hjelpe deg å følge veiledningen. Men hvis du ikke har erfaring med noen av disse, ikke bekymre deg. Det viktigste trinnet er det første.
- Grunnleggende forståelse av UNIX-kommandoer (ls, cd, rm, touch)
- Grunnleggende forståelse av Python-klasser og funksjoner
- Python installert på datamaskinen din (kanskje åpenbart, men jeg måtte inkludere det)
- Det ville vært flott om du allerede har bygget noe med Django
All arbeidskoden vil være tilgjengelig på dette Github repo.
Nå som du har krystallklar de tidligere konseptene, la oss komme inn på saken.
Prosjekterklæring
I denne opplæringen skal du bygge en URL-forkorter. I utgangspunktet er en URL-forkorter en tjeneste som tar en lang URL og gjør den om til en kompakt.
For eksempel, hvis du vil dele en tweet og vil inkludere en lenke til nettstedet ditt, men du møter tegngrensen, kan du bruke en URL-forkorter.
La oss se det med en grafikk.
Som du kan se, får URL-forkorteren en lang URL og returnerer en kort. Det er akkurat det du skal bygge i dag.
Med dette prosjektet vil du øve på bruken av MVT-mønsteret, lære det grunnleggende om databasedesign med Django-modeller, og lære hvordan du viser informasjon til brukeren gjennom visninger, URL-er og maler.
Struktur av et Django-prosjekt
I utgangspunktet er et Django-nettsted bygget på et enkelt prosjekt og flere adskilte apper. Hver av disse appene har spesifikk funksjonalitet, og den kan fungere av seg selv.
La oss forestille oss en kompleks nettapplikasjon som Stackoverflow. Dens funksjonalitet er basert på to hovedaspekter.
- Brukeradministrasjon: Pålogging, Logg ut, Omdømme, Tillatelser
- Forum: Spørsmål, svar, tagger, filtre
Så etter Django-nettstedets struktur, vil prosjektet få navnet StackOverflow som har to hovedapper. Brukernes app og forumappen.
Hver av disse appene har selvstendig funksjonalitet. Det betyr at begge inneholder all koden de trenger for å fungere skikkelig.
Det inkluderer modeller (databasestruktur), visninger (forespørsler og svar), spesifikke URL-mønstre, og selvfølgelig maler og statiske filer (bilder, CSS, JavaScript). Dette betyr at enhver Django-app kan gjenbrukes siden de kan fungere alene.
Forkortelse, et prosjekt refererer til et sett med konfigurasjoner og apper som er ment å bygge en webapplikasjon. På den annen side er en Django-app en del av et prosjekt, som er selvstendig (har alt den trenger for å fungere), og formålet er å utføre en spesifikk operasjon.
Sett opp et Django-prosjekt
I denne delen skal du sette opp et Django-prosjekt. For det formålet skal du bruke forskjellige verktøy som et virtuelt miljø for å organisere Python-avhengigheter og de viktigste Django-skriptene. Django-admin og manage.py
Virtuelt miljø
Jeg anbefaler alltid å jobbe med virtuelle miljøer når du bygger apper med Django. Det er den mest effektive måten å opprettholde et spesifikt sett med avhengigheter. Men hovedformålet er å isolere utviklingspakkene fra de globale.
Så la oss lage et virtuelt miljø med python den innebygde formkommandoen.
Merk: Denne metoden krever Python 3.6 eller nyere versjoner for å fungere.
python -m venv .venv
Denne kommandoen bruker kommandoen python -m eller python –mod. I utgangspunktet kjører den en modul eller et bibliotek, som et skript. I henhold til betydningen av denne kommandoen er venv biblioteket vi kjører, og .venv refererer til navnet på det virtuelle miljøet vi ønsker å lage.
Så i klartekst betyr denne kommandoen.
Hei Python, kjør det innebygde biblioteket venv som et skript og lag et virtualenv-navn .venv
Nå er det på tide å aktivere det virtuelle miljøet vi nettopp opprettet, med følgende kommando.
source .venv/bin/activate
For å påstå at du har null pakker installert i den nye venv, kjører du.
pip freeze
Hvis du aktiverte det virtuelle miljøet riktig, vil du ikke få noe utdata. Det er fordi vi ikke har installert noe ennå.
La oss komme inn på Django
For å lage vår URL-forkorter-applikasjon, skal vi starte med å installere Django-pakken. Django er en tredjepartspakke, derfor må vi installere den med 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
Merk: Husk at $ ikke er annet enn skallsymbolet ditt.
For å sjekke om installasjonen gikk riktig, sjekker vi igjen de installerte pakkene til vår venv.
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1
Ikke bekymre deg hvis versjonene du får er forskjellige fra min. Hvis Django stillbilder på versjon 3.x kan du fortsette uten problemer.
Starter et Django-prosjekt
Når du har installert Django, er det på tide å lage strukturen til URL shortener-nettstedet. Husker du hva et Django-prosjekt er? La oss lage en ved å kjøre følgende kommando.
django-admin startproject config
For å forklare alt om denne kommandoen, er django-admin et kommandolinjeverktøy som utfører alle nødvendige oppgaver for å lage et Django-prosjekt. «startproject»-delen er kommandoen som kjøres av Django-admin-verktøyet, og config er navnet på prosjektet vi skal lage.
Er viktig å understreke at config kan være et hvilket som helst navn du vil. Grunnen til at jeg bruker config som navnet på dette prosjektet er bare på grunn av bekvemmelighet. Det er fint å bytte mellom prosjekter og fortsatt ha samme navnekonvensjon. Så ikke vær redd for å bruke andre prosjektnavn når du vil.
Som du kanskje legger merke til nå har du en konfigurasjon/mappe og inne i det er det mange filer. Senere vil vi se filstrukturen til prosjektet. For nå, la oss gå inn i prosjektkatalogen og kjøre den lokale serveren.
cd config/
Den viktigste filen du skal bruke er manage.py-skriptet. Den har samme funksjonalitet som django-admin, men den største fordelen med å bruke den er at den lar deg administrere innstillingene når du kjører prosjektet.
La oss nå se om alt fungerer som det skal.
python manage.py runserver
Opprette URL-forkorter-appen
Det er på tide å lage hovedappen til prosjektet. Du skal bruke filen manage.py for å utføre denne oppgaven.
python manage.py startapp urlshortener
Dette lager en Django-app, med navnet urlshortener. Hvis du kjører tre kommando, får du noe sånt som dette.
.
├── 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
La oss avklare de forskjellige filene som er opprettet til dette øyeblikket. «config» er navnet på prosjektet vårt, og det heter slik bare for konvensjonen. Inne i config får du settings.py, det er filen der du angir alle innstillingene for prosjektet ditt. urls.py er URL-enes generelle konfigurasjon i prosjektet. Den definerer URL-banene til alle applikasjonene i prosjektet.
Ikke bekymre deg for mye om filene asgi.py og wsgi.py. Dette er filer som lar deg konfigurere applikasjonen din under distribusjon.
manage.py er python-skriptet som lar deg kjøre alle tilgjengelige kommandoer Django-admin.
Når du tar en titt på urlshortener, som er navnet på appen du nettopp opprettet, kan du legge merke til at det er en merkelig mappe kalt «migrations/» og noen andre filer som er avgjørende for logikken til enhver app.
apps.py er der appkonfigurasjonen bor. Vanligvis roter du ikke rundt med det, bortsett fra at du gjør ganske forhåndsting.
admin.py er der du registrerer modellene dine for å gjøre dem synlige i Django-administrasjonspanelet.
models.py er den viktigste. Inne i denne modulen må du definere modellene, som (vagt sagt) er måten dataene lagres på. Du får høre mer om modeller senere.
migrations/ er mappen der Django-migreringer er lagret. Vi vil ta en dybdekikk senere.
tests.py er filen der testene er lagret. Vi vil ikke dekke testing i denne opplæringen.
views.py er filen som lagrer visninger. I utgangspunktet definerer den hvordan brukeren vil samhandle med alle aspektene ved appen din.
Installere en Django-app
Før du fortsetter, åpne settings.py-filen og endre INSTALLED_APPS-variabelen ved å legge til urlshortener-appen.
# 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',
]
Dette er en rutineprosess når du lager en app. Så hver gang du gjør det, ikke glem å installere det på prosjektinnstillingene.
Forstå MVT-mønsteret
Model, View, Template-mønsteret er programvaredesignmønsteret som Django-utviklere bruker for å lage webapplikasjoner.
Den er basert på 3 hovedkonsepter. Modell (data), View (Brukerinteraksjon med data), Mal (Hvordan brukerne ser dataene).
Modeller er Python-klasser, som definerer alle feltene og oppførselen til dataene du er villig til å lagre. Normalt refererer hver modell til en unik tabell i databasen
Visninger i sitt enkleste uttrykk er callables som tar en forespørsel fra brukeren og genererer et svar. Mellom den prosessen oppstår forretningslogikken. Jeg vet at «forretningslogikk» er et ganske uklart konsept, så la meg forklare nøyaktig hva det er. Forretningslogikk er måten data opprettes, lagres og slettes på, det er alt.
Til slutt er maler tekstdokumenter (vanligvis HTML) som vises til brukerne. Formålet er å presentere data så rene som mulig. Django inneholder et minispråk kalt Django malspråk (DTL) som lar deg inkorporere noe av kraften til python i tekstdokumenter.
Lag Shortener-modellen
Når du har fått en rask forståelse av MVT-mønsteret, la oss begynne å lage Django URL-forkorteren fra bunnen av.
Først av alt, la oss definere shortener-modellen inne i models.py-filen.
'''
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}'
Jeg vet. Det er en ganske stor klasse, med mye rart som skjer, men fortvil ikke. Jeg skal gå trinn for trinn på hver viktig ting.
Modellforklaring
Først av alt importerer vi modellmodulen. Denne modulen inneholder all funksjonaliteten vi trenger for å lage en Django-modell.
Ta en titt på «Shortener»-modellen, den første tingen å merke seg er at den utvider modellene. Faktisk må enhver modell i enhver Django-app være en underklasse av modeller.Modell klasse.
Deretter definerer vi alle feltene modellen skal ha på databasen. Feltet «opprettet» er datoen og klokkeslettet den forkortede lenken ble opprettet, derfor bruker vi DateTimeField for å lage denne typen funksjonalitet. Vi bruker argumentet auto_now_add=True fordi vi vil at feltet kun skal endres når forekomsten er opprettet.
Det andre feltet times_followed refererer til gangene den forkortede URL-en har blitt brukt. Det er et PositiveIntegerField og vi spesifiserer en standard på null. Det betyr at hver gang en forekomst har opprettet feltet times_followed, vil Django fylle ut det feltet med 0.
På den annen side refererer long_url til URL-en brukeren legger inn. Det er et URL-felt, fordi vi bare vil at brukeren skal skrive inn tegn i skjemaet: http://dinside.com.
Det siste feltet er short_url, og det har interessante detaljer. Vi spesifiserer at det bare kan være 15 tegn langt, det må være unikt, noe som betyr at det ikke kan være gjentatte elementer i det feltet. Til slutt indikerer vi at det kan stå tomt, noe som betyr at når du arbeider med skjemaer, trenger ikke brukere å skrive sin egen forkorte kode.
Den indre Meta-klassen, fortell oss hvordan klassen må oppføre seg, og vi setter at rekkefølgen (kaller Shortener.objects.all()) av shortener-objektene vil bli diskriminert av de nyeste.
Metoden __str__ forteller hvordan modellen må skrives ut. Så hvis vi har et objekt med long_url = «https://tipsbilk.net.com/» og forkortet del «123456», og vi skriver det ut.
https://tipsbilk.net.com/ to 123456
Nå er det på tide å finne en måte å lagre den korte lenken på på en tilfeldig måte.
Opprette forkortingsfunksjonalitet
Vi skal lage 2 tilpassede funksjoner. Den første vil generere en tilfeldig kode og den andre vil forhindre gjentatte tilfeldige koder fra Shortener-modellen. For å gjøre dette, lag en fil utils.py i «urlshortener»-appen.
touch utils.py
Inne i denne filen skal vi bruke valgfunksjonen fra den tilfeldige innebygde modulen. Dette letter oppgaven med å velge tilfeldige tegn for å lage koden.
'''
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)]
)
Som du kan se returnerer denne funksjonen en tilfeldig streng med lengden spesifisert i innstillingsfilen eller 7 som standard. Du bruker funksjonen getattr for å hente en variabel fra innstillingsmodulen, men uten å gi en feil hvis variabelen ikke er spesifisert.
La oss regne litt. Hvis vi har 7 steder hvor det kan være opptil 62 tilgjengelige tegn for hvert sted, er det mulig kombinasjonsmuligheter er:
Så basert på disse raske beregningene, kan den forkortede delen fylles ut opptil 2,5 billioner forskjellige koder. Så vi kan glemme å komme ut av tilfeldige forkortede nettadresser.
Selv om det kan eksistere så mye permutasjon, er det en liten sannsynlighet for å få gjentatte forkortede deler. Dette er et problem siden vi satte opp shortened_url-feltet til å være unikt. Det er derfor følgende funksjon er så nyttig.
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
La oss se hva som skjer her. Funksjonen tar som argument en «Shortener»-modellforekomst. Først genererer funksjonen en tilfeldig kode ved å bruke create_random_code. Så får den modellklassen og sjekker om det er noe annet objekt som har samme short_url. Hvis den gjør det, kjører den seg selv en gang til, men hvis alt er bra returnerer den random_code.
Senere vil du samhandle med skallet, for å se nærmere på denne funksjonen.
Etter å ha opprettet verktøyfunksjonen, la oss bruke den til å lage tilfeldige koder i shortener-modellen.
Endre lagringsmetoden
På slutten av «Shortener»-klassen skal du endre modelllagringsmetoden. Lagringsmetoden kalles hver gang et objekt lagres i databasen, så vi vil se hvordan du bruker den her.
# 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)
Lagringsmetoden blir overskrevet, noe som betyr at du introduserer ny funksjonalitet til en eksisterende overordnet metode. Det er egentlig å fortelle Django at hver gang et «Shortener»-objekt lagres og short_url ikke er spesifisert, må det fylles med en tilfeldig kode.
Kjører migreringer
Nå er det på tide å gjøre og kjøre migreringene av Shortener-modellen. For å gjøre det, kjør følgende kommandoer i rotprosjektmappen.
$ 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
Foreløpig trenger du ikke bekymre deg for hva migrasjoner er. Bare husk at når du kjører disse to kommandoene, oppretter Django en db.sqlite database fil, basert på modellene du har definert.
La oss lage noen objekter med Django-skallet.
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://tipsbilk.net.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://tipsbilk.net.com' >>> print(s) https://tipsbilk.net.com to kdWFVIc
Det er omtrent slik alle shortener-objekter vil fungere.
Skrivesyn
Som jeg sa før, er en visning en enkel funksjon som tar en forespørsel og returnerer et svar. Så la oss se hvordan du lager et hallo verdensbilde.
Grunnleggende malsvar
Lag en funksjon home_view inne i filen «urlshortener/views.py». aa
'''
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")
Den returnerer en enkel melding «Hello world». Senere vil du se hvordan det ser ut i nettleseren. Lag nå en «urls.py», der vil alle URL-mønstrene til appen stå.
trykk på urls.py
Legg til følgende kode.
'''
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")
]
Appname-variabelen erklærer (som navnet antyder) navneavstanden til urlshortener-appen.
Forklarer raskt at vi importerer banefunksjon, som returnerer et element som skal inkluderes i urlmønstrene til appen. Navneattributtet er navneområdet til banen, som kan kalles i maler om nødvendig.
La oss nå endre de overordnede prosjektnettadressene.
# 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'))
]
La oss nå kjøre serveren igjen.
python manage.py runserver
Hvis du kjører serveren, får du en enkel «Hello world»-melding. Dette er fordi du inkluderer urlmønstrene fra URL-forkorter-appen i det totale prosjektet.
Dette er bare et utgangspunkt. Nå er det på tide å lage et skjema for å la brukeren lage forkortede URL-er selv.
Opprette skjemaer
I Django, en form er en enkel klasse som gjør det mulig å få innspill fra brukeren.
Du skal lage en forms.py-fil. Det er en konvensjon å lagre alle skjemaene til appen i den filen.
cd urlshortener/ touch forms.py
Inne i den filen skal du lage en klasse «ShortenerForm» som strekker seg fra «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',)
Det er en modellform siden formålet er å lage et modellobjekt fra brukerinndata. Vi bruker også widget-argumentet, som lar oss spesifisere attributtet «class» (klasse i CSS, ikke python). Dette er fordi vi skal stilisere appen med bootstrap senere.
Fullfør utsikten
Etter å ha bygget skjemaene er det på tide å lage den endelige forretningslogikken til applikasjonen.
Naviger til views.py-filen inne i shortener-appen, og endre home_view-visningen. Du kan sjekke ut Github repo i dette øyeblikket for å få en ide om hvordan prosjektstrukturen ser ut.
Det er to visninger for URL shortener-appen:
La oss starte med hjemmevisningen som er den mest komplekse. Du må importere Shortener-modellen og skjemaet. Du bruker fortsatt en funksjon siden jeg vil at du skal forstå all dataflyten i visningen. Du vil også bruke banen for en mal (som ikke er opprettet ennå).
Hjemmevisning
'''
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)
Synet er basert på to betingelser:
En vanskelig måte å få hele nettstedets URL dynamisk på er å bruke forespørselsobjektmetoden build_absolute_uri .
>>> print(request.build_absolute_uri('/'))
'https://localhost:8080/'
Som en sikker måte å behandle en feil forespørsel (brukeren skrev ikke inn en gyldig URL), får vi skjemafeilene, sender dem som kontekst og gjengir malen som normalt. Senere vil du se hvordan du implementerer feilvisningen i malen.
Omdirigere visning
Redirect_url_view , er litt enklere. Det er en detaljert visning som betyr at visningen bare fungerer med et objekt.
Denne funksjonen tar som parametere, brukerens forespørsel og den forkortede_delen av URL-en. Det er ikke nødvendig å hevde hvilken type forespørsel vi får, siden vi ikke jobber med skjemaer i denne visningen.
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 :(')
Vi beskytter visningen med en try/except-setning, i tilfelle den forkortede delen ikke finnes i databasen. Hvis objektet blir funnet, legger det til 1 til times_followed-feltet og omdirigerer med HttpResponseRedirect-funksjonen til nettstedets URL som tilsvarer den tilfeldige koden.
Oppdaterer URL-er
Når du har opprettet de to visningene av appen, er det på tide å lage de endelige URL-mønstrene ved å inkludere banen til redirect_url_view.
Som alltid starter du med å importere visningene, og deretter lage en banefunksjon og sende som argumenter:
- URL-ruten
- Utsikten som peker mot stien
- Navnet på banen
'''
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"),
]
Med dette URL-oppsettet ser rutingen av appen slik ut.
- localhost:8000/: Hjemmevisning
- localhost:8000/URL-kode: Omdirigering til den lange URL
Opprette maler
Du er nesten der. Det eneste som skiller deg fra å ha bygget denne appen er brukergrensesnittet. Til det bruker vi Django-maler.
Maler brukes til å gi et rent grensesnitt til appbrukeren. Disse filene er opprettet inne i appen i en dobbel mappestruktur av skjemaet: «maler/appnavn»
# urlshortener directory mkdir -p templates/urlshortener/
Merk: Den doble mappestrukturen og Django-malspråket er utenfor omfanget av denne opplæringen, men du kan lese om dem i offisiell dokumentasjon.
Grunnmal
Django tillater malarv. Dette betyr at vi kan ha en grunnmal og utvide den med det formål å følge DRY (Ikke gjenta deg selv)-prinsippet.
cd templates/urlshortener touch base.html
Base.html-filen er en konvensjon og betyr at annenhver mal på appen må være en forlengelse av denne.
<!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>
Vi skal bruke bootstrap CDN, for å lage et raskt og pent grensesnitt uten å trenge CSS eller javascript-filer.
Hvis du vil lære dypt om DTL-tagger, kan du gjøre det med offisielle dokumenter.
Hjem mal
Hjemmemalen, inherence fra base.html-filen. Det betyr at denne malen inkluderer all HTML fra den overordnede filen.
{% 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 %}
Jeg skal raskt forklare dataflyten til denne malen:
- Skjemaet Shortener vises. Inne i crsf token er satt (sikkerhetsgrunner), og bare det lange URL-feltet til skjemaet vises. Husk at dette feltet har CSS-klassen, «form-control form-control-lg», fordi vi setter det i skjemaet.
- Hvis noen feil blir funnet, vis dem
- Hvis POST-operasjonen lykkes, vises den nye URL-en.
Endelig søknad
Gratulerer! 🎉. Du har bygget en komplett funksjonell URL-forkorter-app med Django.
Her er noen skjermbilder av hvordan applikasjonen ser ut.
Få kun:
Feil ved forkorting av URL:
Vellykket forkortet URL:
URL omdirigert:
Hva synes du om å eksponere en demo av denne URL-forkorterappen for noen? Sjekk hvordan du eksponerer en Django Demo-app for internett.
Utfordring 🔥
Hvis du føler deg komfortabel med Django-ferdighetene dine, hvorfor ikke øve med en utfordring?
Klon koden til denne applikasjonen og lag et autentiseringssystem, der bare registrerte brukere kan forkorte URL-ene sine.
Når du er ferdig, send en pull-forespørsel og ping meg videre Twitter for å vise frem prestasjonene dine.
Avslutter
Du har nådd slutten av denne opplæringen. Tro det eller ei, du har nettopp gjennomgått alle hovedaspektene ved å lage et Django-prosjekt. Jeg håper du fant det svært nyttig.
I denne opplæringen:
- Lærte om arbeidsflyten for å lage en Django-app.
- Bygget et CV-prosjekt
- Forsto forskjellene og strukturen til Django-prosjekter og Django-apper.
- Oppdaget MVT-mønsteret.
- Opprettet funksjonsbasevisninger
- Brukte Django ORM (Object Relational Mapper) for å lage enkle modeller
Det er alt, det er mye å dekke med Django nettrammeverkså hold kontakten for flere fantastiske opplæringsprogrammer.