0Pricing
FastAPI Backend Development Bootcamp · Lección

Dependencias basadas en clases y con yield

Aprenda a crear dependencias más complejas mediante clases y a gestionar recursos con `yield` para la lógica de configuración y liberación.

Dependencias basadas en clases y con yield es una lección gratuita de FastAPI Backend Development Bootcamp en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de FastAPI Backend Development Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en 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.

Preguntas frecuentes

¿La lección «Dependencias basadas en clases y con yield» es gratis?

Sí — el texto completo de «Dependencias basadas en clases y con yield» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de FastAPI Backend Development Bootcamp, actualiza a CoddyKit PRO. El curso de FastAPI Backend Development Bootcamp incluye 4 lecciones en total.

¿Qué aprenderé en «Dependencias basadas en clases y con yield»?

Aprenda a crear dependencias más complejas mediante clases y a gestionar recursos con `yield` para la lógica de configuración y liberación. Practicas FastAPI Backend Development Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar FastAPI Backend Development Bootcamp?

No se requiere experiencia previa. FastAPI Backend Development Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Dependencias basadas en clases y con yield»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de FastAPI Backend Development Bootcamp?

Sí. Cada lección de FastAPI Backend Development Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Comprender las dependencias en FastAPI
  2. Inyección de dependencias comunes
  3. Dependencias basadas en clases y con yield
  4. Dependencias globales y subdependencias
← Volver a FastAPI Backend Development Bootcamp