FastAPI Backend Development Bootcamp · Lektion

Globale Dependencies und Sub-Dependencies

Globale Dependencies und Sub-Dependencies ist eine kostenlose FastAPI Backend Development Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des FastAPI Backend Development Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der FastAPI Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Scaling Up Dependencies

You can attach a dependency to a single route, but real apps need to apply checks broadly. FastAPI supports dependencies at the app, router, and route levels, plus dependencies that depend on other dependencies.

App-Level Dependencies

Pass dependencies=[...] to the FastAPI constructor to run them for every request. Useful for global logging or API-key checks.

from fastapi import FastAPI, Depends

async def verify_key():
    ...

app = FastAPI(dependencies=[Depends(verify_key)])

Router-Level Dependencies

Attach dependencies to an APIRouter so they apply to every route in that router but not the whole app.

from fastapi import APIRouter, Depends

admin = APIRouter(
    prefix='/admin',
    dependencies=[Depends(verify_admin)],
)

Dependencies Without a Return

When you only need a side effect (like raising on failure), put the dependency in the dependencies list rather than a parameter. Its return value is ignored.

@app.get('/secure', dependencies=[Depends(verify_key)])
async def secure():
    return {'ok': True}

Sub-Dependencies

A dependency can itself depend on another dependency. FastAPI resolves the whole chain automatically.

def get_token(authorization: str = Header(None)):
    return authorization

def get_user(token: str = Depends(get_token)):
    return lookup_user(token)

@app.get('/me')
async def me(user = Depends(get_user)):
    return user

Why Layer Dependencies

Sub-dependencies let you compose small, single-purpose pieces: parse the token, then resolve the user, then check permissions. Each layer is reusable and independently testable.

Dependency Caching

Within a single request, FastAPI caches each dependency by default. If two dependencies both need get_user, it runs only once. Disable with Depends(fn, use_cache=False).

@app.get('/data')
async def data(
    a = Depends(get_user),
    b = Depends(get_user),  # reuses cached result
):
    return a is b

Modeling the Resolution Chain

The resolver walks dependencies depth-first and caches by function. Here is a simplified version in plain Python.

cache = {}
calls = []
def resolve(name):
    if name in cache:
        return cache[name]
    calls.append(name)
    cache[name] = name + '_value'
    return cache[name]
resolve('get_user'); resolve('get_user'); resolve('get_token')
print(calls)

Combining Levels

Precedence flows from broad to narrow: app dependencies run first, then router, then route. A request to a router route runs all three layers in order.

Overriding for Tests

Swap any dependency in tests with app.dependency_overrides to inject fakes without touching production code.

app.dependency_overrides[get_user] = lambda: {'id': 1, 'name': 'Test'}

Best Practices

Keep dependencies focused:

One responsibility per dependency.
Use app/router level for cross-cutting concerns.
Rely on caching; only disable it when you truly need fresh evaluation.

Quick Check

Two parameters in the same route both use Depends(get_user) with default settings. How many times does get_user run for one request?

Recap

You leveled up dependency injection:

Applied dependencies at app, router, and route scope.
Used side-effect-only dependencies in the dependencies list.
Chained sub-dependencies and relied on per-request caching.
Overrode dependencies for testing.

Häufig gestellte Fragen

Ist die Lektion „Globale Dependencies und Sub-Dependencies“ kostenlos?

Ja — der vollständige Text von „Globale Dependencies und Sub-Dependencies“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des FastAPI Backend Development Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der FastAPI Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Globale Dependencies und Sub-Dependencies“?

Wenden Sie Dependencies auf eine gesamte App oder einen Router an, verketten Sie Sub-Dependencies und cachen Sie Dependency-Ergebnisse innerhalb eines Requests, um saubere, geschichtete FastAPI-Anwen… Du übst FastAPI Backend Development Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um FastAPI Backend Development Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. FastAPI Backend Development Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Globale Dependencies und Sub-Dependencies“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser FastAPI Backend Development Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede FastAPI Backend Development Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Abhängigkeiten in FastAPI verstehen
Gemeinsame Abhängigkeiten injizieren
Klassenbasierte Abhängigkeiten und Yield-Abhängigkeiten
Globale Dependencies und Sub-Dependencies

← Zurück zu FastAPI Backend Development Bootcamp