Brez truda lahko uporabljate preproste API-je, ne da bi morali konfigurirati zunanji vmesnik. Naučite se uporabljati predloge Django za uporabo API-ja.

Če za pisanje API-jev REST uporabljate zaledno tehnologijo ali ogrodje, kot je Django, Laravel ali Node.js, potrebujete imeti dodatno veščino čelnega dela z uporabo ogrodij, kot so React, Angular in Vue, za uporabo API-ja končne točke. Vendar to ni vedno tako, lahko uporabite API-je v samem Djangu z uporabo predlog Django.

Nastavitev projekta Django in končnih točk API-ja

Prvi korak bo ustvarjanje imenika projekta. Odprite terminal in ustvarite imenik za svoj projekt.

mkdir payment_wallet_project
cd payment_wallet_project

Za to vadnico boste zgradili API-je za plačilno denarnico.

Celotna izvorna koda je na voljo v a Repozitorij GitHub.

Začni z ustvarjanje virtualnega okolja. V tem primeru boste uporabili knjižnico Pipenv.

pipenv install django djangorestframework

Ta ukaz namesti potrebne knjižnice in ustvari virtualno okolje.

Aktivirajte virtualno okolje s spodnjim ukazom:

instagram viewer 
pipenv shell

Ustvarite nov projekt Django imenovan PayApp.

django-admin startproject PayApp .

Uporaba pike (.) na koncu django-admin ukaz zagotavlja, da se projekt izogne ​​ustvarjanju podvojenega imenika projektnega imenika.

Ustvariti nova aplikacija Django v imeniku projekta.

python manage.py startapp wallet

Zdaj nadaljujte z izgradnjo svoje aplikacije API po spodnjih korakih.

Ustvarjanje API-ja REST za plačilno denarnico

Odprite denarnica/modeli.py datoteko ter definirajte denarnico in modele transakcij.

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)

V denarnica ustvarite novo datoteko serializers.pyin napišite serializatorje denarnice in transakcijskega modela.

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

Serializatorji upoštevajo vsa polja v modelih denarnice in transakcij.

notri denarnica/views.py, napišite poglede za obravnavo logike izvajanja funkcionalnosti denarnice. To vključuje zmožnosti pologa in dviga.

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

Nato definirajte usmerjanje URL za API tako, da ustvarite a denarnica/urls.py mapa:

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

V vašem projektu urls.py, vključite URL-je aplikacije:

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

V PayApp/settings.py datoteko, dodajte denarnica in aplikacije rest_framwork do INSTALLED_APPS seznam.

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
]

To bo registriralo aplikacije denarnice in rest_framework v aplikaciji projekta Django.

Uporaba API-ja s predlogami Django

Zdaj boste uporabili predloge Django za ustvarjanje preprostega vmesnika za uporabo API-ja. Ustvariti denarnica.html datoteka v denarnica/predloge/ in dodajte spodnjo kodo HTML.


"en">

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

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




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

Datoteka HTML upodablja API-je za polog in dvig v čudovitem uporabniškem vmesniku, zasnovanem z uporabo Bootstrapa.

Interakcija uporabnika z obrazci

V datoteki HTML ustvarite oznako skripta in dodajte naslednjo kodo poslušalcu dogodka oddaje obrazca za depozit.

Nato dodajte poslušalca dogodkov za oddajo obrazca za odstop s spodnjo kodo:

Poslušalec dogodka je odgovoren za polog in dvig (#depozitni obrazec in #obrazec za umik) oddaje obrazcev.

URL za zahtevo za pridobivanje je za ujemanje URL-jev za dejanja depozita in dviga.

Odgovori JSON za pologe in dvige se nato razčlenijo, da se pridobi posodobljeno stanje (podatki.ravnotežje). Nato so oblikovani in prikazani na strani.

Naprej, v denarnica/views.py, dodajte naslednjo posodobitev za upodobitev strani wallet.html:

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

V tem primeru boste uporabili prvi() poizvedovalno metodo za izbiro denarnice enega uporabnika za namene predstavitve.

Posodobite urls.py datoteko tako, da dodate pot do wallet_view kot sledi:

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

Dostopite do strani denarnice z URL-ja: http://127.0.0.1:8000/home/.

Ko je vse nastavljeno in deluje po pričakovanjih, izvedite makemigrations in seliti ukazi. Na koncu zaženite aplikacijo:

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

Za dostop do končnih točk API-ja pojdite na http://127.0.0.1:8000/api/.

Pričakovani rezultat:

Pomaknite se do lokalni gostitelj za interakcijo z denarnico.

Pričakovani rezultat:

Denarnica prikazuje stanje in vam daje možnost vplačila ali dviga.

Razumevanje predlog Django in njihove vloge pri uporabi API-jev

Kljub temu, da so odlične za predstavitev statične vsebine, imajo predloge Django določene omejitve pri uporabi API-jev:

  • Omejena prilagodljivost: Predloge Django so manj prilagodljive kot tiste, ustvarjene z uporabo Jinja2 ali Twig, saj se uporabljajo za prikaz določenih struktur. Na primer, morali bi ročno razčleniti JSON in vstaviti podatke v predlogo, če bi morali uporabiti API, ki je vrnil podatke JSON. To je lahko izziv, predvsem če API zagotavlja zapletene podatkovne strukture.
  • Ni podpore za asinhrone zahteve: Predloge Django izvorno nimajo zmožnosti obravnavanja asinhronih zahtev. Predloge še vedno potrebujejo sinhrono obdelavo, čeprav async/await sodobna spletna ogrodja, kot sta Flask in Django, podpirata sintakso. To pomeni, da bi morali počakati, da se vse zahteve končajo, preden ustvarite predlogo, če bi morali pred upodabljanjem strani pridobiti podatke iz številnih virov.
  • Omejeno obravnavanje napak: Pri uporabi API-jev se lahko redno pojavljajo napake. V predlogah Django ni vgrajenih mehanizmov za elegantno obravnavanje napak. Če klic API-ja ne uspe, bi morali ujeti izjemo in jo upravljati znotraj same predloge, kar bi lahko povzročilo okorno kodo, ki jo je težko vzdrževati.

Zgradite razširljive aplikacije

Z zagotavljanjem načina za ločitev predstavitvene plasti od poslovne logike Django predloge omogočajo razvijalcem, da se osredotočijo na ustvarjanje kode, ki jo je mogoče ponovno uporabiti in vzdrževati. Vendar pa predloge Django zaradi svojih omejitev morda niso najboljša izbira pri veliki uporabi API-jev. Odjemalski okviri, kot je React, so še vedno uporabni pri gradnji razširljivih aplikacij.