Injektion af almindelige dependencies
Implementér almindelige dependencies til databasesessioner, brugergodkendelse eller delt konfiguration på tværs af endpoints.
Injektion af almindelige dependencies er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Bootcamp i FastAPI-backendudvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Introduktion til almindelige afhængigheder
I FastAPI er afhængigheder kraftfulde. De hjælper dig med at dele logik, administrere ressourcer og holde din kode ren.
Almindelige afhængigheder er funktioner eller klasser, som du genbruger på tværs af mange API-endepunkter. Det forhindrer gentagen kode og gør din applikation nemmere at vedligeholde og teste.
Betragt dem som genanvendelige byggesten til dit API.
Injektion af delt konfiguration
Mange applikationer har brug for globale indstillinger, f.eks. API-nøgler eller database-URL'er. Ved at injicere konfiguration kan du nemt få adgang til disse indstillinger i ethvert endepunkt uden at ty til globale variabler.
Det holder din konfiguration fleksibel og nem at opdatere.
Demo: Simpel konfigurationsafhængighed
Lad os oprette en afhængighed, der returnerer en simpel indstillingsordbog. I en rigtig applikation kunne den indlæse indstillinger fra miljøvariabler ved hjælp af Pydantics BaseSettings.
from fastapi import FastAPI, Depends
app = FastAPI()
# This function acts as our dependency
def get_settings():
return {"app_name": "CoddyKit API", "version": "1.0.0"}
@app.get("/info")
def read_info(settings: dict = Depends(get_settings)):
return {"message": f"Welcome to {settings['app_name']} v{settings['version']}"}
# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/infoHåndtering af databasesessioner
En almindelig opgave for backend-API'er er at arbejde med en database. Hver forespørgsel har typisk brug for sin egen unikke database-"session" eller forbindelse.
Det er besværligt og fejlbehæftet at administrere disse sessioner manuelt i hvert endepunkt. En afhængighed kan automatisk oprette og lukke dem for dig.
Demo: Afhængighed til databasesession
Her er et forenklet eksempel på en get_db-afhængighed. I en rigtig applikation ville den oprette forbindelse til en database ved hjælp af en ORM som SQLAlchemy.
Nøgleordet yield er centralt her!
from fastapi import FastAPI, Depends
from typing import Generator
app = FastAPI()
# This simulates a database session.
# In a real app, this would be a SQLAlchemy session.
class MockDBSession:
def __init__(self):
print("Opening DB session...")
def close(self):
print("Closing DB session...")
def query(self, item_id: int):
return {"id": item_id, "name": f"Item {item_id}"}
def get_db() -> Generator:
db = MockDBSession()
try:
yield db # This is where the endpoint gets the 'db' object
finally:
db.close() # This runs after the request is finished
@app.get("/items/{item_id}")
def read_item(item_id: int, db: MockDBSession = Depends(get_db)):
# The 'db' object is provided by the dependency
return db.query(item_id)
# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/items/1Det magiske ved `yield`
Nøgleordet yield i vores funktion get_db er meget vigtigt.
- Kode før
yieldkøres før slutpunktfunktionen. Det bruges til opsætning, f.eks. til at åbne en databaseforbindelse. - Kode efter
yieldkøres efter slutpunktfunktionen og dens svar. Det bruges til oprydning, f.eks. til at lukke forbindelsen.
Dette mønster kaldes en "afhængighed med yield" eller en "afhængighed med konteksthåndtering".
Indsprøjtning af brugergodkendelse
De fleste API'er har brug for at vide, hvem der sender en forespørgsel. Afhængigheder til autentifikation udtrækker brugeroplysninger fra forespørgslens headere (f.eks. en API-nøgle eller et JWT-token) og gør dem tilgængelige for dine endepunkter.
Det holder din autentifikationslogik adskilt og genanvendelig på tværs af mange ruter.
Demo: Afhængighed for den aktuelle bruger
Her er en grundlæggende afhængighed, der simulerer hentning af den aktuelle bruger. I en rigtig applikation ville det indebære validering af et token fra anmodningens headere.
Hvis brugeren ikke er godkendt, kan funktionen rejse en HTTPException for at stoppe anmodningen tidligt.
from fastapi import FastAPI, Depends, HTTPException, status
from typing import Optional
app = FastAPI()
class User:
def __init__(self, username: str, email: Optional[str] = None):
self.username = username
self.email = email
# This dependency simulates fetching the current user
def get_current_user(token: str = "some_valid_token") -> User:
# In a real app, 'token' would come from request headers
# and be validated against a database or auth service.
if token != "some_valid_token":
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid authentication credentials",
headers={"WWW-Authenticate": "Bearer"},
)
return User(username="jane_doe", email="jane@example.com")
@app.get("/me")
def read_current_user(current_user: User = Depends(get_current_user)):
return {"username": current_user.username, "email": current_user.email}
# To run this:
# 1. Save as main.py
# 2. Run 'uvicorn main:app --reload'
# 3. Go to http://127.0.0.1:8000/meKædning og genbrug af afhængigheder
Afhængigheder kan også afhænge af andre afhængigheder! Det gør det muligt at opdele kompleks logik i mindre og håndterbare dele.
En afhængighed for en "aktuel administratorbruger" kan f.eks. først afhænge af "aktuel bruger" og derefter kontrollere, om brugeren har administratorrettigheder.
Denne modularitet er en af de vigtigste styrker ved FastAPI's afhængighedsindsprøjtning.
Tjek din forståelse
Se på følgende FastAPI-afhængighed:
from fastapi import HTTPException, status
def check_api_key(api_key: str = "SECRET_KEY"):
if api_key != "VALID_API_KEY":
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Invalid API Key"
)
return True
Hvis et slutpunkt bruger Depends(check_api_key), og der kommer en anmodning uden den korrekte API_KEY, hvad sker der så?
Almindelige afhængigheder: Vigtigste pointer
Vi har undersøgt, hvordan du kan indsætte almindelige afhængigheder i FastAPI:
- Konfiguration: Del nemt applikationsindstillinger på tværs af slutpunkter.
- Databasesessioner: Håndter databaseforbindelser pr. anmodning ved hjælp af
yieldfor korrekt opsætning og oprydning. - Brugergodkendelse: Saml logikken til identifikation og validering af brugere ét sted.
Afhængigheder fremmer ren, genanvendelig og testbar kode ved at holde tværgående hensyn adskilt fra din primære logik for slutpunkter.
Lær Bootcamp i FastAPI-backendudvikling med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 21
- Lektioner
- 84
Ofte stillede spørgsmål
Er lektionen “Injektion af almindelige dependencies” gratis?
Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Injektion af almindelige dependencies”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Injektion af almindelige dependencies”?
Implementér almindelige dependencies til databasesessioner, brugergodkendelse eller delt konfiguration på tværs af endpoints. Du øver dig i Bootcamp i FastAPI-backendudvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Bootcamp i FastAPI-backendudvikling?
Der kræves ingen tidligere erfaring. Bootcamp i FastAPI-backendudvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Injektion af almindelige dependencies”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Bootcamp i FastAPI-backendudvikling-lektion?
Ja. Alle Bootcamp i FastAPI-backendudvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Forstå dependencies i FastAPI
- Injektion af almindelige dependencies
- Klassebaserede dependencies og yield-dependencies
- Globale dependencies og sub-dependencies