Spring Boot

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ícate

Uso 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.

Para seguir leyendo hazte Plus

¿Ya eres Plus? Accede a la app

50 % DE DESCUENTO

Plan mensual

19.00 /mes

9.50 € /mes

Precio normal mensual: 19 €
74 % DE DESCUENTO

Plan anual

10.00 /mes

5.00 € /mes

Ahorras 168 € al año
Precio normal anual: 120 €
Aprende SpringBoot GRATIS online

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)

Spring Boot
Test

Identificadores y relaciones JPA

Spring Boot
Puzzle

Borrar datos de base de datos

Spring Boot
Test

Web y Test Starters

Spring Boot
Puzzle

Métodos find en repositorios

Spring Boot
Test

Controladores Spring MVC

Spring Boot
Código

Inserción de datos

Spring Boot
Test

CRUD Customers Spring MVC + Spring Data JPA

Spring Boot
Proyecto

Backend API REST con Spring Boot

Spring Boot
Proyecto

Controladores Spring REST

Spring Boot
Código

Uso de Spring con Thymeleaf

Spring Boot
Puzzle

API Specification

Spring Boot
Puzzle

Registro de usuarios

Spring Boot
Test

Crear entidades JPA

Spring Boot
Código

Asociaciones en JPA

Spring Boot
Test

Asociaciones de entidades JPA

Spring Boot
Código

Integración con Vue

Spring Boot
Test

Consultas JPQL

Spring Boot
Código

Open API y cómo agregarlo en Spring Boot

Spring Boot
Puzzle

Uso de Controladores REST

Spring Boot
Puzzle

Repositorios reactivos

Spring Boot
Test

Inyección de dependencias

Spring Boot
Test

Introducción a Spring Boot

Spring Boot
Test

CRUD y JPA Repository

Spring Boot
Puzzle

Inyección de dependencias

Spring Boot
Código

Vista en Spring MVC con Thymeleaf

Spring Boot
Test

Servicios en Spring

Spring Boot
Código

Operadores Reactivos

Spring Boot
Puzzle

Configuración de Vue

Spring Boot
Puzzle

Entidades JPA

Spring Boot
Test

Integración con Angular

Spring Boot
Test

API Specification

Spring Boot
Test

API Query By Example (QBE)

Spring Boot
Puzzle

Controladores MVC

Spring Boot
Test

Anotaciones y mapeo en JPA

Spring Boot
Puzzle

Consultas JPQL con @Query en Spring Data JPA

Spring Boot
Test

Repositorios Spring Data

Spring Boot
Test

Inyección de dependencias

Spring Boot
Puzzle

Data JPA y Mail Starters

Spring Boot
Test

Configuración de Angular

Spring Boot
Puzzle

Controladores Spring REST

Spring Boot
Test

Configuración de Controladores MVC

Spring Boot
Puzzle

Consultas JPQL con @Query en Spring Data JPA

Spring Boot
Puzzle

Actualizar datos de base de datos

Spring Boot
Test

Verificar token JWT en peticiones

Spring Boot
Test

Login de usuarios

Spring Boot
Test

Integración con React

Spring Boot
Test

Configuración de React

Spring Boot
Puzzle

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

Spring Boot

Introducción Y Entorno

Spring Boot Starters

Spring Boot

Introducción Y Entorno

Inyección De Dependencias

Spring Boot

Introducción Y Entorno

Controladores Spring Mvc

Spring Boot

Spring Web

Vista En Spring Mvc Con Thymeleaf

Spring Boot

Spring Web

Controladores Spring Rest

Spring Boot

Spring Web

Open Api Y Cómo Agregarlo En Spring Boot

Spring Boot

Spring Web

Servicios En Spring

Spring Boot

Spring Web

Clientes Resttemplate Y Restclient

Spring Boot

Spring Web

Rxjava En Spring Web

Spring Boot

Spring Web

Crear Entidades Jpa

Spring Boot

Persistencia Spring Data

Asociaciones De Entidades Jpa

Spring Boot

Persistencia Spring Data

Repositorios Spring Data

Spring Boot

Persistencia Spring Data

Métodos Find En Repositorios

Spring Boot

Persistencia Spring Data

Inserción De Datos

Spring Boot

Persistencia Spring Data

Actualizar Datos De Base De Datos

Spring Boot

Persistencia Spring Data

Borrar Datos De Base De Datos

Spring Boot

Persistencia Spring Data

Consultas Jpql Con @Query En Spring Data Jpa

Spring Boot

Persistencia Spring Data

Api Query By Example (Qbe)

Spring Boot

Persistencia Spring Data

Api Specification

Spring Boot

Persistencia Spring Data

Repositorios Reactivos

Spring Boot

Persistencia Spring Data

Introducción E Instalación De Apache Kafka

Spring Boot

Mensajería Asíncrona

Crear Proyecto Con Apache Kafka

Spring Boot

Mensajería Asíncrona

Creación De Producers

Spring Boot

Mensajería Asíncrona

Creación De Consumers

Spring Boot

Mensajería Asíncrona

Kafka Streams En Spring Boot

Spring Boot

Mensajería Asíncrona

Introducción A Spring Webflux

Spring Boot

Reactividad Webflux

Spring Data R2dbc

Spring Boot

Reactividad Webflux

Controlador Rest Reactivo Basado En Anotaciones

Spring Boot

Reactividad Webflux

Controlador Rest Reactivo Funcional

Spring Boot

Reactividad Webflux

Operadores Reactivos Básicos

Spring Boot

Reactividad Webflux

Operadores Reactivos Avanzados

Spring Boot

Reactividad Webflux

Cliente Reactivo Webclient

Spring Boot

Reactividad Webflux

Introducción A Spring Security

Spring Boot

Seguridad Con Spring Security

Seguridad Basada En Formulario En Mvc Con Thymeleaf

Spring Boot

Seguridad Con Spring Security

Registro De Usuarios

Spring Boot

Seguridad Con Spring Security

Login De Usuarios

Spring Boot

Seguridad Con Spring Security

Verificar Token Jwt En Peticiones

Spring Boot

Seguridad Con Spring Security

Seguridad Jwt En Api Rest Spring Web

Spring Boot

Seguridad Con Spring Security

Seguridad Jwt En Api Rest Reactiva Spring Webflux

Spring Boot

Seguridad Con Spring Security

Autenticación Y Autorización Con Anotaciones

Spring Boot

Seguridad Con Spring Security

Testing Unitario De Componentes Y Servicios

Spring Boot

Testing Con Spring Test

Testing De Repositorios Spring Data Jpa

Spring Boot

Testing Con Spring Test

Testing Controladores Spring Mvc Con Thymeleaf

Spring Boot

Testing Con Spring Test

Testing Controladores Rest Con Json

Spring Boot

Testing Con Spring Test

Testing De Aplicaciones Reactivas Webflux

Spring Boot

Testing Con Spring Test

Testing De Seguridad Spring Security

Spring Boot

Testing Con Spring Test

Testing Con Apache Kafka

Spring Boot

Testing Con Spring Test

Integración Con Angular

Spring Boot

Integración Frontend

Integración Con React

Spring Boot

Integración Frontend

Integración Con Vue

Spring Boot

Integración Frontend

Accede GRATIS a SpringBoot y certifícate

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

  1. Comprender el patrón de diseño MVC y cómo se implementa en Spring MVC.
  2. Aprender cómo se configuran y utilizan los Controladores y Vistas en Spring MVC.
  3. Entender la auto-configuración en Spring Boot y cómo personalizarla según las necesidades.
  4. Familiarizarse con el punto de entrada de una aplicación Spring Boot y su propósito.
  5. Ser capaz de sintetizar y aplicar estos conceptos en el desarrollo de aplicaciones web con Spring Boot.