Anotaciones de definición de componentes en Spring

En el framework Spring, los Beans son objetos gestionados por el contenedor que implementan funcionalidades específicas. A través de anotaciones, las clases Java pueden marcarse como Beans administrados, simplificando su configuración.

@Component: Definición general de Beans

La anotación @Component marca una clase Java como un Bean administrado por Spring. El contenedor escanea y registra automáticamente esta clase, eliminando la necesidad de configuración XML manual.

@Component
public class ComponenteDemo {
    public void realizarOperacion() {
        System.out.println("Operación en ejecución...");
    }
}

En este ejemplo, ComponenteDemo se convierte en un Bean de Spring, instanciado y gestionado automáticamente por el contenedor.

@Service: Capa de lógica de negocio

La anotación @Service se aplica a clases en la capa de servicio, heredando de @Component y proporcionando semántica clara para la lógica de negocio.

@Service
public class ServicioEjemplo {
    public void ejecutarLogica() {
        System.out.println("Lógica de negocio en acción...");
    }
}

Esta anotación facilita la identificación de clases de servicio, mejorando la legibilidad y mantenibilidad del código.

@Controller: Manejo de solicitudes web

En aplicaciones Spring MVC, la anotación @Controller se usa para marcar clases que manejan solicitudes HTTP, sirviendo como punto de entrada para el controlador.

@Controller
public class ControladorWeb {
    @RequestMapping("/saludo")
    public String saludar() {
        return "¡Hola, Mundo!";
    }
}

Spring MVC escanea automáticamente esta clase y asigna métodos a solicitudes HTTP mediante anotaciones como @RequestMapping.

@Repository: Acceso a datos

La anotación @Repository marca clases en la capa de acceso a datos, como DAOs, y hereda de @Component. Mejora el manejo de excepciones relacionadas con la persistencia.

@Repository
public class RepositorioDemo {
    public void almacenar() {
        System.out.println("Almacenando datos...");
    }
}

Esta anotación ayuda a Spring a gestionar transacciones y errores en la capa de datos automáticamente.

Anotaciones de inyección de dependencias

La inyección de dependencias es un principio central en Spring, donde las dependencias se proporcionan externamente en lugar de crearse internamente. Las anotaciones facilitan este proceso.

@Autowired: Inyección automática

La anotación @Autowired inyecta dependencias automáticamente por tipo. Se puede aplicar a campos, constructores o métodos.

@Service
public class ServicioConDependencia {
    @Autowired
    private RepositorioDemo repositorio;

    public void ejecutar() {
        repositorio.almacenar();
    }
}

Aquí, RepositorioDemo se inyecta automáticamente en ServicioConDependencia.

@Resource: Inyección por nombre

La anotación @Resource permite inyectar dependencias por nombre, útil cuando hay múltiples Beans del mismo tipo.

@Service
public class ServicioConNombre {
    @Resource(name = "repositorioDemo")
    private RepositorioDemo repositorio;
}

Esto asegura que se inyecte el Bean específico con el nombre "repositorioDemo".

@Inject: Estándar Java para inyección

La anotación @Inject es parte de la especificación Java y funciona similar a @Autowired, promoviendo la portabilidad del código.

@Service
public class ServicioJavaEstandar {
    @Inject
    private RepositorioDemo repositorio;
}

Esta anotación es ideal para entornos que siguen estándares Java, como Java EE.

Anotaciones de configuración

Las clases de configuración en Spring permiten definir Beans y dependencias mediante código, reemplazando los archivos XML.

@Configuration: Clase de configuración

La anotación @Configuration marca una clase como fuente de definiciones de Beans, similar a un archivo XML.

@Configuration
public class ConfiguracionApp {
    @Bean
    public ServicioDemo servicio() {
        return new ServicioDemo();
    }
}

El método anotado con @Bean define un Bean de tipo ServicioDemo.

@Bean: Definición de Beans

La anotación @Bean se usa dentro de clases @Configuration para declarar Beans, permitiendo lógica de instanciación personalizada.

@Configuration
public class ConfiguracionDatos {
    @Bean
    public RepositorioDemo repositorio() {
        return new RepositorioDemo();
    }
}

Esto proporciona un control detallado sobre la creación de Beans.

Anotaciones de alcance

El alcance de un Bean determina su ciclo de vida y comportamiento de instanciación. Spring ofrece varios alcances mediante anotaciones.

@Scope: Definir el alcance

La anotación @Scope especifica el alcance de un Bean, como singleton (predeterminado), prototype, session o request.

@Component
@Scope("prototype")
public class ComponenteConAlcance {
    public void tareaIndependiente() {
        System.out.println("Tarea con instancia nueva cada vez.");
    }
}

En este caso, cada solicitud crea una nueva instancia de ComponenteConAlcance.

Anotaciones de ciclo de vida

Spring permite ejecutar código en fases específicas del ciclo de vida de un Bean mediante anotaciones.

@PostConstruct: Inicialización

La anotación @PostConstruct marca un método para ejecutarse después de la construcción y la inyección de dependencias.

@Component
public class ComponenteConInicializacion {
    @PostConstruct
    public void configurar() {
        System.out.println("Bean inicializado.");
    }
}

El método configurar se llama automáticamente tras la instanciación.

@PreDestroy: Destrucción

La anotación @PreDestroy marca un método para ejecutarse antes de que el Bean sea eliminado del contenedor.

@Component
public class ComponenteConDestruccion {
    @PreDestroy
    public void liberarRecursos() {
        System.out.println("Recursos liberados antes de destrucción.");
    }
}

Este método ayuda a limpiar recursos, como conexiones de base de datos.

Anotaciones condicionales

Las anotaciones condicionales permiten cargar Beans dinámicamente basado en condiciones específicas.

@Conditional: Carga condicional

La anotación @Conditional carga un Bean solo si se cumplen condiciones definidas en una clase de condición.

@Component
@Conditional(CondicionEspecifica.class)
public class ComponenteCondicional {
    public void funcionar() {
        System.out.println("Componente cargado bajo condiciones.");
    }
}

CondicionEspecifica implementa la interfaz Condition para evaluar la carga del Bean.

Anotaciones adicionales

Otras anotaciones útiles en Spring resuelven problemas comunes, como la inyección de propiedades y la selección de Beans.

@Qualifier: Especificar Beans

La anotación @Qualifier se usa con @Autowired para desambiguar Beans del mismo tipo, indicando un nombre específico.

@Autowired
@Qualifier("repositorioEspecial")
private RepositorioDemo repositorioCalificado;

Esto asegura la inyección del Bean con el nombre "repositorioEspecial".

@Value: Inyección de propiedades

La anotación @Value inyecta valores desde archivos de configuración, como application.properties.

@Component
public class ComponenteConPropiedades {
    @Value("${app.configuracion}")
    private String configuracion;
}

El valor de la propiedad "app.configuracion" se inyecta en el campo configuracion.

@Profile: Entornos específicos

La anotación @Profile asocia un Bean a un perfil de entorno, como desarrollo, pruebas o producción.

@Component
@Profile("desarrollo")
public class ComponenteDesarrollo {
    public void modoDesarrollo() {
        System.out.println("Configuración para entorno de desarrollo.");
    }
}

Este Bean solo se carga cuando el perfil activo es "desarrollo".