In diesem Artikel erfahren Sie, wie Sie mit dem ** Django Web Framework ** eine Anwendung aus der Cloud erstellen, um Webentwicklern bei der Bewältigung der heutigen Herausforderungen zu helfen.
Bevor wir über Django sprechen, möchte ich Ihnen sagen, was eine Webanwendung ist. Eine Webanwendung ist eine Sammlung von Code, der in einer Programmiersprache geschrieben ist, die in einem Browser gerendert wird und normalerweise genau definierte Probleme behebt. Zum Beispiel ein Blog-Beitrag (wie dieser!), Eine E-Commerce-Website oder ein soziales Netzwerk.
Nun, das ist ziemlich einfach, aber was ist ein Webframework? Ein Webframework ist eine Sammlung wiederverwendbarer Komponenten, die viele der allgemeinen und sich wiederholenden Aufgaben der Entwicklung von Webanwendungen auf integrierte Weise erledigen. Anstatt eine Bibliothek mit unterschiedlichem Code zu erhalten und einen Weg zu finden, wie diese zusammenarbeiten können, bietet das Webframework alle benötigten Komponenten in einem einzigen Paket und kümmert sich um die Integration. ..
Nachdem Sie das Konzept von Web-Apps und Frameworks kennen, sprechen wir über Django. Django ist eines der neuesten Web-Frameworks, das die Erstellung von Web-Apps vereinfachen soll. Django bietet eine Reihe von Tools, mit denen Sie schnell wiederverwendbare, skalierbare, saubere und hochdynamische Webanwendungen entwickeln können.
Django basiert auf dem DRY-Paradigma (Don't Repeat Yourself), und Sie müssen in jedem Schritt des Entwicklungsprozesses weniger Code schreiben als der durchschnittliche Code, der mit anderen Frameworks erforderlich ist. Es bedeutet nicht zu sein.
Diese Reihe von Tutorials führt Sie durch die Entwicklung mehrerer Anwendungen. Wie die verschiedenen mit Django gebündelten Komponenten und Anwendungen Ihnen helfen, in jeder Phase des Entwicklungsprozesses weniger Code zu schreiben. Hier erfahren Sie, wie Sie dies alles in der Cloud tun. Dieses Mal führen wir die Webanwendung auf einer Alibaba Cloud Elastic Compute Service (ECS) -Instanz aus. Das Verfahren zum Einrichten von Django auf ECS wird nicht beschrieben. Lesen Sie stattdessen die folgenden beiden Tutorials.
1、https://www.alibabacloud.com/getting-started/projects/how-to-deploy-django-application-on-alibaba-cloud 2、http://www.alibabacloud.com/blog/how-to-deploy-a-django-application-with-docker_581157
Das Projekt, das wir erstellen möchten, ist eine Webanwendung für den elektronischen Handel, mit der Menschen Waren kaufen und verkaufen können. Aus Gründen der Flexibilität und Wartbarkeit ist das Projekt in drei unabhängige Apps unterteilt: Kern-App, Warenkorb-App und Zahlungs-App.
Wie bereits erwähnt, verwaltet die Kern-App alles (Ergänzungen, Änderungen, Löschungen), die mit dem Produkt zusammenhängen, das Sie verkaufen möchten. Die Kern-App zielt darauf ab, den gesamten Einkaufsprozess zu verwalten.
1, Benutzer (Käufer / Verkäufer und Administrator) 2, Produktinformationen 3, Produktkategorie
Die Warenkorbanwendung wird verwendet, um den Kauf- und Verkaufsprozess zu verwalten. Die hier verwalteten spezifischen Elemente sind wie folgt.
1, Kauf- und Verkaufsoptionen 2, Warenkorb des Kunden und Warenkorbartikel 3, Artikel zum Warenkorb hinzufügen / entfernen
Die Zahlungs-App ermöglicht Ihnen den Zugriff auf das Zahlungs-Gateway und ermöglicht es Ihnen, das vom Kunden übergebene Geld zu erhalten. Hier klicken für Details:
1, Zahlungsgateway 2, Zahlungsmethode 3, Zahlungs-API-Integration
Installieren Sie Python 3 und Pip
$ python --version
# sudo apt-get install python3
# sudo apt-get install python-pip
Installieren der PostgreSQL-Datenbank
# sudo apt-get update
# sudo apt-get install python-dev libpq-dev postgresql postgresql-contrib
Virtualenv installieren
# sudo pip install virtualenv
Kisseninstallation Mit dieser Bibliothek können Sie Profile und Produktbilder auf Vorlagen drucken.
(venv)$ pip install pillow
Dieser Befehl erstellt eine virtuelle Umgebung im venv-Ordner, die python3 zum Standard-Python-Interpreter macht.
$ virtualenv venv --python=python3
$ cd venv
Dieser Befehl aktiviert diese virtuelle Umgebung.
$ source bin/activate
(venv)$ cd venv
(venv)$ pip install django==2.1
(venv)$ django-admin startproject buyandsell
Nach erfolgreichem Abschluss der oben genannten Schritte sollte der resultierende Projektordner folgendermaßen aussehen:
buyandsell/
buyandsell/
__init__.py
settings.py
urls.py
wsgi.py
db.sqlite3
manage.py
Hier sind einige der Dateien, die in diesem Ordner angezeigt werden.
1, ** settings.py **: Mit dieser Datei wird die Kernkonfiguration der App festgelegt, z. B. Datenbankzugriffsparameter und statische Dateidienstdefinitionen. 2, ** urls.py **: Mit dieser Datei wird ein URL-Stamm erstellt, der den von der Anwendung gespeicherten Inhalt bereitstellt. 3, ** wsgi.py **: Diese Datei definiert die Standardeinstellungen, die vom Webserver in den Bereitstellungseinstellungen verwendet werden. 4, ** manage.py **: Das Hauptskript zum Verwalten des Django-Projekts und seiner Anwendungen (Datenbankmigration, Testausführung, Ausführung des Entwicklungsservers). 5, ** db.sqlite3 **: Dies ist die in Django voreingestellte Standarddatenbank. Verwenden Sie es nur für die Entwicklung. Ändern Sie es jedoch bei der Bereitstellung in eine PostgreSQL-Datenbank, die in Verbindung mit der Django-Anwendung verwendet wird. 6, ** admin.py **: Wird zum Generieren einer Admin-Schnittstellenanwendung verwendet. 7, ** tests.py **: Definiert die Tests, die beim Testen der App ausgeführt werden sollen. 8, ** app.py **: Diese Datei enthält die Standardeinstellungen für die App.
Nach dem Erstellen des Projekts müssen Sie grundlegende Tabellen wie Benutzer, Sitzung usw. erstellen, um das Standardverhalten von Django bereitzustellen.
(venv)$ cd buyandsell
(venv)$ python manage.py migrate
Der Django-Superuser ist der Root-Benutzer von Linux, und dieser Benutzer hat alle Rechte an den in der Django-Datenbank gespeicherten Daten. Dieser Benutzer hat alle Zugriff auf die Administrationsoberfläche.
(venv)$ cd buyandsell
(venv)$ python manage.py createsuperuser admin
Hinweis: Bitte geben Sie ein 8-stelliges Passwort ein, das eine Mischung aus Groß- und Kleinbuchstaben und Sonderzeichen ist.
Sie können testen, ob es funktioniert, indem Sie einen Befehl im Ordner 'buyandsell'root ausgeben.
(venv)$ python manage.py runserver SERVER_IP:SERVER_PORT
SERVER_IP ist die öffentliche IP-Adresse der Instanz der virtuellen Maschine und SERVER_PORT ist der auf dem Server konfigurierte externe Port.
Alle in diesem Tutorial entwickelten Anwendungen folgen dem folgenden Verfahren.
(venv)$ cd buyandsell
(venv)$ django-admin startapp core
Nach der Initialisierung der Kern-App sollte der Projektordner einen neuen Ordner mit der folgenden Struktur haben:
core/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
Damit Django die Kern-App als Teil des buyandsell-Projekts betrachten kann, müssen Sie Ihrer Datei settings.py die folgenden Einstellungen hinzufügen:
….
INSTALLED_APPS = [
'core',
…
]
….
Wie oben erwähnt, behandelt diese App die folgenden Modelle.
1, Benutzerprofil 2, Produkt 3, Produktkategorie Und hier ist der entsprechende Quellcode.
from django.db import models
from django.urls import reverse
from django.contrib.auth.models import User
from django.conf import settings
from datetime import datetime
class UserProfile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
photo = models.ImageField(upload_to='profile_images', blank=True)
phone = models.CharField(max_length=20)
def __str__(self):
return self.user + "profile"
def get_absolute_url(self):
return reverse("profile_detail", kwargs={"pk": self.pk})
class Product(models.Model):
""" This the default Product class """
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='product_images', blank=True)
price_ht = models.FloatField()
category = models.ForeignKey("core.Category", on_delete=models.CASCADE)
created_at = models.DateTimeField(default=datetime.now)
created_by = models.ForeignKey(User, on_delete=models.CASCADE)
TVA_AMOUNT = 19.25
def price_ttc(self):
return self.price_ht + self.TVA_AMOUNT
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("product_detail", kwargs={"pk": self.pk})
class Category(models.Model):
name = models.CharField(max_length=50)
description = models.TextField(max_length=100)
photo = models.ImageField(upload_to='category_images', blank=True)
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse("category_detail", kwargs={"pk": self.pk})
Nach dem Definieren des Modells müssen Sie diese Strukturen mit dem folgenden Befehl in der Datenbank speichern:
(venv)$ python manage.py makemigrations
(venv)$ python manage.py migrate
Sie müssen Ansichten und Vorlagendateien definieren, damit Endbenutzer über Ihren Browser auf Ihre Anwendung zugreifen können.
Erstellen Sie Ansichten und Vorlagendateien, um die Modellerstellung, Aktualisierungen, Löschungen, Listen und Details zu verwalten.
Der Inhalt der Datei views.py wird unten angezeigt.
from django.shortcuts import render
from django.views.generic import DetailView, ListView, CreateView, UpdateView, DeleteView
from .models import Product, Category, UserProfile
# Product views
class ProductDetailView(DetailView):
model = Product
template_name = "core/product_detail.html"
class ProductListView(ListView):
model = Product
template_name = "core/product_list.html"
class ProductCreateView(CreateView):
model = Product
template_name = "core/product_create.html"
def form_valid(self, form):
form.instance.created_by = self.request.user
return super().form_valid(form)
class ProductUpdateView(UpdateView):
model = Product
template_name = "core/product_update.html"
class ProductDeleteView(DeleteView):
model = Product
template_name = "core/product_delete.html"
Hier stellen wir die HTML-Vorlage vor, mit der das Formular zur Produkterstellung angezeigt wird.
{% extends 'base.html' %}
{% block title %} Creation of a product {% endblock %}
{% block menu_bar %}
{{ block.super }}
<li class="active" ><a href="{% url 'product-list' %}">products</a></li>
{% endblock menu_bar %}
{% block content %}
<h3>Creation of a product</h3>
<form action="" method="post" enctype="multipart/form-data" >
{% csrf_token %}
{{ form.as_p }}
<input type="submit" value="Create">
<button class="button"><a href="{% url 'product-list' %}">Cancel</a></button>
</form>
{% endblock %}
Die HTML-Vorlagendatei befindet sich im Verzeichnis templates / core im Stammordner der Kernanwendung.
Weitere Informationen zur Verwendung von Django-Vorlagendateien finden Sie unter: django-website / templates
UrlConf ist eine Struktur, die definiert, wie die Navigation in Ihrer Anwendung erfolgt. Es wird in der Datei views.py festgelegt.
Unten ist der Inhalt dieser Datei.
# Product Urls
urlpatterns = [
path('products/', views.ProductListView.as_view(), name='product-list'),
path('product/<int:pk>/', views.ProductDetailView.as_view(), name='product-detail'),
path('product/create/', views.ProductCreateView.as_view(), name='product-create'),
path('product/<int:pk>/update/', views.ProductUpdateView.as_view(), name='product-update'),
path('product/<int:pk>/delete/', views.ProductDeleteView.as_view(), name='product-delete'),
]
Die bisher definierten Routen dienen als Einstiegspunkte für den Zugriff auf die im Ansichtsabschnitt definierten Vorlagendateien. Diese Datei erstellt eine Bindung zwischen dem URL-Pfad und der dieser URL zugeordneten Ansicht.
Wenn Sie eine Webanwendung erstellen, um die Geschäftsanforderungen Ihres Kunden zu erfüllen, erstellen Sie im Allgemeinen auch eine Administratoranwendung, die die in der Datenbank gespeicherten Daten, Berechtigungen, Berechtigungen und Rollen verwaltet. Django vereinfacht das Leben von Webentwicklern, da dies bereits standardmäßig erfolgt.
Um die Admin-Oberfläche zu konfigurieren, müssen Sie admin.py ändern und für die Verwendung des Modells konfigurieren.
Die Einstellungen werden auf diese Weise vorgenommen.
from core.models import Product
class ProductAdmin(admin.ModelAdmin):
pass
admin.site.register(Product, ProductAdmin)
Alternativ können Sie die Klasse ProductAdmin mit Anmerkungen versehen.
@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass
Verwenden Sie nach dem Wiederholen dieser Schritte für alle Modelle den folgenden Code in der Datei admin.py.
from django.contrib import admin
from core.models import Product, Category, UserProfile
@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
pass
@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
pass
@admin.register(UserProfile)
class UserProfileAdmin(admin.ModelAdmin):
pass
Sobald dies erledigt ist, können Sie Ihren Browser unter der folgenden Adresse öffnen, um den Administratorbildschirm anzuzeigen.
127.0.0.1:8000/admin/
Sie haben sich mit dem in diesem Lernprogramm erstellten Superuser-Konto angemeldet.
Jetzt, da wir eine funktionierende Anwendung haben, versuchen wir, einige Stile hinzuzufügen, um sie sichtbarer zu machen. Verwenden Sie also Bootstrap 3 und die Jquery-Bibliothek, um Ihrer Anwendung Stile hinzuzufügen.
Es gibt einen Prozess, um dies zu tun.
Laden Sie die entsprechende Quelldatei herunter.
1、bootstrap.css 2、bootstrap.js 3、jquery.js
Erstellen Sie einen Unterordner mit dem Namen static im Kernordner und einen weiteren Ordner mit dem Namen core darin. Platzieren Sie auf diese Weise die statischen Dateien der Kern-App in diesen Ordnern.
Legen Sie die Einstellungen STATIC_ROOT und STATIC_URL fest, um über Ihren Browser auf diese Dateien zuzugreifen
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, '/static/')
Konsolidieren Sie statische Dateien in der Datei base.html und stellen Sie diesen Bibliotheken geerbte Vorlagen zur Verfügung.
Laden Sie zunächst alle statischen Bibliotheken.
{% load static %}
Mit diesem Tag können Sie jetzt statische Ressourcen in statischen Ordnern verwenden, wie unten gezeigt.
{% static 'core/css/bootstrap.css' %}
Unten finden Sie die Datei base.html, die sich aus dem erfolgreichen Import aller statischen Ressourcen ergibt.
<!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">
<meta name="description" content="">
<meta name="author" content="">
<link rel="icon" href="../../favicon.ico">
<title>{% block title %} Welcome to the core app !! {% endblock %}</title>
<link rel="stylesheet" type="text/css" href="{% static 'core/css/bootstrap.css' %}">
<link rel="stylesheet" type="text/css" href="{% static 'core/css/main.css' %}">
</head>
<body>
<script src="{% static 'core/js/jquery.js' %}"></script>
<script src="{% static 'core/js/bootstrap.js' %}"></script>
</body>
</html>
Am Ende dieses Tutorials erfahren Sie, wie Sie eine Anwendung mit dem Django-Webframework erstellen. Genauer gesagt haben wir die Modelle, Ansichten und Vorlagen von Django kennengelernt.
Der Quellcode für die in diesem Tutorial verwendete Anwendung befindet sich auf GitHub.
https://github.com/binel01/buyandsell/tree/master/core
Recommended Posts