Como a injeção de dependência (Depends) funciona?

Question

IT Interview Practice · Accepted Answer

O sistema de **injeção de dependência** do FastAPI permite que você declare dependências reutilizáveis (funções/classes) que o FastAPI chama e **injeta** em suas operações de caminho via `Depends()`. É usado para lógica compartilhada como sessões de banco de dados, autenticação e parâmetros comuns — mantendo o código DRY e testável.

## Uma dependência básica

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

Declarar `params = Depends(pagination)` diz ao FastAPI para chamar `pagination` (resolvendo *seus* parâmetros da solicitação também) e passar o resultado para sua função. A dependência é reutilizável em muitos endpoints.

## Dependências com limpeza (yield) — por exemplo, sessões de banco de dados

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

Uma dependência com `yield` fornece um recurso e executa limpeza após a solicitação — o padrão padrão para sessões de banco de dados (abrir antes, fechar depois, automaticamente).

## Dependências podem depender de dependências

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

As dependências formam uma árvore — FastAPI resolve toda a cadeia. É assim que autenticação é normalmente feita (uma dependência `get_current_user`).

## Dependências de classe e reutilização

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Por que isso importa

A injeção de dependência é um dos recursos mais poderosos e importantes do FastAPI — é como você compartilha e reutiliza lógica de forma limpa em endpoints (sessões de banco de dados, autenticação, parâmetros de query comuns, verificações de permissão) sem duplicação.

Compreender isso é essencial porque sustenta padrões principais: a **dependência com `yield`** é a forma padrão de gerenciar sessões de banco de dados (com limpeza garantida após cada solicitação), e uma **dependência `get_current_user`** é a forma idiomática de implementar autenticação.

DI também torna o código altamente **testável** — você pode sobrescrever dependências com mocks em testes.

A elegância do sistema (dependências resolvem seus próprios parâmetros da solicitação, podem depender de outras dependências formando uma árvore, e se integram com a documentação) a torna uma ferramenta versátil para estruturar aplicações reais, então dominar `Depends` é fundamental para construir aplicações FastAPI bem organizadas, mantíveis e testáveis.

Uma dependência básica

Dependências com limpeza (yield) — por exemplo, sessões de banco de dados

Dependências podem depender de dependências

Dependências de classe e reutilização

Por que isso importa

Perguntas relacionadas