0Pricing
FastAPI Backend Development Bootcamp · Aula

Dependências baseadas em classes e com yield

Aprenda a criar dependências mais complexas usando classes e a gerenciar recursos com `yield` para a lógica de configuração e desmontagem.

Dependências baseadas em classes e com yield é uma aula grátis de FastAPI Backend Development Bootcamp no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de FastAPI Backend Development Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Beyond Simple Function Dependencies

In previous lessons, we learned about basic function-based dependencies in FastAPI. These are great for simple tasks like validation or injecting common values.

But what if your dependency needs to maintain state, accept configuration, or manage resources that require both setup and cleanup? That's where class-based and yield dependencies come in!

Why Use Class-Based Dependencies?

Class-based dependencies offer several advantages for more complex scenarios:

  • Organization: Encapsulate related logic and data within a class.
  • State: Classes can hold internal state, which can be useful (though be mindful of request isolation).
  • Configuration: Easily pass parameters to the dependency during its instantiation.
  • Testability: Easier to mock or inject specific class instances for testing.

Defining a Class Dependency

To create a class-based dependency, you define a Python class. FastAPI can then use an instance of this class. If your class has a __call__ method, FastAPI will invoke it to get the dependency's value.

Let's see a simple example:

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)

How FastAPI Handles Class Dependencies

When you use Depends(MyClass), FastAPI will:

  • Create an instance of MyClass.
  • If MyClass has a __call__ method, it will call it and use the returned value as the dependency.
  • Otherwise, it will use the instance of MyClass itself as the dependency.

If you use Depends(MyClass()), you're passing an already instantiated object, and FastAPI will simply use that object (and its __call__ method if present).

Class Dependencies with Parameters

A major benefit of class-based dependencies is the ability to pass parameters to their constructor. This is perfect for injecting configuration or other dependencies into your service class.

Imagine a service that needs an API key:

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())

Introducing Yield Dependencies

Some resources, like database connections or file handlers, need not only to be set up but also properly cleaned up afterwards. This is where yield dependencies shine!

A yield dependency is a generator function that allows you to run code before the endpoint is executed (setup) and after the response is sent (teardown).

Yield for Resource Setup

The code before the yield statement in your dependency function is executed as setup logic. The value that is yielded is what your endpoint function will receive as a dependency.

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 for Resource Teardown

The power of yield dependencies is in their ability to perform cleanup. Any code placed after the yield statement will execute once the request has finished and the response has been sent.

This is typically done within a try...finally block to guarantee cleanup, even if errors occur.

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.")

Combining Class-based & Yield Dependencies

You can use both class-based and yield dependencies together! For instance, a class-based dependency might provide configuration for a database, and a yield dependency would then use that configuration to establish and close a database connection.

This allows for highly modular and robust resource management within your FastAPI application.

Quick Check

Consider the benefits and use cases for advanced dependency injection patterns.

Lesson Summary

Great job! In this lesson, you've leveled up your understanding of FastAPI dependencies.

  • Class-based dependencies help organize complex logic, maintain state, and accept configuration.
  • Yield dependencies (generator functions) are powerful for managing resources that require both setup (before yield) and guaranteed teardown (after yield, often in a finally block).

These patterns make your FastAPI applications more robust, maintainable, and easier to test.

Perguntas Frequentes

A aula “Dependências baseadas em classes e com yield” é grátis?

Sim — o texto completo de “Dependências baseadas em classes e com yield” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de FastAPI Backend Development Bootcamp, atualize para CoddyKit PRO. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.

O que vou aprender em “Dependências baseadas em classes e com yield”?

Aprenda a criar dependências mais complexas usando classes e a gerenciar recursos com `yield` para a lógica de configuração e desmontagem. Você pratica FastAPI Backend Development Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar FastAPI Backend Development Bootcamp?

Nenhuma experiência prévia é necessária. FastAPI Backend Development Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Dependências baseadas em classes e com yield”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de FastAPI Backend Development Bootcamp?

Sim. Cada aula de FastAPI Backend Development Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Compreendendo as dependências no FastAPI
  2. Injetando dependências comuns
  3. Dependências baseadas em classes e com yield
  4. Dependências globais e subdependências
← Voltar para FastAPI Backend Development Bootcamp