• Erledigen Sie die Anwendungssicherheit auf die richtige Weise! Erkennen, schützen, überwachen, beschleunigen und mehr…
  • Der beste Weg, um Django oder eine andere Fähigkeit zu erlernen, besteht darin, das Wissen anzuwenden, das Sie haben, indem Sie funktionale Projekte erstellen.

    Django ist das am häufigsten verwendete Python-Webentwicklungsframework. Seine integrierten Funktionen und die umfangreiche Anzahl an Paketen von Drittanbietern haben es zu einem der beliebtesten gemacht Web-Frameworks weltweit.

    Es ist schnell, zuverlässig und verfügt über viele integrierte Funktionen. Zum Beispiel ein Hole-Authentifizierungssystem, mit dem Sie sich auf die Hauptfunktionen Ihrer App konzentrieren können. Sie können auch externe Pakete installieren, um noch komplexere Aufgaben zu erledigen, wie z Django-allauthHiermit können Sie Benutzer mit ihren sozialen Konten registrieren.

    Aber lassen Sie uns einige Fakten aufdecken. Django ist ein so riesiges Framework, dass es manchmal schwierig ist, damit zu beginnen.

    Heute werden Sie eine voll funktionsfähige Django-Anwendung von Grund auf neu erstellen.

    Am Ende dieses Tutorials werden Sie:

    • Habe eine URL Shortener App geschrieben
    • Verstehen Sie das Django MVT-Muster
    • Habe den Workflow zum Erstellen eines Projekts gelernt

    Pre-requirements

    Alle folgenden Anforderungen sind optional und helfen Ihnen, das Lernprogramm zu befolgen. Aber wenn Sie keine Erfahrung mit diesen haben, machen Sie sich keine Sorgen. Der wichtigste Schritt ist der erste.

    • Grundlegendes Verständnis von UNIX-Befehle (ls, cd, rm, berühren)
    • Grundlegendes Verständnis von Python-Klassen und -Funktionen
    • Python auf Ihrem Computer installiert (Vielleicht offensichtlich, aber ich musste es einschließen)
    • Es wäre toll, wenn Sie bereits etwas mit Django gebaut hätten

    Der gesamte Arbeitscode wird hierfür verfügbar sein Github Repo.

    Nachdem Sie die vorherigen Konzepte kristallklar verstanden haben, wollen wir uns mit der Sache befassen.

    Project statement

    In diesem Tutorial erstellen Sie einen URL-Shortener. Grundsätzlich ist a URL-Verkürzer ist ein Dienst, der eine lange URL in eine kompakte URL umwandelt.

    Wenn Sie beispielsweise einen Tweet teilen und einen Link zu Ihrer Website einfügen möchten, sich jedoch der Zeichenbeschränkung gegenübersehen, können Sie einen URL-Shortener verwenden.

    Lassen Sie es uns mit einer Grafik sehen.

    URL-Verkürzer

    Wie Sie sehen können, erhält der URL-Shortener eine lange URL und gibt eine kurze zurück. Genau das werden Sie heute bauen.

    In diesem Projekt üben Sie die Verwendung des MVT-Musters, lernen die Grundlagen des Datenbankdesigns mit Django-Modellen und lernen, wie Sie dem Benutzer Informationen über Ansichten, URLs und Vorlagen anzeigen.

    Structure of a Django project

    Grundsätzlich basiert eine Django-Website auf einer einzigen Projekt und mehrfach getrennt Apps. Jede dieser Apps verfügt über spezifische Funktionen und kann für sich arbeiten.

    Stellen wir uns eine komplexe Webanwendung wie vor Stackoverflow. Seine Funktionalität basiert auf zwei Hauptaspekten.

    • Benutzerverwaltung: Anmelden, Abmelden, Reputation, Berechtigungen
    • Forum: Fragen, Antworten, Tags, Filter

    Entsprechend der Struktur der Django-Website würde das Projekt benannt StackOverflow Das hat zwei Haupt-Apps. Das Benutzer App und die Forum App.

    Jede dieser Apps verfügt über eigenständige Funktionen. Das bedeutet, dass beide den gesamten Code enthalten, den sie benötigen, um ordnungsgemäß zu funktionieren.

    Dazu gehören Modelle (Datenbankstruktur), Ansichten (Anforderungen und Antworten), bestimmte URL-Muster und natürlich Vorlagen und statische Dateien (Bilder, CSS, JavaScript). Dies bedeutet, dass jede Django-App wiederverwendet werden kann, da sie selbst arbeiten kann.

    Kurz gesagt, ein Projekt bezieht sich auf eine Reihe von Konfigurationen und Apps, mit denen eine Webanwendung erstellt werden soll. Auf der anderen Seite ist eine Django-App Teil eines Projekts, das in sich geschlossen ist (alles hat, was es zum Arbeiten benötigt) und dessen Zweck darin besteht, eine bestimmte Operation auszuführen.

    Set Up a Django project

    In diesem Abschnitt richten Sie ein Django-Projekt ein. Zu diesem Zweck verwenden Sie verschiedene Tools wie eine virtuelle Umgebung, um Python-Abhängigkeiten und die wichtigsten Django-Skripte zu organisieren. Django-Admin . manage.py

    Virtuelle Umgebung

    Ich empfehle immer mit zu arbeiten virtuelle Umgebungen beim Erstellen von Apps mit Django. Dies ist der effizienteste Weg, um bestimmte Abhängigkeiten zu verwalten. Der Hauptzweck besteht jedoch darin, die Entwicklungspakete von den globalen zu isolieren.

    Erstellen wir also eine virtuelle Umgebung mit Python, dem integrierten Formularbefehl.

    Hinweis: Diese Methode erfordert Python 3.6 oder neuere Versionen an die Arbeit.

    python -m venv .venv

    Dieser Befehl verwendet die Python -m or Python –mod Befehl. Grundsätzlich wird ein Modul oder eine Bibliothek als Skript ausgeführt. Entsprechend der Bedeutung dieses Befehls venv ist die Bibliothek, die wir betreiben, und .venv bezieht sich auf den Namen der virtuellen Umgebung, die wir erstellen möchten.

    Im Klartext bedeutet dieser Befehl also.

    Hey Python, führe als Skript die eingebaute Bibliothek aus venv und erstellen Sie einen virtuellen Namen .venv

    Jetzt ist es Zeit, die gerade erstellte virtuelle Umgebung mit dem folgenden Befehl zu aktivieren.

    source .venv/bin/activate

    Um sicherzustellen, dass im neuen venv keine Pakete installiert sind, führen Sie aus.

    pip freeze

    Wenn Sie die virtuelle Umgebung korrekt aktiviert haben, erhalten Sie keine Ausgabe. Das liegt daran, dass wir noch nichts installiert haben.

    Kommen wir nach Django

    Um unsere URL-Shortener-Anwendung zu erstellen, installieren wir zunächst das Django-Paket. Django ist ein Paket von Drittanbietern, daher müssen wir es mit installieren Pips (Pip installiert Pakete).

    $ 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

    Hinweis: Beachten Sie, dass $ ist nichts als dein Shell-Symbol.

    Um zu überprüfen, ob die Installation korrekt verlaufen ist, überprüfen wir erneut die installierten Pakete unseres venv.

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

    Mach dir keine Sorgen, wenn die Versionen, die du bekommst, von meinen abweichen. Wenn Django immer noch auf Version 3.x läuft, können Sie problemlos fortfahren.

    Starten eines Django-Projekts

    Sobald Sie Django installiert haben, ist es Zeit, die Struktur der URL-Shortener-Website zu erstellen. Erinnerst du dich, was ein Django-Projekt ist? Erstellen Sie eine, indem Sie den folgenden Befehl ausführen.

    django-admin startproject config

    Alles über diesen Befehl erklären, django-admin ist ein Befehlszeilenprogramm, das alle erforderlichen Aufgaben zum Erstellen eines Django-Projekts ausführt. Der Teil "startproject" ist der Befehl, der vom Dienstprogramm Django-admin ausgeführt wird, und Config ist der Name des Projekts, das wir erstellen werden.

    Ist wichtig, das zu betonen Config kann ein beliebiger Name sein. Der Grund, warum ich config als Namen für dieses Projekt verwende, ist nur der Einfachheit halber. Es ist schön, zwischen Projekten zu wechseln und trotzdem die gleiche Namenskonvention zu haben. Haben Sie also keine Angst davor, andere Projektnamen zu verwenden, wann immer Sie möchten.

    Wie Sie jetzt vielleicht bemerken, haben Sie eine config / Ordner und im Inneren gibt es viele Dateien. Später werden wir die Dateistruktur des Projekts sehen. Geben Sie zunächst das Projektverzeichnis ein und führen Sie den lokalen Server aus.

    cd config/

    Die wichtigste Datei, die Sie verwenden werden, ist die manage.py Skript. Es hat die gleiche Funktionalität wie django-adminDer Hauptvorteil der Verwendung besteht jedoch darin, dass Sie die Einstellungen beim Ausführen des Projekts verwalten können.

    Nun wollen wir sehen, ob alles richtig funktioniert.

    python manage.py runserver

    Django Demo App

    Creating the Url shortener app

    Es ist Zeit, die Haupt-App des Projekts zu erstellen. Sie werden die verwenden manage.py Datei, um diese Aufgabe zu erfüllen.

    python manage.py startapp urlshortener

    Dadurch wird eine Django-App mit dem Namen erstellt URL-Verkürzer. Wenn Sie die ausführen Baum Befehl, Sie werden so etwas bekommen.

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

    Lassen Sie uns die verschiedenen Dateien klären, die bis zu diesem Moment erstellt wurden. "Config" ist der Name unseres Projekts und wird nur für die Konvention so benannt. Innerhalb der Konfiguration erhalten Sie settings.pyIn dieser Datei legen Sie alle Einstellungen Ihres Projekts fest. urls.py ist die Gesamtkonfiguration der URLs innerhalb des Projekts. Es definiert die URL-Pfade aller Anwendungen innerhalb des Projekts.

    Mach dir keine Sorgen über die asgi.py . wsgi.py Dateien. Dies sind Dateien, mit denen Sie Ihre Anwendung in der Bereitstellung konfigurieren können.

    Das manage.py ist das Python-Skript, mit dem Sie alle verfügbaren Befehle von ausführen können Django-Admin.

    Werfen Sie einen Blick hinein urlshortener Dies ist der Name der App, die Sie gerade erstellt haben. Möglicherweise gibt es einen seltsamen Ordner mit dem Namen "migrations /" und einige andere Dateien, die für die Logik einer App von entscheidender Bedeutung sind.

    apps.py Hier befindet sich die App-Konfiguration. Normalerweise spielt man nicht damit herum, außer man macht ziemlich fortgeschrittene Sachen.

    admin.py Hier registrieren Sie Ihre Modelle um sie im Django Admin Panel sichtbar zu machen.

    models.py ist das wichtigste. Innerhalb dieses Moduls müssen Sie die definieren Modelle, welche (vage gesagt) die Art und Weise sind, wie die Daten gespeichert werden. Sie werden später mehr über Modelle erfahren.

    migrations/ ist der Ordner, in dem Django-Migrationen gespeichert werden. Wir werden später genauer darauf eingehen.

    tests.py ist die Datei, in der die Tests gespeichert sind. In diesem Tutorial werden die Tests nicht behandelt.

    views.py ist die Datei, in der Ansichten gespeichert werden. Grundsätzlich wird definiert, wie der Benutzer mit allen Aspekten Ihrer App interagiert.

    Installieren einer Django-App

    Bevor Sie fortfahren, öffnen Sie die settings.py Datei und ändern Sie die INSTALLED_APPS Variable durch Hinzufügen der urlshortener App.

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

    Dies ist ein Routineprozess, wenn Sie eine App erstellen. Vergessen Sie also nicht, es jedes Mal in den Projekteinstellungen zu installieren.

    Understanding the MVT pattern

    Das Modell-, Ansichts- und Vorlagenmuster ist das Software-Entwurfsmuster, mit dem Django-Entwickler Webanwendungen erstellen.

    MVT-Muster

    Es basiert auf 3 Hauptkonzepten. Modell (Daten), Ansicht (Benutzerinteraktion mit Daten), Vorlage (Wie die Benutzer die Daten sehen).

    Modelle sind Python-Klassen, die alle Felder und das Verhalten der Daten definieren, die Sie speichern möchten. Normalerweise verweist jedes Modell auf eine eindeutige Tabelle in der Datenbank

    Ansichten in ihrem einfachsten Ausdruck sind aufrufbare Elemente, die eine Anforderung vom Benutzer entgegennehmen und eine Antwort generieren. Zwischen diesem Prozess tritt die Geschäftslogik auf. Ich weiß, dass „Geschäftslogik“ ein ziemlich dunkles Konzept ist, also lassen Sie mich genau erklären, was es ist. Geschäftslogik ist die Art und Weise, wie Daten erstellt, gespeichert und gelöscht werden.

    Schließlich sind Vorlagen Textdokumente (normalerweise HTML), die den Benutzern angezeigt werden. Ziel ist es, die Daten so sauber wie möglich darzustellen. Django enthält eine Mini-Sprache namens Django-Vorlagensprache (DTL) Damit können Sie einen Teil der Leistung von Python in Textdokumente integrieren.

    Create the Shortener model

    Sobald Sie das MVT-Muster schnell verstanden haben, können Sie den Django-URL-Shortener von Grund auf neu erstellen.

    Zunächst definieren wir das Shortener-Modell innerhalb des models.py Datei.

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

     

    Ich weiß. Es ist eine ziemlich große Klasse, in der viele seltsame Dinge vor sich gehen, aber verzweifeln Sie nicht. Ich werde Schritt für Schritt auf jede wichtige Sache eingehen.

    Modellerklärung

    Zunächst importieren wir die models Modul. Dieses Modul enthält alle Funktionen, die wir zum Erstellen eines Django-Modells benötigen.

    Wenn Sie sich das Modell „Shortener“ ansehen, müssen Sie zunächst feststellen, dass es erweitert wird models.Model. Tatsächlich muss jedes Modell in einer Django-App eine Unterklasse der sein Modelle.Modell Klasse.

    Dann definieren wir alle Felder, die das Modell in der Datenbank haben wird. Das Feld "Erstellt" ist das Datum und die Uhrzeit, zu der der verkürzte Link erstellt wird. Daher verwenden wir DatumZeitFeld um diese Art von Funktionalität zu erstellen. Wir benutzen das Argument auto_now_add = True weil wir möchten, dass das Feld nur geändert wird, wenn die Instanz erstellt wird.

    Das zweite Feld times_followed bezieht sich auf die Zeiten, zu denen die verkürzte URL verwendet wurde. Es ist ein PositiveIntegerField und wir geben einen Standardwert von Null an. Das bedeutet, dass jedes Mal, wenn eine Instanz das erstellt hat times_followed Feld, Django wird dieses Feld mit 0 ausfüllen.

    Auf der anderen Seite, long_url bezieht sich auf die URL, die der Benutzer eingibt. Es ist ein URL-Feld, weil wir nur möchten, dass der Benutzer Zeichen des Formulars eingibt: http://yoursite.com.

    Das letzte Feld ist  short_urlund es hat interessante Details. Wir geben an, dass es nur 15 Zeichen lang sein kann, es muss eindeutig sein, was bedeutet, dass es in diesem Feld keine wiederholten Elemente geben kann. Schließlich weisen wir darauf hin, dass es leer bleiben kann, was bedeutet, dass Benutzer bei der Arbeit mit Formularen keinen eigenen Kürzungscode schreiben müssen.

    Die innere Meta-Klasse sagt uns, wie sich die Klasse verhalten muss, und wir legen die Reihenfolge (Aufruf) fest Shortener.objects.all ()) der Verkürzungsobjekte werden durch die neuesten unterschieden.

    Das __str__ Methode gibt an, wie das Modell gedruckt werden muss. Wenn wir also ein Objekt mit long_url = "https://geekflare.com/" und dem verkürzten Teil "123456" haben, drucken wir es aus.

    https://geekflare.com/ to 123456

    Jetzt ist es an der Zeit, nach einer Möglichkeit zu suchen, den kurzen Link auf zufällige Weise zu speichern.

    Verkürzungsfunktionalität erstellen

    Wir werden 2 benutzerdefinierte Funktionen erstellen. Der erste generiert einen Zufallscode und der zweite verhindert, dass wiederholte Zufallscodes aus dem Shortener-Modell abgerufen werden. Erstellen Sie dazu eine Datei utils.py in der App „urlshortener“.

    touch utils.py

    In dieser Datei verwenden wir die Auswahlfunktion aus dem integrierten Zufallsmodul. Dies erleichtert die Auswahl zufälliger Zeichen zum Erstellen des Codes.

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

    Wie Sie sehen können, gibt diese Funktion eine zufällige Zeichenfolge mit der in der Einstellungsdatei angegebenen Länge oder standardmäßig mit 7 zurück. Sie verwenden die Funktion getattr, um eine Variable aus dem Einstellungsmodul abzurufen, ohne jedoch einen Fehler auszulösen, wenn die Variable nicht angegeben ist.

    Lass uns ein bisschen rechnen. Wenn wir 7 Stellen haben, an denen bis zu 62 Zeichen für jede Stelle verfügbar sein können, ist dies möglich Permutationen sind:

    Basierend auf diesen schnellen Berechnungen kann der verkürzte Teil bis zu 2.5 Billionen verschiedener Codes ausgefüllt werden. So können wir vergessen, aus zufälligen verkürzten URLs herauszukommen.

    Obwohl es so viele Permutationen geben kann, besteht eine geringe Wahrscheinlichkeit, dass sich verkürzte Teile wiederholen. Dies ist ein Problem, da wir das eingerichtet haben shortened_url Feld einzigartig sein. Deshalb ist die folgende Funktion so nützlich.

    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

    Mal sehen, was hier passiert. Die Funktion verwendet als Argument eine "Shortener" -Modellinstanz. Zunächst generiert die Funktion einen Zufallscode mit dem create_random_code. Dann bekommt es das Modell Klasse und prüft, ob es ein anderes Objekt gibt, das dasselbe hat short_url. Wenn dies der Fall ist, wird es noch einmal von selbst ausgeführt. Wenn jedoch alles in Ordnung ist, wird der random_code zurückgegeben.

    Später werden Sie mit der Shell interagieren, um diese Funktion genauer zu betrachten.

    Nachdem Sie die Utility-Funktion erstellt haben, können Sie damit zufällige Codes im Shortener-Modell erstellen.

    Ändern der Speichermethode

    Am Ende der Klasse "Shortener" ändern Sie die Methode zum Speichern des Modells. Das Speichern Die Methode wird jedes Mal aufgerufen, wenn ein Objekt in der Datenbank gespeichert wird. Wir werden hier sehen, wie es verwendet wird.

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

    Die Speichermethode wird überschrieben. Dies bedeutet, dass Sie einer bereits vorhandenen übergeordneten Methode neue Funktionen hinzufügen. Es sagt Django im Grunde, dass jedes Mal, wenn ein "Shortener" -Objekt gespeichert wird und das short_url ist nicht angegeben, muss mit einem Zufallscode gefüllt werden.

    Ausführen von Migrationen

    Jetzt ist es Zeit, die Migrationen des Shortener-Modells durchzuführen und auszuführen. Führen Sie dazu die folgenden Befehle im Stammprojektordner aus.

    $ 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

    Im Moment müssen Sie sich keine Gedanken darüber machen, was Migrationen sind. Denken Sie daran, dass Django beim Ausführen dieser beiden Befehle eine erstellt Datenbank db.sqlite Datei, basierend auf den von Ihnen definierten Modellen.

    Lassen Sie uns einige Objekte mit der Django-Shell erstellen.

    $ 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

    So funktionieren so ziemlich alle Shortener-Objekte.

    Writing views

    Wie ich bereits sagte, ist eine Ansicht eine einfache Funktion, die eine Anfrage entgegennimmt und eine Antwort zurückgibt. Lassen Sie uns sehen, wie Sie ein Hallo-Weltbild erstellen.

    Grundlegende Antwort auf Vorlagen

    Erstellen Sie in der Datei "urlshortener / views.py" eine Funktion home_view. 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")

    Es wird eine einfache Meldung "Hallo Welt" zurückgegeben. Später werden Sie sehen, wie es im Browser aussieht. Erstellen Sie nun eine "urls.py", dort werden alle URL-Muster der App angezeigt.

    touch urls.py

    Fügen Sie den folgenden Code hinzu.

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

    Das  App Name Variable deklariert (wie der Name schon sagt) den Namespace der urlshortener-App.

    Schnell erklären, dass wir das importieren Pfadfunktion, das ein Element zurückgibt, das in die URL-Muster der App aufgenommen werden soll. Das Name Attribut ist der Namespace des Pfads, der bei Bedarf in Vorlagen aufgerufen werden kann.

    Lassen Sie uns nun die gesamten Projekt-URLs ändern.

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

    Lassen Sie uns nun den Server erneut ausführen.

    python manage.py runserver

    Wenn Sie den Server ausführen, erhalten Sie eine einfache Meldung "Hallo Welt". Dies liegt daran, dass Sie die URL-Muster aus der URL-Shortener-App in das Gesamtprojekt aufnehmen.

    Dies ist nur ein Ausgangspunkt. Jetzt ist es Zeit, ein Formular zu erstellen, mit dem der Benutzer verkürzte URLs selbst erstellen kann.

    Creating forms

    In Django, a ProForm ist eine einfache Klasse, mit der Eingaben vom Benutzer abgerufen werden können.

    Sie erstellen eine forms.py-Datei. Es ist eine Konvention, alle Formen der App in dieser Datei zu speichern.

    cd urlshortener/
    touch forms.py
    

    Innerhalb dieser Datei erstellen Sie eine Klasse "ShortenerForm", die sich von "ModelForm" erstreckt.

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

    Es handelt sich um ein Modellformular, da es dazu dient, aus der Benutzereingabe ein Modellobjekt zu erstellen. Wir verwenden auch das Widget-Argument, mit dem wir das Attribut "class" (Klasse in CSS, nicht Python) angeben können. Dies liegt daran, dass wir die App später mit Bootstrap stilisieren werden.

    Finishing the views

    Nach dem Erstellen der Formulare ist es Zeit, die endgültige Geschäftslogik der Anwendung zu erstellen.

    Navigieren Sie zu der views.py Datei in der Shortener-App und ändern Sie die home_view Aussicht. Sie können die überprüfen Github Repo in diesem Moment, um eine Vorstellung davon zu bekommen, wie die Projektstruktur aussieht.

    Es gibt zwei Ansichten für die URL-Shortener-App:

    1. Startansicht: Dies zeigt das Kürzungsformular und die neue URL, wenn das Formular bereits gesendet wurde.
    2. Umleitungsansicht: Dies leitet zur langen URL weiter und addiert 1 zu den folgenden Zeiten.

    Beginnen wir mit der Startansicht, die am komplexesten ist. Sie müssen das Shortener-Modell und das Formular importieren. Sie verwenden immer noch eine Funktion, da ich möchte, dass Sie den gesamten Datenfluss der Ansicht verstehen. Außerdem verwenden Sie den Pfad für eine Vorlage (die noch nicht erstellt wurde).

    Startansicht

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

    Die Ansicht basiert auf zwei Bedingungen:

    1. Wenn die HTTP-Methode gleich GET ist: Wir übergeben nur als Kontext das Shortener-Formular, das zum Erstellen von Shortener-Objekten verwendet wird.
    2. Wenn die HTTP-Methode gleich POST ist: Wir übergeben das Formular weiterhin im Kontext, da der Benutzer eine andere URL eingeben kann. Wir leiten die Post-Anfrage jedoch an ein anderes Formular mit dem Namen weiter verwendet_form.

    Eine schwierige Möglichkeit, die vollständige Site-URL dynamisch abzurufen, ist die Verwendung von Anforderung Objektmethode build_absolute_uri .

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

    Um eine falsche Anfrage sicher zu verarbeiten (der Benutzer hat keine gültige URL eingegeben), erhalten wir die Formularfehler, übergeben sie als Kontext und rendern die Vorlage wie gewohnt. Später erfahren Sie, wie Sie die Fehleranzeige in der Vorlage implementieren.

    Ansicht umleiten

    Das redirect_url_view  ist etwas einfacher. Es ist eine Detailansicht, dh die Ansicht funktioniert nur mit einem Objekt.

    Diese Funktion verwendet als Parameter die Benutzeranforderung und die verkürzter Teil der URL. Es ist nicht erforderlich, die Art der Anforderung anzugeben, die wir erhalten, da wir in dieser Ansicht nicht mit Formularen arbeiten.

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

    Wir schützen die Aussicht mit einem versuchen Sie es / ausgenommen Anweisung, falls der verkürzte Teil nicht in der Datenbank gefunden wird. Wenn das Objekt gefunden wird, wird 1 zum hinzugefügt times_followed Feld und leitet mit dem weiter HttpResponseRedirect Funktion auf die Site-URL, die dem Zufallscode entspricht.

    Updating URLs

    Sobald Sie die beiden Ansichten der App erstellt haben, ist es Zeit, die endgültigen URL-Muster zu erstellen, indem Sie den Pfad zu der App angeben redirect_url_view.

    Wie immer importieren Sie zunächst die Ansichten, erstellen dann eine Pfadfunktion und übergeben sie als Argumente:

    • Die URL-Route
    • Die Ansicht zeigt auf den Pfad
    • Der Name des Pfades
    '''
    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'),
    ]
    

    Mit dieser URL-Einrichtung sieht das Routing der App folgendermaßen aus.

    • localhost:8000/: Startansicht
    • localhost:8000/URL-code: Umleitung zur langen URL

    Creating templates

    Du bist fast am Ziel. Das einzige, was Sie von der Erstellung dieser App unterscheidet, ist die Benutzeroberfläche. Dafür verwenden wir Django-Vorlagen.

    Vorlagen werden verwendet, um eine saubere Oberfläche für den App-Benutzer zu rendern. Diese Dateien werden innerhalb der App in einer Doppelordnerstruktur des Formulars erstellt: "Vorlagen / Anwendungsname"

    # urlshortener directory
    mkdir -p templates/urlshortener/

    Hinweis: Die Doppelordnerstruktur und die Django-Vorlagensprache gehen über den Rahmen dieses Tutorials hinaus, aber Sie können sie im lesen offizielle Dokumentation.

    Basisvorlage

    Django erlaubt die Vererbung von Vorlagen. Dies bedeutet, dass wir eine Basisvorlage haben und diese erweitern können, um dem DRY-Prinzip (Wiederholen Sie sich nicht) zu folgen.

    cd templates/urlshortener
    touch base.html

    Die base.html-Datei ist eine Konvention und bedeutet, dass jede andere Vorlage in der App eine Erweiterung dieser sein muss.

    <!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>
    

    Wir werden das Bootstrap-CDN verwenden, um eine schnelle und hübsche Oberfläche zu erstellen, ohne CSS- oder Javascript-Dateien zu benötigen.

    Wenn Sie mehr über DTL-Tags erfahren möchten, können Sie dies mit dem tun offizielle Dokumente.

    Home-Vorlage

    Die Home-Vorlage, Inhärenz aus der Datei base.html. Das bedeutet, dass diese Vorlage den gesamten HTML-Code aus der übergeordneten Datei enthält.

    {% 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 %}

    Ich werde den Datenfluss dieser Vorlage schnell erklären:

    • Das Shortener-Formular wird angezeigt. Im Inneren die CRSF-Token ist festgelegt (Sicherheitsgründe) und nur das lange URL-Feld des Formulars wird angezeigt. Denken Sie daran, dass dieses Feld die CSS-Klasse "form-control form-control-lg" hat, da wir dies im Formular festlegen.
    • Wenn Fehler gefunden werden, zeigen Sie diese an
    • Wenn der POST-Vorgang erfolgreich ist, wird die neue URL angezeigt.

    Final application

    Herzliche Glückwünsche! 🎉. Sie haben mit Django eine vollständige funktionale URL-Shortener-App erstellt.

    Hier sind einige Screenshots, wie die Anwendung aussieht.

    Holen Sie sich nur:

    Fehler beim Verkürzen der URL:

    Erfolgreiche verkürzte URL:

    Django URL Shortener Erfolg

    URL umgeleitet:

    Erfolgsumleitung

    Was halten Sie davon, jemandem eine Demo dieser URL-Shortener-App zur Verfügung zu stellen? Prüfen wie man eine Django Demo App dem Internen zur Verfügung stelltt.

    Herausforderung 🔥

    Wenn Sie sich mit Ihren Django-Fähigkeiten wohl fühlen, warum nicht mit einer Herausforderung üben?

    Klonen Sie den Code dieser Anwendung und erstellen Sie ein Authentifizierungssystem, in dem nur registrierte Benutzer ihre URLs kürzen können.

    Wenn Sie fertig sind, senden Sie eine Pull-Anfrage und rufen Sie mich an Twitter um Ihre Erfolge zu präsentieren.

    Wrapping up

    Sie haben das Ende dieses Tutorials erreicht. Ob Sie es glauben oder nicht, Sie haben gerade alle Hauptaspekte beim Erstellen eines Django-Projekts überprüft. Ich hoffe, Sie fanden es äußerst nützlich.

    In diesem Tutorial haben Sie:

    • Erfahren Sie mehr über den Workflow beim Erstellen einer Django-App.
    • Erstellt ein Lebenslaufprojekt
    • Verstand die Unterschiede und die Struktur von Django-Projekten und Django-Apps.
    • Entdeckte das MVT-Muster.
    • Funktionsbasisansichten erstellt
    • Verwendete den Django ORM (Object Relational Mapper), um einfache Modelle zu erstellen

    Das ist alles, es gibt viel zu decken mit dem Django Web FrameworkBleiben Sie also in Kontakt, um weitere tolle Tutorials zu erhalten.