Las anotaciones @Configuration y @Bean para la configuración basada en Java

Hoy nos vamos a centrar en la configuración de aplicaciones Spring. Más concretamente, en cómo la configuración basada en Java con las anotaciones @Configuration y @Bean puede sustituir a los archivos XML y hacerte la vida más fácil. ¡Abrochaos el cinturón, que va a ser interesante!

En los "buenos viejos" tiempos, los desarrolladores de Spring usaban archivos XML para la configuración. Era... bueno, siendo sinceros, no era lo más cómodo. Esos XML larguísimos, llenos de etiquetas <bean> y demás "cosas robóticas", más bien daban dolor de cabeza que ayuda.

La configuración basada en Java es como pasar de cartas en botella directamente al email. Te permite:

• Deshacerte del XML: no tienes que saltar entre el código Java y archivos XML; toda la configuración está donde tu código.
• Tener configuración tipada: te beneficias de la compilación y los errores se ven antes de ejecutar.
• Mejorar la comodidad y la legibilidad: tus compañeros ya no te mirarán raro cuando vean otro XML en el proyecto.

Anotación @Configuration

La anotación @Configuration indica a Spring que esa clase es una clase de configuración. Es como decir: "Oye Spring, aquí tienes las instrucciones de cómo configurar nuestros beans, ¡están aquí!"

Ejemplo de uso

import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    // Aquí estará nuestra magia de configuración de beans
}

Bastante sencillo, ¿no? ¿Qué sigue? Pasamos a la anotación @Bean, donde empieza la verdadera magia.

Anotación @Bean

La anotación @Bean se usa para definir explícitamente un bean en el contexto de Spring. Básicamente, es un método que devuelve un objeto (tu bean), y Spring se encarga de gestionar su ciclo de vida.

Ejemplo mínimo con @Bean

Vamos a crear un bean simple que represente nuestro servicio principal:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

class MyService {
    public void doSomething() {
        System.out.println("¡Trabajando con MyService!");
    }
}

Ahora, cuando Spring levante el contexto (por ejemplo, mediante ApplicationContext), creará automáticamente una instancia de MyService y la gestionará.

Uso de beans en la aplicación

Ok, el bean está creado. ¿Cómo lo usas? ¡Fácil! En Spring está disponible para DI, por ejemplo:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyController {

    private final MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService;
    }

    public void process() {
        myService.doSomething();
    }
}

El bean MyService se inyecta automáticamente en el controlador gracias a la magia de Spring. Genial, ¿no?

Diferencias entre @Component y @Bean

La diferencia clave está en dónde y cómo defines tu bean:

• @Component: úsalo si quieres que Spring encuentre tu clase automáticamente y la registre como bean. Va bien para escenarios estándar con poco nivel de personalización.

• @Bean: úsalo si quieres definir explícitamente cómo se crea y configura el bean. Es la elección ideal si el bean requiere lógica compleja al crearse o depende de librerías externas.

Ejemplo para @Bean

Imagina que necesitas crear un bean para configurar un cliente HTTP de terceros:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import okhttp3.OkHttpClient;

@Configuration
public class HttpClientConfig {

    @Bean
    public OkHttpClient httpClient() {
        return new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();
    }
}

Esto no es algo que se pueda escanear automáticamente con @Component, por eso usar @Bean aquí tiene más sentido.

Enlazando beans: cuando un bean depende de otro

Los beans pueden depender unos de otros, y puedes configurarlo fácilmente con configuración basada en Java. Imagina que tenemos un UserService que depende de UserRepository. Así quedaría:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

class UserRepository {
    // Tu código del repositorio
}

class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void processUsers() {
        System.out.println("¡Trabajando con usuarios!");
    }
}

Spring sustituirá automáticamente la instancia de UserRepository en el método userService, gracias a IoC y DI. Muy cómodo.

6. Ventajas de la configuración basada en Java frente a XML

7. ¿Cuándo usar @Bean?

Usa @Bean cuando:

• Necesitas crear objetos que no son tus propias clases (por ejemplo, librerías de terceros).
• Quieres configurar el bean usando parámetros complejos.
• Necesitas controlar explícitamente la creación del bean.

Errores típicos con @Configuration y @Bean

Cualquiera puede equivocarse (incluso el desarrollador más experimentado). Aquí tienes algunos fallos comunes al trabajar con configuración basada en Java:

• Olvidar la anotación @Configuration: si olvidas marcar la clase como de configuración, Spring no conocerá tus beans.
• Falta de coincidencia de tipos: asegúrate de que el tipo devuelto por el método marcado con @Bean coincide con lo que esperas inyectar.
• Dependencias cíclicas: si el bean A depende del bean B y el bean B depende del bean A, eso provocará un error. Piensa la arquitectura de tus beans con antelación.

Estos errores se pueden evitar fácilmente. Solo necesitas práctica y atención al detalle.

Ahora sabes cómo usar las anotaciones @Configuration y @Bean para configurar tus aplicaciones en Spring. Deja de escribir XML y disfruta de las ventajas de Java. A continuación nos meteremos en los aspectos prácticos de crear clases de configuración y beans.