Diferentes módulos de Spring (Core, Data, MVC, AOP, Security y demás)

Cuando hablamos de Spring no nos referimos a un único framework, sino a todo un ecosistema. Cada módulo resuelve una tarea concreta, lo que hace a Spring modular y muy flexible. ¿Quieres trabajar con una base de datos? Usa Spring Data. ¿Necesitas construir un REST API seguro? Para eso están Spring Security y Spring MVC.

Aquí tienes algunas razones por las que el enfoque modular mola:

• Flexibilidad: usas solo las partes de Spring que necesitas. ¿Para qué arrastrar todo si el proyecto solo necesita Spring Core?
• Código limpio: los módulos ayudan a aislar funcionalidad. Esto es especialmente importante en proyectos grandes.
• Escalabilidad: los módulos permiten añadir nuevas capacidades sin cambiar el código ya existente.

Vamos a repasar los módulos clave de Spring Framework.

1. Spring Core

Spring Core es el núcleo del framework. Aquí vive nuestro viejo amigo IoC-container, y es el que gestiona todos los Spring Beans. Si imaginamos a Spring como un superhéroe, su superpoder es IoC, y Core es el corazón.

Capacidades clave de Spring Core:

Ejemplo: creación de un Spring Bean

• Gestión de dependencias mediante DI.
• Configuración de beans con anotaciones (@Component, @Autowired, @Qualifier) y basada en Java (@Configuration, @Bean).
• Facilidad para testear y reutilizar componentes.

@Component
public class HelloService {
    public String sayHello() {
        return "¡Hola, Spring!";
    }
}

@RestController
public class HelloController {
    private final HelloService helloService;

    @Autowired
    public HelloController(HelloService helloService) {
        this.helloService = helloService;
    }

    @GetMapping("/hello")
    public String hello() {
        return helloService.sayHello();
    }
}

Aquí HelloService es gestionado automáticamente por el IoC-container, y su instancia se inyecta en el controlador. ¿Magia? No, simplemente Spring Core.

2. Spring Data

Spring Data hace que trabajar con bases de datos sea lo más sencillo y cómodo posible. Llegan al rescate JPA, anotaciones y repositorios. Eso significa que no tienes que escribir montones de SQL. Sí, ahora se puede vivir sin tanto dolor.

Capacidades clave de Spring Data:

• ORM potente (a través de Hibernate y JPA).
• Generación automática de operaciones CRUD mediante JpaRepository.
• Modelos de datos con anotaciones como @Entity, @Id, @GeneratedValue.

Ejemplo de código: entidad simple y repositorio

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters y setters
}

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}

Ahora puedes simplemente llamar a findByName("John") para obtener todos los usuarios con el nombre "John". ¡Se disparan las hormonas de la alegría!

3. Spring MVC

Spring MVC sigue la arquitectura Model-View-Controller y nos ayuda a construir aplicaciones web. Es el módulo que se encarga de manejar las peticiones HTTP, el routing y la generación de páginas HTML.

Componentes principales de Spring MVC:

• Controladores: manejan las peticiones con anotaciones, por ejemplo @Controller, @RequestMapping.
• Modelos: los datos que pasamos a la vista.
• Vistas: plantillas HTML generadas con, por ejemplo, Thymeleaf.

Ejemplo: crear un controlador simple

@Controller
public class HomeController {
    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "¡Bienvenido a Spring MVC!");
        return "home"; // Devolverá la plantilla home.html (vía Thymeleaf)
    }
}

4. Spring AOP (Aspect-Oriented Programming)

AOP es una forma de inyectar funcionalidad adicional sin tocar el código principal. Por ejemplo, puedes añadir logging, manejo de errores o control de transacciones en un solo sitio.

Conceptos clave:

• Aspecto (Aspect): funcionalidad adicional que quieres añadir (por ejemplo, logging).
• Pointcut (Pointcut): el punto en el código donde se aplicarán los aspectos.
• Advice (Advice): la propia lógica del aspecto.

Ejemplo de código: logging con AOP

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethodExecution() {
        System.out.println("El método se está llamando...");
    }
}

Cuando se llame a un método en com.example.service, verás el mensaje El método se está llamando.... Es como un espía que apunta todo lo que haces.

5. Spring Security

Spring Security se encarga de la seguridad de las aplicaciones web. Incluye autenticación de usuarios, verificación de permisos y mucho más.

Capacidades clave:

• Configuración de roles y permisos mediante anotaciones.
• Integración con la base de datos para almacenar usuarios.
• Soporte para mecanismos modernos de seguridad como JWT y OAuth2.

Ejemplo: proteger un endpoint

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .formLogin();
    }
}

Ahora solo los usuarios con el rol ADMIN podrán acceder a las rutas /admin/**.

6. ¿Cuándo y qué módulo usar?

Aun después de este vistazo rápido a los módulos principales de Spring, has visto qué potente, flexible y cómodo es este framework. Pero recuerda, con gran poder no siempre viene fácil: "Un gran poder conlleva una gran responsabilidad". Nuestra misión es aprender a usar los módulos de Spring sin crear un proyecto sobrecargado y saturado.