Förstå beroenden i FastAPI
Utforska konceptet dependency injection och hur det förenklar kodorganisation och återanvändning i FastAPI.
Förstå beroenden i FastAPI är en gratis lektion i Bootcamp i backendutveckling med FastAPI på CoddyKit. Detta är lektion 1 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.
Vad är dependency injection?
Har du någon gång önskat att dina funktioner automatiskt kunde få de verktyg de behöver? Det är det som Dependency Injection (DI) hjälper till med!
I FastAPI är DI ett kraftfullt designmönster där komponenter, till exempel dina API-slutpunkter, inte skapar sina beroenden själva. I stället deklarerar de vad de behöver, och FastAPI "injicerar" dem.
Fördelar med FastAPI DI
FastAPI använder DI i stor utsträckning eftersom det gör din kod:
- Återanvändbar: Skriv logik en gång och använd den överallt.
- Testbar: Byt enkelt ut riktiga tjänster mot simulerade versioner i tester.
- Ren: Håller sökvägsfunktionerna fokuserade på sin huvuduppgift.
- Underhållbar: Ändringar i beroenden sprids inte genom hela applikationen.
Skapa ett grundläggande beroende
Ett beroende i FastAPI är vanligtvis bara en vanlig Python-funktion.
Funktionen kan utföra all konfiguration, validering eller resursinhämtning som behövs innan din huvudsakliga API-logik körs. Den kan även returnera ett värde.
FastAPI anropar automatiskt funktionen och skickar resultatet till din slutpunkt.
Injicera i en slutpunkt
För att använda ett beroende deklarerar du det som en parameter i din sökvägsfunktion med FastAPI:s särskilda funktion Depends.
När en begäran kommer in kontrollerar FastAPI slutpunktens parametrar, löser eventuella beroenden och anropar sedan slutpunkten med resultaten.
Ett enkelt beroende i praktiken
Vi tittar på ett grundläggande beroende som returnerar en enkel sträng. Observera hur get_message anropas av FastAPI innan read_root.
from fastapi import FastAPI, Depends
app = FastAPI()
def get_message():
return "Hello from dependency!"
@app.get("/")
async def read_root(message: str = Depends(get_message)):
return {"message": message}
# To run this:
# 1. Save as main.py
# 2. pip install fastapi uvicorn
# 3. uvicorn main:app --reload
# Then visit http://127.0.0.1:8000/Beroenden kan ha parametrar
Beroenden är inte begränsade till enkla funktioner. De kan även ta emot egna parametrar, som FastAPI också löser.
Det innebär att ett beroende i sin tur kan vara beroende av andra beroenden och bilda en kedja! Det är mycket kraftfullt när du bygger komplex logik.
Beroende som tar emot indata
Här är greet_user ett beroende som tar emot en name. Om name inte anges i frågan används 'Guest' som standardvärde.
from fastapi import FastAPI, Depends
app = FastAPI()
def greet_user(name: str = "Guest"):
return f"Hello, {name}!"
@app.get("/greet/")
async def say_hello(greeting: str = Depends(greet_user)):
return {"greeting": greeting}
# To run this:
# uvicorn main:app --reload
# Visit http://127.0.0.1:8000/greet/
# And http://127.0.0.1:8000/greet/?name=CoddyFörstå `Depends()`
Den magiska delen som kopplar din slutpunkt till ett beroende är funktionen Depends().
- Den säger till FastAPI: "Innan den här funktionen körs, lös det här beroendet."
- Du skickar själva beroendefunktionen (eller ett anropbart objekt) direkt till
Depends(), inte dess resultat. - FastAPI hanterar anropet av beroendefunktionen åt dig.
Användningsområden för beroenden
Beroenden passar perfekt för:
- Databasanslutningar: Hämta en session för varje begäran.
- Autentisering: Verifiera användaruppgifter.
- Behörighetskontroll: Kontrollera användarroller och behörigheter.
- Delad logik: Kod som flera slutpunkter behöver.
De håller ditt API rent och fokuserat.
Kontroll av beroendekonceptet
Studera följande FastAPI-kodavsnitt:
from fastapi import FastAPI, Depends
app = FastAPI()
def get_db_session():
# Imagine this connects to a database
return "Database Session Object"
@app.get("/items/")
async def read_items(session: str = Depends(get_db_session)):
return {"message": f"Using {session}"}Vilket värde har session inuti funktionen read_items när en begäran skickas till /items/?
Sammanfattning: beroenden förklarade
Du har tagit ett viktigt steg mot att bemästra FastAPI genom att förstå Dependency Injection!
- Beroenden är funktioner som FastAPI kör innan din slutpunkt.
- De håller koden modulär, återanvändbar och testbar.
- Du deklarerar dem med
param: Type = Depends(your_dependency_func).
Härnäst går vi igenom fler vanliga och avancerade mönster för beroenden!
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
Vanliga frågor
Är lektionen ”Förstå beroenden i FastAPI” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Bootcamp i backendutveckling med FastAPI, inklusive ”Förstå beroenden i FastAPI”, 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 ”Förstå beroenden i FastAPI”?
Utforska konceptet dependency injection och hur det förenklar kodorganisation och återanvändning i FastAPI. 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 1 av 4.
Hur lång tid tar lektionen ”Förstå beroenden i FastAPI”?
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