Bootcamp i FastAPI-backendudvikling · Lektion

Klassebaserede dependencies og yield-dependencies

Lær at oprette mere komplekse dependencies ved hjælp af klasser og administrere ressourcer med `yield` til opsætnings- og nedlukningslogik.

Lektion 3 af 411 trin

Klassebaserede dependencies og yield-dependencies er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 3 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.

Ud over simple funktionsafhængigheder

I tidligere lektioner lærte du om grundlæggende funktionsbaserede afhængigheder i FastAPI. De er velegnede til simple opgaver som validering eller indsættelse af almindelige værdier.

Men hvad nu, hvis din afhængighed skal bevare tilstand, acceptere konfiguration eller håndtere ressourcer, der kræver både opsætning og oprydning? Så er klassebaserede afhængigheder og yield-afhængigheder nyttige!

Hvorfor bruge klassebaserede afhængigheder?

Klassebaserede afhængigheder har flere fordele i mere komplekse scenarier:

Organisering: Indkapsl relateret logik og data i en klasse.
Tilstand: Klasser kan indeholde intern tilstand, hvilket kan være nyttigt, men vær opmærksom på isolation mellem anmodninger.
Konfiguration: Send nemt parametre til afhængigheden, når den instantieres.
Testbarhed: Det er nemmere at simulere eller indsætte bestemte klasseinstanser til test.

Definition af en klasseafhængighed

For at oprette en klassebaseret afhængighed definerer du en Python-klasse. FastAPI kan derefter bruge en instans af denne klasse. Hvis din klasse har en __call__-metode, kalder FastAPI den for at hente afhængighedens værdi.

Lad os se på et enkelt eksempel:

class MyService:
    def __init__(self):
        self.message = "Welcome from MyService!"

    def __call__(self):
        # This method is called by FastAPI to get the value
        return self.message

# Simulate FastAPI's usage:
# FastAPI would instantiate MyService() once or per request
service_instance = MyService()

# It then calls the __call__ method to get the value
dependency_value = service_instance()
print(dependency_value)

Sådan håndterer FastAPI klasseafhængigheder

Når du bruger Depends(MyClass), gør FastAPI følgende:

Opretter en instans af MyClass.
Hvis MyClass har en __call__-metode, kalder FastAPI den og bruger den returnerede værdi som afhængigheden.
Ellers bruger FastAPI selve instansen af MyClass som afhængigheden.

Hvis du bruger Depends(MyClass()), sender du et objekt, der allerede er instantieret, og FastAPI bruger ganske enkelt dette objekt samt dets __call__-metode, hvis den findes.

Klasseafhængigheder med parametre

En væsentlig fordel ved klassebaserede afhængigheder er muligheden for at sende parametre til deres konstruktør. Det er ideelt til at indsætte konfiguration eller andre afhængigheder i din serviceklasse.

Forestil dig en tjeneste, der har brug for en API-nøgle:

class ExternalApiService:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.external.com"

    def __call__(self):
        return f"API Service configured with key: {self.api_key}"

# In a real FastAPI app, the api_key might come from
# an environment variable or another dependency.
# Here, we simulate instantiation with different keys.

prod_api = ExternalApiService(api_key="prod_secret_123")
dev_api = ExternalApiService(api_key="dev_test_abc")

print(prod_api())
print(dev_api())

Introduktion til yield-afhængigheder

Nogle ressourcer, f.eks. databaseforbindelser eller filhåndteringer, skal ikke kun sættes op, men også ryddes korrekt op bagefter. Det er her, yield-afhængigheder er særligt nyttige!

En yield-afhængighed er en generatorfunktion, der giver dig mulighed for at køre kode før slutpunktet udføres, altså under opsætningen, og efter at svaret er sendt, altså under oprydningen.

Yield til opsætning af ressourcer

Koden før yield-sætningen i din afhængighedsfunktion udføres som opsætningslogik. Den værdi, der afgives med yield, modtager din slutpunktfunktion som en afhængighed.

def get_database_session():
    print("DB: Establishing connection...") # Setup logic
    db_session = {"id": 1, "status": "active"} # Simulate a session
    yield db_session # This value is passed to the dependent function
    # Teardown logic (after yield) would go here

# Simulate a function that uses the dependency
def process_data(session):
    print(f"Endpoint: Processing data with session ID: {session['id']}")

# How FastAPI conceptually uses it:
# 1. Calls get_database_session()
# 2. Takes the yielded value
# 3. Passes it to process_data()

session_generator = get_database_session()
active_session = next(session_generator) # Runs setup, gets yielded value
process_data(active_session)
# FastAPI would then ensure the generator is closed, triggering teardown.

Yield til oprydning af ressourcer

Styrken ved yield-afhængigheder ligger i deres evne til at udføre oprydning. Al kode, der placeres efter yield-sætningen, udføres, når anmodningen er afsluttet, og svaret er sendt.

Det gøres typisk i en try...finally-blok for at garantere oprydning, selv hvis der opstår fejl.

def get_file_handle():
    print("File: Opening 'log.txt'...")
    file_handle = open("log.txt", "w") # Simulate opening a file
    try:
        yield file_handle # Provide the file handle
    finally:
        print("File: Closing 'log.txt'.")
        file_handle.close() # Teardown logic: close the file

# Simulate a function using the dependency
def write_log(f_handle):
    f_handle.write("Lesson content generated.\n")
    print("Endpoint: Wrote to log file.")

# Manual simulation of FastAPI's lifecycle:
file_generator = get_file_handle()
current_file = next(file_generator) # Setup runs
write_log(current_file)

# This step would be handled by FastAPI to trigger teardown
try:
    next(file_generator) # Continues generator, runs finally block
except StopIteration:
    print("Generator exhausted, teardown complete.")

Kombination af klassebaserede afhængigheder og yield-afhængigheder

Du kan bruge både klassebaserede afhængigheder og yield-afhængigheder sammen! En klassebaseret afhængighed kan f.eks. levere konfiguration til en database, hvorefter en yield-afhængighed bruger konfigurationen til at oprette og lukke en databaseforbindelse.

Det giver en meget modulær og robust håndtering af ressourcer i din FastAPI-applikation.

Hurtigt tjek

Overvej fordelene ved og anvendelsesområderne for avancerede mønstre til afhængighedsindsprøjtning.

Besvar den i den interaktive lektion

Opsummering af lektionen

Godt gået! I denne lektion har du opnået en bedre forståelse af FastAPI-afhængigheder.

Klassebaserede afhængigheder hjælper med at organisere kompleks logik, bevare tilstand og acceptere konfiguration.
yield-afhængigheder, altså generatorfunktioner, er effektive til at håndtere ressourcer, der kræver både opsætning, før yield, og garanteret oprydning efter yield, ofte i en finally-blok.

Disse mønstre gør dine FastAPI-applikationer mere robuste, nemmere at vedligeholde og lettere at teste.

Gratis at komme i gang

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Klassebaserede dependencies og yield-dependencies” gratis?

Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Klassebaserede dependencies og yield-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 “Klassebaserede dependencies og yield-dependencies”?

Lær at oprette mere komplekse dependencies ved hjælp af klasser og administrere ressourcer med `yield` til opsætnings- og nedlukningslogik. 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 3 af 4.

Hvor lang tid tager lektionen “Klassebaserede dependencies og yield-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

← Tilbage til Bootcamp i FastAPI-backendudvikling