Bootcamp i backendutveckling med FastAPI · Lektion

Injektion av gemensamma beroenden

Implementera gemensamma beroenden för databassessioner, användarautentisering eller delad konfiguration mellan endpoints.

Lektion 2 av 411 steg

Injektion av gemensamma beroenden är en gratis lektion i Bootcamp i backendutveckling med FastAPI på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med FastAPI, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

Introduktion till vanliga beroenden

I FastAPI är beroenden kraftfulla. De hjälper dig att dela logik, hantera resurser och hålla koden ren.

Vanliga beroenden är funktioner eller klasser som du återanvänder i många API-slutpunkter. Det förhindrar upprepad kod och gör applikationen enklare att underhålla och testa.

Se dem som återanvändbara byggblock för ditt API.

Injicera delad konfiguration

Många applikationer behöver globala inställningar, till exempel API-nycklar eller databas-URL:er. Genom att injicera konfiguration kan du enkelt komma åt dessa inställningar i alla slutpunkter utan att använda globala variabler.

Det håller konfigurationen flexibel och enkel att uppdatera.

Demo: enkelt konfigurationsberoende

Vi skapar ett beroende som returnerar en enkel inställningsordbok. I en verklig applikation kan detta läsa in värden från miljövariabler med hjälp av 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/info

Hantera databassessioner

En vanlig uppgift för backend-API:er är att kommunicera med en databas. Varje begäran behöver vanligtvis sin egen unika "session" eller anslutning.

Att hantera dessa sessioner manuellt i varje slutpunkt är tidskrävande och felbenäget. Ett beroende kan automatiskt skapa och stänga dem åt dig.

Demo: databassessionsberoende

Här är ett förenklat exempel på beroendet get_db. I en verklig applikation skulle detta ansluta till en databas med hjälp av ett ORM-verktyg som SQLAlchemy.

Nyckelordet yield är centralt här!

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/1

Magin med `yield`

Nyckelordet yield i vår get_db-funktion är mycket viktigt.

Kod före yield körs före endpoint-funktionen. Detta används för förberedelser, till exempel för att öppna en databasanslutning.
Kod efter yield körs efter endpoint-funktionen och dess svar. Detta används för att avsluta och städa upp, till exempel genom att stänga anslutningen.

Detta mönster kallas en "dependency med yield" eller en "context manager-dependency".

Injicera användarautentisering

De flesta API:er behöver veta vem som skickar en begäran. Autentiseringsdependencies hämtar användarinformation från request-headers, till exempel en API-nyckel eller JWT-token, och gör den tillgänglig för dina endpoints.

Detta håller autentiseringslogiken separat och återanvändbar i många routes.

Demo: Dependency för aktuell användare

Här är en enkel dependency som simulerar hämtning av den aktuella användaren. I en verklig applikation skulle detta innebära att en token från request-headers valideras.

Om användaren inte är autentiserad kan funktionen kasta ett HTTPException för att stoppa begäran tidigt.

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/me

Kedja och återanvänd dependencies

Dependencies kan också bero på andra dependencies! Det gör det möjligt att dela upp komplex logik i mindre, hanterbara delar.

En dependency för en "aktuell administratörsanvändare" kan till exempel först bero på "aktuell användare" och sedan kontrollera om användaren har administratörsbehörighet.

Denna modularitet är en av de största styrkorna med FastAPI:s dependency injection.

Kontrollera dina kunskaper

Studera följande FastAPI-dependency:

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

Om en endpoint använder Depends(check_api_key) och en begäran kommer in utan korrekt API_KEY, vad händer då?

Besvara frågan i den interaktiva lektionen

Vanliga dependencies: viktiga slutsatser

Vi har gått igenom hur du injicerar vanliga dependencies i FastAPI:

Konfiguration: Dela enkelt applikationsinställningar mellan endpoints.
Databassessioner: Hantera databasanslutningar per begäran genom att använda yield för korrekta förberedelser och korrekt avslutning.
Användarautentisering: Samla logiken för att identifiera och validera användare på ett ställe.

Dependencies främjar ren, återanvändbar och testbar kod genom att hålla tvärgående funktionalitet separat från huvudlogiken i dina endpoints.

Gratis att börja

Lär dig Bootcamp i backendutveckling med FastAPI med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Injektion av gemensamma beroenden” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Bootcamp i backendutveckling med FastAPI, inklusive ”Injektion av gemensamma beroenden”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

Vad lär jag mig i ”Injektion av gemensamma beroenden”?

Implementera gemensamma beroenden för databassessioner, användarautentisering eller delad konfiguration mellan endpoints. Ni övar på Bootcamp i backendutveckling med FastAPI med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med FastAPI?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med FastAPI på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Injektion av gemensamma beroenden”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med FastAPI-lektionen?

Ja. Varje Bootcamp i backendutveckling med FastAPI-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Förstå beroenden i FastAPI
Injektion av gemensamma beroenden
Klassbaserade beroenden och yield-beroenden
Globala beroenden och underberoenden

← Tillbaka till Bootcamp i backendutveckling med FastAPI