Antes de ponernos a escribir código, veamos para qué sirve la configuración. Una aplicación Spring es como un circuito eléctrico, donde cada componente (o bean) cumple su función, y la configuración determina cómo conectar esos componentes para que todo funcione. La configuración describe cómo interactúan esos componentes entre sí y cómo ajustar correctamente la aplicación a las necesidades del proyecto.
En Spring hay tres formas principales de configuración:
- Configuración XML — la forma "a la antigua" (old-school). Va bien para quienes disfrutan escribiendo montones de archivos XML.
- Anotaciones — un enfoque moderno y más cómodo, que reduce el papeleo.
- Código Java (configuración basada en Java) — una forma potente de personalizar, que ofrece flexibilidad en el manejo.
¿Cuándo usar cada uno?
- XML es útil para proyectos donde la separación entre configuración y código es algo importante.
- Las anotaciones son buenas cuando quieres configurar un componente rápido sin sobrecargar con archivos.
- El código Java es ideal para aplicaciones complejas que requieren configuración dinámica.
Configuración con XML
La configuración XML es la forma más antigua, pero fiable. Antes, todas las configuraciones de las aplicaciones Spring se guardaban en archivos .xml. Al principio puede parecer excesivamente complicada, pero para entender los fundamentos del contenedor de Spring es útil.
Ejemplo: Configurar un bean en XML
Objetivo: registrar un bean que represente un servicio simple.
Definamos la clase del servicio:
package com.example.service;
public class GreetingService {
public void sayHello() {
System.out.println("Hello from GreetingService!");
}
}
Creemos la configuración XML (applicationContext.xml):
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Definimos el bean GreetingService -->
<bean id="greetingService" class="com.example.service.GreetingService" />
</beans>
Usamos el bean en el código:
package com.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.example.service.GreetingService;
public class App {
public static void main(String[] args) {
// Cargamos el contexto desde XML
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// Obtenemos el bean del contexto
GreetingService greetingService = context.getBean("greetingService", GreetingService.class);
// Llamamos al método del bean
greetingService.sayHello();
}
}
Este enfoque muestra cómo funciona el contenedor IoC de Spring: crea el objeto GreetingService y gestiona su ciclo de vida.
Configuración con anotaciones
¿A quién no le gusta la magia? Con Spring, las anotaciones nos facilitan mucho la vida. Las anotaciones permiten marcar clases y sus miembros para la configuración automática.
Principales anotaciones
@Component— indica la clase que debe registrarse como bean.@Autowired— inyecta dependencias en el bean.@ComponentScan— indica dónde buscar componentes (beans).
Ejemplo: uso de anotaciones para la configuración
Modificamos la clase del servicio:
package com.example.service;
import org.springframework.stereotype.Component;
@Component // Registro automático de la clase como bean
public class GreetingService {
public void sayHello() {
System.out.println("Hello from GreetingService with annotations!");
}
}
Configuremos la clase principal de la aplicación:
package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.example.service.GreetingService;
@Configuration
@ComponentScan(basePackages = "com.example") // Escanea el paquete y busca componentes
public class AppConfig {
@Autowired
private GreetingService greetingService;
public void run() {
greetingService.sayHello();
}
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Obtenemos el bean AppConfig
AppConfig app = context.getBean(AppConfig.class);
app.run();
context.close();
}
}
El resultado es el mismo que con XML, pero nos libramos de archivos extra. ¡Pura magia!
Configuración con Java (anotación @Configuration)
El código Java es una herramienta potente en manos de un desarrollador experimentado. Aquí creamos clases de configuración y configuramos beans manualmente mediante métodos.
Ejemplo de uso de @Configuration y @Bean
Queremos registrar un bean pero no queremos escanear todo el proyecto.
La clase del servicio permanece igual:
package com.example.service;
public class GreetingService {
public void sayHello() {
System.out.println("Hello from GreetingService with Java-based config!");
}
}
Creemos la configuración Java:
package com.example.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.example.service.GreetingService;
@Configuration
public class AppConfig {
@Bean
public GreetingService greetingService() {
return new GreetingService(); // Creación manual del bean
}
}
package com.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.example.service.GreetingService;
import com.example.config.AppConfig;
public class App {
public static void main(String[] args) {
// Inicializamos el contexto con la configuración Java
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// Obtenemos el bean
GreetingService greetingService = context.getBean(GreetingService.class);
// Usamos el bean
greetingService.sayHello();
}
}
Flexibilidad de la configuración Java
Se puede añadir lógica compleja al crear un bean. Por ejemplo, un bean puede depender de configuraciones o ajustes externos:
@Bean
public GreetingService greetingService() {
if (System.getProperty("user.language").equals("ru")) {
return new RussianGreetingService();
}
return new EnglishGreetingService();
}
Ahora vemos que la configuración Java está más orientada a proyectos grandes, donde se necesita flexibilidad.
Comparación de enfoques: XML, Anotaciones, Java
| Enfoque | Ventajas | Desventajas |
|---|---|---|
| XML | Adecuado para configuraciones que deben estar separadas del código | Mucha rutina. Hay que escribir XML incluso para cosas simples |
| Anotaciones | Simplicidad, menos código para tareas básicas | Toda la configuración está "oculta" en el código, lo que complica el mantenimiento |
| Java | Mejor opción para aplicaciones complejas, adaptabilidad | PUEde volverse complejo cuando hay muchos beans |
¿Qué método elegir? Si eres principiante o escribes una aplicación pequeña, las anotaciones son la opción ideal. Para sistemas complejos es mejor usar la configuración Java, ya que es más flexible y cómoda para la personalización.
GO TO FULL VERSION