Anotaciones Spring para Exponer APIs RESTful

Curso de Java Spring

Contenido del curso

Antes de empezar

Introducción a Spring boot

Spring Data

Construyendo nuestra API

Mejorando nuestra API

Despliegue de nuestra aplicación

Tomar examen

Anotaciones Spring para Exponer APIs RESTful

Resumen

¿Cómo exponer una API utilizando Spring?

El mundo del desarrollo de software es vasto, y una herramienta muy valiosa en la construcción de aplicaciones es la capacidad de exponer APIs de manera eficiente. Spring Framework nos facilita esta tarea proporcionándonos varias anotaciones que nos permiten publicar nuestros servicios rápidamente y con menos complicaciones. En esta clase exploraremos cómo usar las anotaciones @GetMapping, @PostMapping y @DeleteMapping.

¿Cómo usar GetMapping para obtener información?

Para obtener información de nuestro servidor, utilizamos la anotación @GetMapping. Esta anotación nos permite vincular un método a una solicitud HTTP GET. Por ejemplo, si queremos publicar un servicio que recupere una lista completa de productos, simplemente añadimos @GetMapping al método correspondiente, especificando la ruta de acceso adecuada:

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

Cuando implementamos el servicio y lo lanzamos, podemos verificar su correcto funcionamiento desde el navegador o mediante herramientas como Postman. Una solicitud GET sencilla nos devolverá la lista de productos.

¿Cómo recuperar un producto específico por su ID?

Recuperar un producto por su ID es igualmente sencillo, pero requiere un enfoque ligeramente distinto: debemos incluir una variable de ruta en la anotación @GetMapping. Usamos {} para indicar parámetros de ruta dinámicos y @PathVariable para mapearlos al método pertinente:

@GetMapping("/products/{productId}")
public Product getProductById(@PathVariable("productId") Long id) {
    return productService.getProductById(id);
}

Aquí, el ID del producto se pasa como parte de la URL, lo que nos permite recuperar el producto específico a través de métodos HTTP.

¿Cómo construir servicios más complejos?

Para manejar solicitudes más complejas, como filtrar productos por categoría, modificamos ligeramente nuestras anotaciones:

@GetMapping("/products/category/{categoryId}")
public List<Product> getProductsByCategory(@PathVariable("categoryId") Long categoryId) {
    return productService.getProductsByCategory(categoryId);
}

Asegúrate de diferenciar entre varias rutas posibles para evitar conflictos, por ejemplo, al utilizar identificadores de categorías.

¿Cómo guardar y actualizar información con PostMapping?

Para enviar información nueva al servidor, @PostMapping es la anotación que debemos utilizar, indicando que la información se envía en el cuerpo de la solicitud:

@PostMapping("/products/save")
public Product saveProduct(@RequestBody Product product) {
    return productService.saveProduct(product);
}

Con esto, recibimos un nuevo objeto Product que se procesa y guarda en el sistema. Asegúrate de formatear las solicitudes JSON correctamente en herramientas como Postman.

¿Cómo eliminar registros con DeleteMapping?

Cuando necesitamos eliminar un recurso, @DeleteMapping es la solución. Como en operaciones de obtención de datos, utilizamos la variable de ruta para especificar qué recurso debe eliminarse:

@DeleteMapping("/products/{productId}")
public boolean deleteProduct(@PathVariable("productId") Long id) {
    return productService.deleteProduct(id);
}

Esta llamada posiblemente retornará un valor booleano indicando si la operación fue exitosa.

Exponer APIs utilizando Spring es una tarea accesible y altamente efectiva. Con estos ejemplos y el poderoso conjunto de herramientas de Spring, puedes empezar a crear servicios robustos y eficientes para tu aplicación. ¡Continúa explorando y desarrollando, ya que siempre hay nuevas técnicas y mejoras esperando ser descubiertas!

Laura Sofía Córdoba

Estudiante

Se me ocurrio el update de la siguiente forma, pero pienso que debe haber una mejor manera de hacerlo

package com.platzi.market.domain.service;

import com.platzi.market.domain.Product;
import com.platzi.market.domain.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public List<Product> getAll(){
        return productRepository.getAll();
    }

    public Optional<Product> getProduct(long productId){
        return productRepository.getProduct(productId);
    }

    public Optional<List<Product>> getByCategory (long categoryId){
        return productRepository.getByIdCategory(categoryId);
    }

    public Optional<List<Product>> getScarseProducts (int quantity){
        return  productRepository.getScarseProduct(quantity);
    }

    public Product save (Product product){
        return productRepository.save(product);
    }

    public boolean delete (long productId){
         return getProduct(productId).map(product -> {
             productRepository.delete(productId);
            return true;
         }).orElse(false);
    }


    public void update (long productId , Product product){
         Product product1 = getProduct(productId).get();
         product1.setName(product.getName());
         product1.setCategory(product.getCategory());
         product1.setActive(product.isActive());
         product1.setPrice(product.getPrice());
         product1.setStock(product.getStock());
         save(product1);
    }

package com.platzi.market.web.controller;

import com.platzi.market.domain.Product;
import com.platzi.market.domain.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

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

    @Autowired
    private ProductService productService;

    @GetMapping("/all")
    public List<Product>getAll(){
        return productService.getAll();
    }

    @GetMapping("/{id}")
    public Optional<Product> getProducto(@PathVariable("id") long productId){
        return productService.getProduct(productId);
    }

    @GetMapping("/category/{categoryId}")
    public Optional<List<Product>> getByCategory(@PathVariable("categoryId") long categoryId){
        return  productService.getByCategory(categoryId);
    }

    @PostMapping("/save")
    public Product save(@RequestBody  Product product){
        return productService.save(product);
    }

    @PutMapping("/{id}")
    public void update (@PathVariable("id") long productId, @RequestBody Product product){
        productService.update(productId, product);
    }

    @DeleteMapping("/delete/{id}")
    public boolean delete(@PathVariable("id") long productId){
        return productService.delete(productId);
    }


}

William Alexander Hernandez Leiva

Estudiante

Me parece bien cumple su proposito, solo queria saber si agregaste el metodo en ProductRepository y ProductoRepository ya que estamos hablando en terminos de dominio. Te comparto mi metodo update.

    @PutMapping(value = "/update/{productId}")
    public Product update(@RequestBody Product product, @PathVariable("productId") long productId) {
        return productService.getProduct(productId)
                .map(product1 -> {
                    product1.setName(product.getName());
                    product1.setCategoryId(product.getCategoryId());
                    product1.setPrice(product.getPrice());
                    product1.setStock(product.getStock());
                    product1.setActive(product.isActive());
                    return productService.save(product1);
                })
                .orElseGet(() -> {
                    product.setProductId(productId);
                    return productService.save(product);
                });
    }

Lo copie de la pagina oficial de Spring https://spring.io/guides/tutorials/rest/ por si quieres observarlo.

Santiago Mejia

Estudiante

Con solo el codigo qu eagrega William Alexander agrego el Put?? o debo dirigirme a otra parte?? y escribir mas

Raul Castillo

Alejandro Ramírez

Profesor

Rosemberg Porras Mancilla

Eliana Huamani

Jefersson Nuñez Nava

Abel Areiza

Jose Gabriel Cortazar Ocampo

Jaime Manuel Cutipa Calderón

Ylse Maria Alvarez Perez

Juan Pablo Peña Franco

Gleycer Parra

Brayam Steven Builes Echavarria

Brayan Olarte

Luis Pillaga

jose puma chavez

Omar Buendia

Rolando Mamani Salas

oscar Florez

Marco Antonio Alvarado Cabrera

Daniel Aristizabal castaño

Cristian David Restrepo Marin

Alexis Méndez Méndez

Cesar Eduardo Valle Pino

Franco David Oliva

David Gallego

Cristian Felipe Patiño Cáceres

Santiago Hernández Bolívar

FREDDY LEONARDO ABAD LEON

Uziel Lorenzo

William Amaya

Miguel Urango

Nicoll Idaly Angulo Mejia

Jhonatan Ortiz Cabezas

Christian Gabriel Espino Magaña

Anotaciones Spring para Exponer APIs RESTful

Antes de empezar

Desarrollo de API con Java Spring Framework

Evolución y Licencias de Java: Oracle y OpenJDK

Instalación de herramientas de desarrollo en Windows

Instalación de entorno de desarrollo Java en Ubuntu 20.04.1 LTS

Instalación de Entorno Java Spring Boot en macOS 2025

Introducción a Spring boot

Creación de Aplicaciones Autocontenidas con SpringBoot

Configuración de Proyectos Spring Boot en IntelliJ IDEA

Configuración de Spring Boot con application.properties y perfiles

Arquitectura por Capas para Aplicaciones de Supermercado

Spring Data

Conceptos básicos de JPA y anotaciones en Java

Gestión de Bases de Datos con Spring Data JPA en Java

Conexión y Configuración de Base de Datos en Spring Boot

Mapeo de Tablas a Clases con JPA: Creación de Entities en Java

Creación de Entities con Clave Primaria Compuesta en JPA

Relaciones JPA: Categorías, Productos, Compras y Clientes

Repositorios de Spring Data: Gestión Eficiente de Bases de Datos

Consultas avanzadas con Query Methods en Spring Data

Construyendo nuestra API

Clase de Repositorio de Productos con Spring Framework

Patrón DataMapper en Proyectos Java: Implementación y Beneficios

Creación de Mapeadores con MapStruct en Java

Repositorio de Productos Orientado al Dominio en Java

Inyección de Dependencias en Spring Framework

Implementación de Servicios de Dominio en Java con Spring Framework

Creación de Controlador REST en Spring Boot