SpringBoot
Tutorial SpringBoot: Controladores Spring MVC
Spring Boot controladores MVC: uso. Domina el uso de controladores MVC en Spring Boot con ejemplos prácticos y detallados.
Aprende SpringBoot GRATIS y certifícateUso de la anotación @Controller y @RequestMapping
En Spring MVC, los controladores son componentes fundamentales que manejan las solicitudes HTTP y devuelven respuestas adecuadas. La anotación @Controller
se utiliza para indicar que una clase es un controlador de Spring MVC. Al marcar una clase con @Controller
, esta se registra como un bean en el contexto de la aplicación y permite que Spring detecte y gestione las solicitudes entrantes.
Por otro lado, la anotación @RequestMapping
se emplea para asignar rutas URL y métodos HTTP específicos a métodos dentro del controlador. Esta anotación puede aplicarse tanto a nivel de clase como de método. Cuando se aplica a nivel de clase, establece una ruta base para todas las solicitudes manejadas por ese controlador.
A continuación, se muestra un ejemplo básico de cómo usar estas anotaciones:
@Controller
@RequestMapping("/productos")
public class ProductoController {
@GetMapping("/lista")
public String mostrarListaProductos(Model modelo) {
List<Producto> productos = productoService.obtenerTodos();
modelo.addAttribute("productos", productos);
return "lista-productos";
}
@GetMapping("/detalle/{id}")
public String mostrarDetalleProducto(@PathVariable Long id, Model modelo) {
Producto producto = productoService.obtenerPorId(id);
modelo.addAttribute("producto", producto);
return "detalle-producto";
}
}
En este ejemplo, ProductoController
está anotado con @Controller
, indicando que es un componente controlador. La anotación @RequestMapping("/productos")
a nivel de clase establece que todas las rutas manejadas por este controlador comenzarán con /productos
.
El método mostrarListaProductos
está anotado con @GetMapping("/lista")
, que es una especialización de @RequestMapping
para solicitudes HTTP GET. Este método maneja las solicitudes a /productos/lista
, obtiene la lista de productos y la añade al modelo para ser utilizada en la vista lista-productos
.
El método mostrarDetalleProducto
utiliza @GetMapping("/detalle/{id}")
, donde {id}
es un parámetro de ruta que se inyecta en el método mediante la anotación @PathVariable
. Este método maneja solicitudes como /productos/detalle/1
, obtiene el producto correspondiente y lo añade al modelo para su visualización.
Es relevante mencionar que además de @GetMapping
, existen otras anotaciones especializadas como @PostMapping
, @PutMapping
, @DeleteMapping
y @PatchMapping
, que se utilizan para manejar otros métodos HTTP. Por ejemplo:
@PostMapping("/crear")
public String crearProducto(@ModelAttribute Producto producto) {
productoService.guardar(producto);
return "redirect:/productos/lista";
}
En este caso, el método crearProducto
maneja solicitudes HTTP POST a /productos/crear
. Utiliza @ModelAttribute
para vincular los datos del formulario al objeto Producto
y luego guarda el producto utilizando el servicio correspondiente. Finalmente, redirige a la lista de productos utilizando redirect:
.
La anotación @RequestMapping
y sus variantes permiten también especificar detalles más avanzados, como los tipos de contenido que el método acepta o produce. Por ejemplo, para manejar solicitudes que envían y reciben JSON:
@PostMapping(
value = "/actualizar",
consumes = "application/json",
produces = "application/json"
)
@ResponseBody
public Producto actualizarProducto(@RequestBody Producto producto) {
return productoService.actualizar(producto);
}
Aquí, el método actualizarProducto
maneja solicitudes HTTP POST a /productos/actualizar
, consume y produce JSON, y utiliza @RequestBody
para vincular el cuerpo de la solicitud al objeto Producto
. La anotación @ResponseBody
indica que el objeto devuelto debe escribirse directamente en la respuesta HTTP en formato JSON.
Además, es posible manejar diferentes métodos HTTP para la misma ruta utilizando @RequestMapping
con el atributo method
. Por ejemplo:
@RequestMapping(value = "/editar/{id}", method = RequestMethod.GET)
public String editarProductoForm(@PathVariable Long id, Model modelo) {
Producto producto = productoService.obtenerPorId(id);
modelo.addAttribute("producto", producto);
return "editar-producto";
}
@RequestMapping(value = "/editar/{id}", method = RequestMethod.POST)
public String editarProducto(@PathVariable Long id, @ModelAttribute Producto producto) {
producto.setId(id);
productoService.actualizar(producto);
return "redirect:/productos/detalle/" + id;
}
En este ejemplo, tanto el formulario para editar un producto como la acción de actualizarlo comparten la misma ruta /productos/editar/{id}
pero manejan diferentes métodos HTTP: GET para mostrar el formulario y POST para procesar la actualización.
Las anotaciones de mapeo en Spring también permiten trabajar con cabeceras, parámetros de solicitud y consumir o producir tipos de contenido específicos. Por ejemplo, para manejar solicitudes que solo acepten JSON y contengan una cabecera específica:
@PostMapping(
value = "/importar",
consumes = "application/json",
headers = "X-API-KEY"
)
public ResponseEntity<String> importarProductos(@RequestBody List<Producto> productos, @RequestHeader("X-API-KEY") String apiKey) {
if (esApiKeyValida(apiKey)) {
productoService.guardarTodos(productos);
return ResponseEntity.ok("Productos importados correctamente");
} else {
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("API Key no válida");
}
}
En este caso, el método importarProductos
maneja solicitudes POST a /productos/importar
que consumen JSON y deben incluir la cabecera X-API-KEY
. Utiliza @RequestBody
para recibir una lista de productos y @RequestHeader
para acceder al valor de la cabecera.
Para rutas más complejas, se pueden utilizar expresiones ant y variables en la ruta. Por ejemplo:
@GetMapping("/buscar")
public String buscarProductos(@RequestParam("q") String consulta, Model modelo) {
List<Producto> productos = productoService.buscarPorNombre(consulta);
modelo.addAttribute("productos", productos);
return "lista-productos";
}
Este método maneja solicitudes a /productos/buscar?q=nombre
, donde el parámetro de consulta q
se obtiene mediante @RequestParam
. De esta forma, se pueden manejar solicitudes con parámetros específicos sin modificar la ruta base.
Es posible también definir valores predeterminados y especificar si los parámetros son obligatorios o no:
@GetMapping("/filtrar")
public String filtrarProductos(
@RequestParam(value = "categoria", required = false) String categoria,
@RequestParam(value = "precioMin", required = false, defaultValue = "0") Double precioMin,
@RequestParam(value = "precioMax", required = false, defaultValue = "1000") Double precioMax,
Model modelo) {
List<Producto> productos = productoService.filtrar(categoria, precioMin, precioMax);
modelo.addAttribute("productos", productos);
return "lista-productos";
}
En este ejemplo, se manejan solicitudes a /productos/filtrar
con parámetros opcionales. Se utilizan valores predeterminados para precioMin
y precioMax
, y el parámetro categoria
no es obligatorio gracias a required = false
.
Respecto a las redirecciones y reenvíos, es importante entender cómo se manejan en el contexto de los controladores. Para redirigir a otra ruta, se puede utilizar redirect:
:
@PostMapping("/eliminar/{id}")
public String eliminarProducto(@PathVariable Long id) {
productoService.eliminar(id);
return "redirect:/productos/lista";
}
Aquí, una vez eliminado el producto, se redirige al usuario a la lista de productos. Si se desea reenviar la solicitud a otra vista sin cambiar la URL, se utiliza forward:
:
@GetMapping("/inicio")
public String inicio() {
return "forward:/productos/lista";
}
En este caso, la solicitud a /productos/inicio
se envía al método que maneja /productos/lista
, pero la URL en el navegador permanece igual.
Otra característica valiosa es el uso de nombres de rutas para evitar problemas al cambiar las rutas en el futuro. Se puede utilizar la anotación @RequestMapping
con un atributo name
:
@GetMapping(value = "/lista", name = "listaProductos")
public String mostrarListaProductos(Model modelo) {
// ...
}
Luego, se puede generar enlaces en las vistas utilizando el nombre de la ruta, lo que mejora el mantenimiento de la aplicación.
Explicación y uso de Model, ModelMap y ModelAndView
En el desarrollo de aplicaciones web con Spring MVC, es fundamental comprender cómo se transfiere información desde los controladores hasta las vistas. Para facilitar este proceso, Spring proporciona las interfaces y clases Model, ModelMap y ModelAndView, que permiten pasar datos a las vistas de forma sencilla y estructurada.
El Model es una interfaz que define un contenedor para los atributos que serán utilizados en la vista. Al añadir atributos al Model, estos se ponen a disposición de la vista para su renderización. Por ejemplo:
@GetMapping("/saludo")
public String mostrarSaludo(Model model) {
model.addAttribute("mensaje", "Bienvenido al sistema");
return "vista-saludo";
}
En este ejemplo, se añade el atributo mensaje al model
, el cual estará disponible en la vista identificada por vista-saludo. La interfaz Model permite utilizar métodos encadenados gracias a su implementación en clases como ModelMap o ExtendedModelMap.
La clase ModelMap es una implementación de la interfaz Map que proporciona capacidades adicionales para manejar los atributos del modelo. Aunque similar al Model, ModelMap ofrece más métodos para manipular los datos y es útil cuando se requiere una mayor flexibilidad. Un ejemplo de su uso es:
@GetMapping("/detalles")
public String mostrarDetalles(ModelMap modelMap) {
modelMap.addAttribute("usuario", obtenerUsuarioActual());
modelMap.addAttribute("fecha", LocalDate.now());
return "vista-detalles";
}
Aquí, modelMap
actúa como un mapa que almacena los atributos usuario y fecha, los cuales estarán disponibles en la vista vista-detalles.
Por otro lado, ModelAndView es una clase que encapsula tanto el modelo como la vista en un solo objeto. Esto es útil cuando se desea controlar explícitamente qué vista se va a renderizar y qué datos se van a pasar, todo en un mismo retorno. Un ejemplo típico es:
@GetMapping("/perfil")
public ModelAndView mostrarPerfil() {
ModelAndView mav = new ModelAndView("vista-perfil");
mav.addObject("perfil", cargarPerfil());
return mav;
}
En este caso, se crea un objeto ModelAndView
indicando la vista vista-perfil, y se añade el objeto perfil al modelo mediante el método addObject
. De esta forma, tanto la lógica de negocio como la definición de la vista se encapsulan en un único retorno.
Es relevante destacar que, aunque Model, ModelMap y ModelAndView cumplen funciones similares, la elección entre ellos depende del contexto y las preferencias de diseño. El uso de Model es habitual cuando se sigue el patrón de devolver el nombre de la vista como una cadena y se desea mantener el código más conciso. Por ejemplo:
@PostMapping("/guardar")
public String guardarDatos(Model model) {
boolean exito = servicio.guardar();
model.addAttribute("resultado", exito);
return "vista-resultado";
}
En situaciones donde se requiere manipular el modelo como un mapa, o se necesitan métodos específicos de Map, ModelMap es la opción adecuada. Por ejemplo, al añadir múltiples atributos y utilizar funcionalidades propias de un mapa:
@GetMapping("/estadisticas")
public String mostrarEstadisticas(ModelMap modelMap) {
modelMap.addAttribute("usuarios", obtenerUsuarios());
modelMap.putAll(calcularEstadisticas());
return "vista-estadisticas";
}
En este ejemplo, se añade una colección de atributos al modelo utilizando putAll
, aprovechando que ModelMap implementa la interfaz Map.
Cuando se requiere un mayor control sobre la respuesta, o se desea retornar directamente un objeto que represente tanto el modelo como la vista, ModelAndView es especialmente útil. Por ejemplo, en casos donde la vista a retornar depende de alguna condición:
@GetMapping("/acceso")
public ModelAndView verificarAcceso() {
return tienePermiso()
? new ModelAndView("vista-permitida").addObject("mensaje", "Acceso concedido")
: new ModelAndView("vista-denegada").addObject("error", "No tiene permisos");
}
Aquí, se retorna un ModelAndView
diferente según el resultado de la verificación, añadiendo los atributos correspondientes al modelo en cada caso.
Es importante mencionar que en Spring Boot 3, el uso de Model es ampliamente recomendado por su simplicidad y legibilidad. Sin embargo, ModelAndView sigue siendo útil en situaciones donde se necesita más control sobre la vista y el modelo en conjunto.
Además, al utilizar las características funcionales modernas de Java, es posible escribir código más conciso y expresivo. Por ejemplo, utilizando expresiones lambda y referencias a métodos:
@GetMapping("/productos")
public String listarProductos(Model model) {
var productos = productoService.obtenerProductos();
productos.forEach(p -> model.addAttribute("producto" + p.getId(), p));
return "vista-productos";
}
En este caso, se añade cada producto al modelo con una clave dinámica, aprovechando las capacidades funcionales de Java.
Qué es la vista y cómo se puede usar
En el marco de Spring MVC, la vista es el componente encargado de presentar los datos al usuario. Forma parte del patrón Modelo-Vista-Controlador, donde cada elemento tiene una responsabilidad específica: el modelo gestiona los datos, el controlador procesa las solicitudes y la vista representa la información.
La vista en Spring MVC se utiliza para renderizar la respuesta que el usuario verá en su navegador. Se basa en archivos de plantilla que pueden ser manejados por diversos motores como Thymeleaf, FreeMarker o Mustache. Estos motores permiten combinar código HTML con expresiones que insertan datos dinámicos provenientes del modelo.
Para emplear una vista, el método del controlador debe retornar una cadena con el nombre de la misma. Por ejemplo:
@GetMapping("/saludo")
public String mostrarSaludo(Model modelo) {
modelo.addAttribute("mensaje", "Bienvenido a nuestra aplicación");
return "saludo";
}
En este ejemplo, se agrega un atributo mensaje al modelo y se retorna la vista "saludo"
. Spring, mediante el ViewResolver, localizará el archivo de plantilla correspondiente en el directorio predeterminado, que suele ser src/main/resources/templates/
.
Si se utiliza Thymeleaf como motor de plantillas, el archivo podría llamarse saludo.html
y contener lo siguiente:
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Página de Saludo</title>
</head>
<body>
<h1 th:text="${mensaje}">Mensaje por defecto</h1>
</body>
</html>
Aquí, la expresión th:text="${mensaje}"
inserta el valor del atributo mensaje en el encabezado <h1>
. De esta manera, la vista utiliza los datos proporcionados por el modelo para generar contenido dinámico.
Es posible configurar diversas propiedades de las vistas en el archivo application.properties
o application.yml
. Por ejemplo, para cambiar el directorio de las plantillas:
spring.mvc.view.prefix=/WEB-INF/vistas/
Y para establecer el sufijo de los archivos de plantilla:
spring.mvc.view.suffix=.jsp
Estas configuraciones permiten utilizar otros motores de vistas, como JSP, adaptando la aplicación a diferentes necesidades.
Las redirecciones y los forwardings son mecanismos para controlar el flujo entre vistas y controladores. Una redirección instruye al navegador a realizar una nueva solicitud a una URL distinta, mientras que un forwarding transfiere el control internamente sin cambiar la URL visible para el usuario.
Para realizar una redirección:
@PostMapping("/procesar")
public String procesarFormulario() {
// Lógica de procesamiento
return "redirect:/resultado";
}
Y para un forwarding:
@GetMapping("/iniciar")
public String iniciarProceso() {
return "forward:/intermedio";
}
Es fundamental entender cómo funcionan las vistas y cómo se integran con los controladores y el modelo. Esto permite construir aplicaciones web donde la presentación de la información es coherente y está separada de la lógica de negocio.
Además, las vistas pueden beneficiarse de características avanzadas como la internacionalización, permitiendo mostrar contenido en diferentes idiomas según la configuración del usuario. Esto se logra mediante el uso de archivos de mensajes y recursos que el motor de vistas puede utilizar para adaptar el contenido.
Al utilizar plantillas con Thymeleaf, es posible iterar sobre colecciones, manejar condiciones y fragmentos reutilizables. Por ejemplo, para mostrar una lista de productos:
<ul>
<li th:each="producto : ${productos}" th:text="${producto.nombre}">Nombre del producto</li>
</ul>
En este fragmento, th:each
itera sobre la colección productos y th:text
muestra el nombre de cada producto. Esta capacidad dinámica convierte a las vistas en herramientas poderosas para la presentación de datos.
En resumen, la vista es el componente de Spring MVC que se ocupa de generar la interfaz de usuario. Mediante la combinación de controladores que proporcionan datos y vistas que los presentan, se construyen aplicaciones web estructuradas y eficientes. Comprender cómo se puede usar la vista es esencial para desarrollar proyectos con Spring Boot 3 y aprovechar al máximo sus funcionalidades.
Gestión de excepciones con @ControllerAdvice
En el desarrollo de aplicaciones web con Spring Boot 3, la gestión adecuada de excepciones es esencial para garantizar una experiencia de usuario consistente y para mantener el código limpio y mantenible. La anotación @ControllerAdvice proporciona un mecanismo eficaz para manejar excepciones de forma centralizada en la capa de controladores.
@ControllerAdvice es una especialización de la anotación @Component que permite definir una clase global de manejo de excepciones. Al utilizarla, es posible interceptar y procesar excepciones lanzadas por los métodos de los controladores, sin necesidad de agregar código de gestión de errores en cada uno de ellos.
Un ejemplo básico de una clase anotada con @ControllerAdvice es el siguiente:
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(NullPointerException.class)
public String handleNullPointerException(NullPointerException ex, Model modelo) {
modelo.addAttribute("errorMensaje", "Se ha producido un error inesperado.");
return "error";
}
}
En este ejemplo, se captura la excepción NullPointerException mediante el método anotado con @ExceptionHandler(NullPointerException.class). Cuando se produce esta excepción en cualquier controlador, se invoca este método, se agrega un mensaje de error al modelo y se retorna la vista "error".
Es posible manejar múltiples excepciones en una misma clase de @ControllerAdvice. Para ello, se pueden definir varios métodos con @ExceptionHandler:
@ExceptionHandler(IllegalArgumentException.class)
public String handleIllegalArgumentException(IllegalArgumentException ex, Model modelo) {
modelo.addAttribute("errorMensaje", ex.getMessage());
return "error";
}
En este caso, se captura IllegalArgumentException y se muestra el mensaje de la excepción en la vista de error.
Para aplicaciones que exponen servicios REST, es común retornar respuestas en formato JSON o XML. En lugar de retornar una vista, se puede devolver un objeto de tipo ResponseEntity:
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorDetalles> handleResourceNotFoundException(ResourceNotFoundException ex) {
ErrorDetalles errorDetalles = new ErrorDetalles(LocalDateTime.now(), ex.getMessage(), "Recurso no encontrado");
return new ResponseEntity<>(errorDetalles, HttpStatus.NOT_FOUND);
}
Aquí, ResourceNotFoundException es una excepción personalizada que se lanza cuando no se encuentra un recurso. Se crea un objeto ErrorDetalles con información relevante y se retorna con el código de estado HttpStatus.NOT_FOUND.
La clase ErrorDetalles podría definirse de la siguiente manera:
public record ErrorDetalles(LocalDateTime timestamp, String mensaje, String detalles) { }
Al utilizar records de Java, se simplifica la definición de clases de datos inmutables, mejorando la legibilidad del código.
Es posible aplicar @ControllerAdvice de forma selectiva a un subconjunto de controladores. Para ello, se pueden utilizar propiedades como basePackages, basePackageClasses o assignableTypes. Por ejemplo:
@ControllerAdvice(basePackages = "com.ejemplo.controladores.api")
public class ApiExceptionHandler {
// Métodos de manejo de excepciones
}
De esta forma, ApiExceptionHandler gestionará excepciones únicamente en los controladores del paquete com.ejemplo.controladores.api.
Además, se puede capturar excepciones genéricas para manejar cualquier error no previsto:
@ExceptionHandler(Exception.class)
public String handleGlobalException(Exception ex, Model modelo) {
modelo.addAttribute("errorMensaje", "Error interno del servidor.");
return "error";
}
Es importante el orden en que se definen los métodos @ExceptionHandler, ya que Spring buscará el manejador más específico para la excepción ocurrida.
Para evitar duplicar código, es posible crear una clase base que extienda de ResponseEntityExceptionHandler, la cual proporciona manejadores predeterminados para excepciones comunes. Por ejemplo:
@ControllerAdvice
public class RestResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {
@Override
protected ResponseEntity<Object> handleMethodArgumentNotValid(
MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
Map<String, String> errores = new HashMap<>();
ex.getBindingResult().getFieldErrors().forEach(error ->
errores.put(error.getField(), error.getDefaultMessage())
);
return new ResponseEntity<>(errores, HttpStatus.BAD_REQUEST);
}
}
Este método sobrescribe el manejador para MethodArgumentNotValidException, que se lanza cuando fallan las validaciones de los parámetros de entrada. Se recopilan los mensajes de error y se retornan en un mapa como respuesta con código BAD_REQUEST.
Para mejorar aún más la gestión de excepciones, se pueden utilizar @ResponseStatus en las excepciones personalizadas:
@ResponseStatus(HttpStatus.NOT_FOUND)
public class RecursoNoEncontradoException extends RuntimeException {
public RecursoNoEncontradoException(String mensaje) {
super(mensaje);
}
}
Al anotar la excepción con @ResponseStatus, se indica al framework que, cuando se lance esta excepción, debe responder con el código de estado especificado.
Además, es posible combinar @ControllerAdvice con @ResponseBody para que todos los manejadores de excepciones retornen directamente el cuerpo de la respuesta:
@RestControllerAdvice
public class GlobalRestExceptionHandler {
@ExceptionHandler(AccesoDenegadoException.class)
public ErrorDetalles handleAccesoDenegadoException(AccesoDenegadoException ex) {
return new ErrorDetalles(LocalDateTime.now(), ex.getMessage(), "Acceso denegado");
}
}
La anotación @RestControllerAdvice es una combinación de @ControllerAdvice y @ResponseBody, lo que simplifica la definición de manejadores en aplicaciones RESTful.
Para aplicaciones con múltiples módulos o capas, es recomendable organizar los manejadores de excepciones de manera lógica, agrupándolos según sus responsabilidades. Esto facilita el mantenimiento y mejora la claridad del código.
En resumen, la utilización de @ControllerAdvice en Spring Boot 3 permite una gestión centralizada y eficaz de las excepciones, mejorando la robustez de la aplicación y proporcionando respuestas adecuadas ante errores. Al implementar estos mecanismos, se garantiza una experiencia de usuario coherente y se simplifica la lógica de los controladores individuales.
Ejercicios de esta lección Controladores Spring MVC
Evalúa tus conocimientos de esta lección Controladores Spring MVC con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
API Query By Example (QBE)
Identificadores y relaciones JPA
Borrar datos de base de datos
Web y Test Starters
Métodos find en repositorios
Controladores Spring MVC
Inserción de datos
CRUD Customers Spring MVC + Spring Data JPA
Backend API REST con Spring Boot
Controladores Spring REST
Uso de Spring con Thymeleaf
API Specification
Registro de usuarios
Crear entidades JPA
Asociaciones en JPA
Asociaciones de entidades JPA
Integración con Vue
Consultas JPQL
Open API y cómo agregarlo en Spring Boot
Uso de Controladores REST
Repositorios reactivos
Inyección de dependencias
Introducción a Spring Boot
CRUD y JPA Repository
Inyección de dependencias
Vista en Spring MVC con Thymeleaf
Servicios en Spring
Operadores Reactivos
Configuración de Vue
Entidades JPA
Integración con Angular
API Specification
API Query By Example (QBE)
Controladores MVC
Anotaciones y mapeo en JPA
Consultas JPQL con @Query en Spring Data JPA
Repositorios Spring Data
Inyección de dependencias
Data JPA y Mail Starters
Configuración de Angular
Controladores Spring REST
Configuración de Controladores MVC
Consultas JPQL con @Query en Spring Data JPA
Actualizar datos de base de datos
Verificar token JWT en peticiones
Login de usuarios
Integración con React
Configuración de React
Todas las lecciones de SpringBoot
Accede a todas las lecciones de SpringBoot y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Spring Boot
Introducción Y Entorno
Spring Boot Starters
Introducción Y Entorno
Inyección De Dependencias
Introducción Y Entorno
Controladores Spring Mvc
Spring Web
Vista En Spring Mvc Con Thymeleaf
Spring Web
Controladores Spring Rest
Spring Web
Open Api Y Cómo Agregarlo En Spring Boot
Spring Web
Servicios En Spring
Spring Web
Clientes Resttemplate Y Restclient
Spring Web
Rxjava En Spring Web
Spring Web
Crear Entidades Jpa
Persistencia Spring Data
Asociaciones De Entidades Jpa
Persistencia Spring Data
Repositorios Spring Data
Persistencia Spring Data
Métodos Find En Repositorios
Persistencia Spring Data
Inserción De Datos
Persistencia Spring Data
Actualizar Datos De Base De Datos
Persistencia Spring Data
Borrar Datos De Base De Datos
Persistencia Spring Data
Consultas Jpql Con @Query En Spring Data Jpa
Persistencia Spring Data
Api Query By Example (Qbe)
Persistencia Spring Data
Api Specification
Persistencia Spring Data
Repositorios Reactivos
Persistencia Spring Data
Introducción E Instalación De Apache Kafka
Mensajería Asíncrona
Crear Proyecto Con Apache Kafka
Mensajería Asíncrona
Creación De Producers
Mensajería Asíncrona
Creación De Consumers
Mensajería Asíncrona
Kafka Streams En Spring Boot
Mensajería Asíncrona
Introducción A Spring Webflux
Reactividad Webflux
Spring Data R2dbc
Reactividad Webflux
Controlador Rest Reactivo Basado En Anotaciones
Reactividad Webflux
Controlador Rest Reactivo Funcional
Reactividad Webflux
Operadores Reactivos Básicos
Reactividad Webflux
Operadores Reactivos Avanzados
Reactividad Webflux
Cliente Reactivo Webclient
Reactividad Webflux
Introducción A Spring Security
Seguridad Con Spring Security
Seguridad Basada En Formulario En Mvc Con Thymeleaf
Seguridad Con Spring Security
Registro De Usuarios
Seguridad Con Spring Security
Login De Usuarios
Seguridad Con Spring Security
Verificar Token Jwt En Peticiones
Seguridad Con Spring Security
Seguridad Jwt En Api Rest Spring Web
Seguridad Con Spring Security
Seguridad Jwt En Api Rest Reactiva Spring Webflux
Seguridad Con Spring Security
Autenticación Y Autorización Con Anotaciones
Seguridad Con Spring Security
Testing Unitario De Componentes Y Servicios
Testing Con Spring Test
Testing De Repositorios Spring Data Jpa
Testing Con Spring Test
Testing Controladores Spring Mvc Con Thymeleaf
Testing Con Spring Test
Testing Controladores Rest Con Json
Testing Con Spring Test
Testing De Aplicaciones Reactivas Webflux
Testing Con Spring Test
Testing De Seguridad Spring Security
Testing Con Spring Test
Testing Con Apache Kafka
Testing Con Spring Test
Integración Con Angular
Integración Frontend
Integración Con React
Integración Frontend
Integración Con Vue
Integración Frontend
Certificados de superación de SpringBoot
Supera todos los ejercicios de programación del curso de SpringBoot y obtén certificados de superación para mejorar tu currículum y tu empleabilidad.
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender el patrón de diseño MVC y cómo se implementa en Spring MVC.
- Aprender cómo se configuran y utilizan los Controladores y Vistas en Spring MVC.
- Entender la auto-configuración en Spring Boot y cómo personalizarla según las necesidades.
- Familiarizarse con el punto de entrada de una aplicación Spring Boot y su propósito.
- Ser capaz de sintetizar y aplicar estos conceptos en el desarrollo de aplicaciones web con Spring Boot.