Wenn Sie eine Backend-Technologie oder ein Backend-Framework wie Django, Laravel oder Node.js zum Schreiben von REST-APIs verwenden, benötigen Sie Folgendes eine zusätzliche Frontend-Fähigkeit zu haben, die Frameworks wie React, Angular und Vue verwendet, um die API zu nutzen Endpunkte. Dies ist jedoch nicht immer der Fall. Sie können die APIs in Django selbst mithilfe von Django-Vorlagen nutzen.

Einrichten eines Django-Projekts und API-Endpunkten

Der erste Schritt besteht darin, ein Projektverzeichnis zu erstellen. Öffnen Sie Ihr Terminal und erstellen Sie ein Verzeichnis für Ihr Projekt.

mkdir payment_wallet_project
cd payment_wallet_project

In diesem Tutorial erstellen Sie APIs für ein Zahlungs-Wallet.

Der vollständige Quellcode ist in a verfügbar GitHub-Repository.

Beginnen Sie mit Erstellen einer virtuellen Umgebung. In diesem Fall verwenden Sie die Pipenv-Bibliothek.

pipenv install django djangorestframework

Dieser Befehl installiert die erforderlichen Bibliotheken und erstellt eine virtuelle Umgebung.

Aktivieren Sie die virtuelle Umgebung mit dem folgenden Befehl:

pipenv shell

Erstellen Sie ein neues Django-Projekt genannt PayApp.

django-admin startproject PayApp .

Mit dem Punkt (.) am Ende von django-admin Der Befehl stellt sicher, dass das Projekt die Erstellung eines doppelten Verzeichnisses des Projektverzeichnisses vermeidet.

Ein... kreieren neue Django-App im Projektverzeichnis.

python manage.py startapp wallet

Fahren Sie nun mit der Erstellung Ihrer API-Anwendung fort, indem Sie die folgenden Schritte ausführen.

Erstellen einer Payment Wallet REST API

Öffne das wallet/models.py Datei ablegen und die Wallet- und Transaktionsmodelle definieren.

from django.db import models
classWallet(models.Model):
 user = models.CharField(max_length=100)
 balance = models.DecimalField(max_digits=10, decimal_places=2)
 date_created = models.DateTimeField(auto_now_add=True)
 date_modified = models.DateTimeField(auto_now=True)
def__str__(self):
return self.user
classTransaction(models.Model):
 wallet = models.ForeignKey(Wallet, on_delete=models.CASCADE)
 amount = models.DecimalField(max_digits=10, decimal_places=2)
 timestamp = models.DateTimeField(auto_now_add=True)

Im Geldbörse Verzeichnis, erstellen Sie eine neue Datei serializers.pyund schreiben Sie die Wallet- und Transaktionsmodell-Serialisierer.

from rest_framework import serializers
from .models import Wallet, Transaction
classWalletSerializer(serializers.ModelSerializer):
classMeta:
 model = Wallet
 fields = '__all__'
classTransactionSerializer(serializers.ModelSerializer):
classMeta:
 model = Transaction 
 fields = '__all__'

Die Serialisierer berücksichtigen alle Felder in den Wallet- und Transaktionsmodellen.

In wallet/views.pySchreiben Sie die Ansichten für die Handhabung der Logik zur Implementierung der Wallet-Funktionalität. Dazu gehören die Ein- und Auszahlungsmöglichkeiten.

from rest_framework import generics, status
from rest_framework.response import Response
from rest_framework.decorators import action
from decimal import Decimal
from .models import Wallet, Transaction
from .serializers import WalletSerializer, TransactionSerializer
classWalletViewSet(viewsets.ModelViewSet):
 queryset = Wallet.objects.all()
 serializer_class = WalletSerializer
 @action(detail=True, methods=['post'])
defdeposit(self, request, pk=None):
 wallet = self.get_object()
 amount = Decimal(request.data['amount'])
 wallet.balance += amount
 wallet.save() 
 serializer = WalletSerializer(wallet)
return Response(serializer.data)

 @action(detail=True, methods=['post'])
defwithdraw(self, request, pk=None):
 wallet = self.get_object()
 amount = Decimal(request.data['amount'])
if wallet.balance < amount:
return Response({'error': 'Insufficient funds'},
 status=status.HTTP_400_BAD_REQUEST)
 wallet.balance -= amount
 wallet.save()
 serializer = WalletSerializer(wallet)
return Response(serializer.data)'
classTransactionViewSet(viewsets.ModelViewSet):
 queryset = Transaction.objects.all()
 Serializer_class = TransactionSerializer

Definieren Sie als Nächstes das URL-Routing für die API, indem Sie eine erstellen wallet/urls.py Datei:

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import WalletViewSet, TransactionViewSet, wallet_view
router = DefaultRouter()
router.register(r'wallets', WalletViewSet, basename='wallets')
router.register(r'transactions', TransactionViewSet, basename='transactions')
urlpatterns = [
 path('api/', include(router.urls)),
 path('wallets//deposit/', WalletViewSet.as_view({'post': 'deposit'}),
 name='wallet-deposit'),
 path('wallets//withdraw/', WalletViewSet.as_view({'post': 'withdraw'}),
 name='wallet-withdraw'),
]

In Ihrem Projekt urls.py, fügen Sie die URLs der App ein:

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
 path('admin/', admin.site.urls),
 path('', include('wallet.urls')),
]

Im PayApp/settings.py Datei, fügen Sie die hinzu Geldbörse Und rest_framwork-Apps zum INSTALLED_APPS Liste.

INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
"rest_framework", # new
"wallet", # new
]

Dadurch werden die Wallet- und rest_framework-Apps bei der Django-Projektanwendung registriert.

Nutzung der API mit Django-Vorlagen

Jetzt verwenden Sie die Django-Vorlagen, um ein einfaches Frontend für die Nutzung der API zu erstellen. Ein... kreieren wallet.html Datei in der Brieftasche/Vorlagen/ Verzeichnis und fügen Sie den folgenden HTML-Code hinzu.

"en">

"UTF-8">
"viewport" content="width=device-width, initial-scale=1">


"stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/
 css/bootstrap.min.css">



class="container">
Wallets

class="table">

















User
Balance
Actions






{{ wallet.user }}
"balance">{{ wallet.balance }}


"loading-indicator"class="d-none">

class="spinner-bordertext-primary" role="status">
class="sr-only">Loading...span>



Please wait while the deposit is being processed.




"deposit-form" method="post">
 {% csrf_token %}
"number" name="amount" step="0.01" min="0" required>
"submit"class="btnbtn-success">Depositbutton>



"post" id="withdraw-form">
 {% csrf_token %}
"number" name="amount" step="0.01" min="0" required>
"submit"class="btnbtn-danger">Withdrawbutton>

Die HTML-Datei stellt die Ein- und Auszahlungs-APIs in einer schönen Benutzeroberfläche dar, die mit Bootstrap entworfen wurde.

Benutzerinteraktion mit Formularen

Erstellen Sie in der HTML-Datei ein Skript-Tag und fügen Sie den folgenden Code zum Ereignis-Listener für die Übermittlung des Einzahlungsformulars hinzu.

Fügen Sie als Nächstes den Ereignis-Listener für die Übermittlung des Widerrufsformulars hinzu, indem Sie den folgenden Code verwenden:

Der Ereignis-Listener ist für die Abwicklung der Ein- und Auszahlung verantwortlich (#Einzahlungsformular Und #Rückzugsformular) Formulareinreichungen.

Die URL für die Abrufanforderung dient zum Abgleichen der URLs für Ein- und Auszahlungsaktionen.

Die JSON-Antworten für die Ein- und Auszahlungen werden dann analysiert, um den aktualisierten Kontostand zu erhalten (data.balance). Anschließend werden sie formatiert und auf der Seite angezeigt.

Als nächstes im wallet/views.py, fügen Sie das folgende Update hinzu, um die Seite wallet.html zu rendern:

from django.shortcuts import render
defwallet_view(request):
# Retrieve the wallet to display
 wallet = Wallet.objects.first() 
return render(request, 'wallet.html', {'wallet': wallet})

In diesem Beispiel verwenden Sie die Erste() Abfragemethode zur Auswahl der Wallet eines einzelnen Benutzers zu Demonstrationszwecken.

Aktualisieren Sie die urls.py Datei durch Hinzufügen eines Pfads zu wallet_view wie folgt:

from .views import wallet_view
urlpatterns = [
 ...
 path('home/', wallet_view, name='wallet-page'),
]

Greifen Sie über die URL auf die Wallet-Seite zu: http://127.0.0.1:8000/home/.

Wenn alles eingerichtet ist und wie erwartet funktioniert, führen Sie Folgendes aus Makemigrationen Und Wandern Befehle. Führen Sie abschließend die Anwendung aus:

python manage.py makemigrations
python manage.py migrate
python manage.py runserver

Um auf die API-Endpunkte zuzugreifen, navigieren Sie zu http://127.0.0.1:8000/api/.

Erwartete Ausgabe:

Navigieren Sie zu localhost um mit der Brieftasche zu interagieren.

Erwartete Ausgabe:

Das Wallet zeigt den Kontostand an und bietet Ihnen die Möglichkeit, entweder einzuzahlen oder abzuheben.

Django-Vorlagen und ihre Rolle bei der API-Nutzung verstehen

Obwohl sie sich hervorragend für die Darstellung statischer Inhalte eignen, unterliegen Django-Vorlagen bestimmten Einschränkungen bei der Verwendung von APIs:

• Begrenzte Flexibilität: Django-Vorlagen sind weniger flexibel als solche, die mit Jinja2 oder Twig erstellt wurden, da sie zur Anzeige bestimmter Strukturen verwendet werden. Beispielsweise müssten Sie JSON manuell analysieren und die Daten in die Vorlage einfügen, wenn Sie eine API nutzen müssten, die JSON-Daten zurückgibt. Dies kann eine Herausforderung sein, vor allem wenn die API komplizierte Datenstrukturen liefert.
• Keine Unterstützung für asynchrone Anfragen: Django-Vorlagen verfügen von Haus aus nicht über die Fähigkeit, asynchrone Anfragen zu verarbeiten. Vorlagen benötigen weiterhin eine synchrone Verarbeitung, auch wenn die asynchronen/wartenden modernen Web-Frameworks wie Flask und Django die Syntax unterstützen. Das bedeutet, dass Sie mit der Erstellung der Vorlage warten müssten, bis alle Anfragen abgeschlossen sind, wenn Sie vor dem Rendern einer Seite Daten aus zahlreichen Quellen abrufen müssten.
• Eingeschränkte Fehlerbehandlung: Bei der Verwendung von APIs kann es regelmäßig zu Fehlern kommen. In Django-Vorlagen gibt es keine integrierten Mechanismen für eine ordnungsgemäße Fehlerbehandlung. Sie müssten die Ausnahme abfangen und innerhalb der Vorlage selbst verwalten, wenn ein API-Aufruf fehlschlägt, was zu ungeschicktem und schwierig zu wartendem Code führen könnte.

Erstellen Sie skalierbare Anwendungen

Durch die Möglichkeit, die Präsentationsebene von der Geschäftslogik zu trennen, ermöglichen Django-Vorlagen Entwicklern, sich auf die Erstellung wiederverwendbaren und wartbaren Codes zu konzentrieren. Aufgrund ihrer Einschränkungen sind Django-Vorlagen jedoch möglicherweise nicht die beste Wahl, wenn APIs in großem Maßstab genutzt werden. Client-Frameworks wie React sind immer noch nützlich beim Erstellen skalierbarer Anwendungen.