El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, aprenderemos cómo manejar los diferentes métodos HTTP en una aplicación Spring Boot. Los métodos HTTP son fundamentales para la comunicación en aplicaciones web, y cada uno tiene un propósito específico. Los métodos más comunes son GET, POST, PUT, DELETE y PATCH.

Conceptos Clave

GET: Recupera información del servidor.
POST: Envía datos al servidor para crear un nuevo recurso.
PUT: Actualiza un recurso existente en el servidor.
DELETE: Elimina un recurso del servidor.
PATCH: Aplica modificaciones parciales a un recurso.

Anotaciones en Spring Boot

Spring Boot proporciona anotaciones específicas para manejar estos métodos HTTP en los controladores. A continuación, se muestra una tabla con las anotaciones correspondientes:

Método HTTP	Anotación Spring Boot
GET	`@GetMapping`
POST	`@PostMapping`
PUT	`@PutMapping`
DELETE	`@DeleteMapping`
PATCH	`@PatchMapping`

Ejemplos Prácticos

Manejo del Método GET

El método GET se utiliza para recuperar información del servidor. Aquí hay un ejemplo de cómo manejar una solicitud GET en Spring Boot:

@RestController
@RequestMapping("/api")
public class MyController {

    @GetMapping("/items")
    public List<Item> getAllItems() {
        // Lógica para obtener todos los ítems
        return itemService.getAllItems();
    }
}

Manejo del Método POST

El método POST se utiliza para enviar datos al servidor y crear un nuevo recurso:

@RestController
@RequestMapping("/api")
public class MyController {

    @PostMapping("/items")
    public Item createItem(@RequestBody Item item) {
        // Lógica para crear un nuevo ítem
        return itemService.createItem(item);
    }
}

Manejo del Método PUT

El método PUT se utiliza para actualizar un recurso existente:

@RestController
@RequestMapping("/api")
public class MyController {

    @PutMapping("/items/{id}")
    public Item updateItem(@PathVariable Long id, @RequestBody Item item) {
        // Lógica para actualizar un ítem existente
        return itemService.updateItem(id, item);
    }
}

Manejo del Método DELETE

El método DELETE se utiliza para eliminar un recurso:

@RestController
@RequestMapping("/api")
public class MyController {

    @DeleteMapping("/items/{id}")
    public void deleteItem(@PathVariable Long id) {
        // Lógica para eliminar un ítem
        itemService.deleteItem(id);
    }
}

Manejo del Método PATCH

El método PATCH se utiliza para aplicar modificaciones parciales a un recurso:

@RestController
@RequestMapping("/api")
public class MyController {

    @PatchMapping("/items/{id}")
    public Item partiallyUpdateItem(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
        // Lógica para actualizar parcialmente un ítem
        return itemService.partiallyUpdateItem(id, updates);
    }
}

Ejercicio Práctico

Ejercicio 1: Crear un Controlador REST

Objetivo: Crear un controlador REST que maneje los métodos HTTP GET, POST, PUT, DELETE y PATCH para un recurso Product.

Crea una clase Product con los campos id, name y price.
Crea un servicio ProductService con métodos para manejar las operaciones CRUD.
Crea un controlador ProductController que maneje las solicitudes HTTP para el recurso Product.

Solución:

// Product.java
public class Product {
    private Long id;
    private String name;
    private Double price;

    // Getters y Setters
}

// ProductService.java
@Service
public class ProductService {
    private Map<Long, Product> productRepository = new HashMap<>();

    public List<Product> getAllProducts() {
        return new ArrayList<>(productRepository.values());
    }

    public Product createProduct(Product product) {
        product.setId((long) (productRepository.size() + 1));
        productRepository.put(product.getId(), product);
        return product;
    }

    public Product updateProduct(Long id, Product product) {
        product.setId(id);
        productRepository.put(id, product);
        return product;
    }

    public void deleteProduct(Long id) {
        productRepository.remove(id);
    }

    public Product partiallyUpdateProduct(Long id, Map<String, Object> updates) {
        Product product = productRepository.get(id);
        if (updates.containsKey("name")) {
            product.setName((String) updates.get("name"));
        }
        if (updates.containsKey("price")) {
            product.setPrice((Double) updates.get("price"));
        }
        productRepository.put(id, product);
        return product;
    }
}

// ProductController.java
@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }

    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        return productService.updateProduct(id, product);
    }

    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }

    @PatchMapping("/{id}")
    public Product partiallyUpdateProduct(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
        return productService.partiallyUpdateProduct(id, updates);
    }
}

Resumen

En esta sección, hemos aprendido cómo manejar los diferentes métodos HTTP en una aplicación Spring Boot utilizando anotaciones específicas. Hemos visto ejemplos prácticos para cada método y hemos creado un ejercicio para reforzar los conceptos aprendidos. Con esta base, estarás preparado para manejar solicitudes HTTP en tus aplicaciones Spring Boot de manera efectiva.

Manejo de Métodos HTTP

Conceptos Clave

Anotaciones en Spring Boot

Ejemplos Prácticos

Manejo del Método GET

Manejo del Método POST

Manejo del Método PUT

Manejo del Método DELETE

Manejo del Método PATCH

Ejercicio Práctico

Ejercicio 1: Crear un Controlador REST

Resumen

Curso de Spring Boot

Módulo 1: Introducción a Spring Boot

Módulo 2: Conceptos Básicos de Spring Boot

Módulo 3: Construyendo Servicios Web RESTful

Módulo 4: Acceso a Datos con Spring Boot

Módulo 5: Seguridad en Spring Boot

Módulo 6: Pruebas en Spring Boot

Módulo 7: Funciones Avanzadas de Spring Boot

Módulo 8: Despliegue de Aplicaciones Spring Boot

Módulo 9: Rendimiento y Monitoreo

Módulo 10: Mejores Prácticas y Consejos