CodeGym /Cursos /Módulo 5. Spring /Lección 177: Práctica: implementación de un REST API senc...

Lección 177: Práctica: implementación de un REST API sencillo para un microservicio

Módulo 5. Spring

Nivel 12 , Lección 6

Disponible

Hoy veremos el desarrollo práctico de un microservicio para gestionar la entidad Customer. Implementaremos operaciones CRUD, conectaremos la base de datos con Spring Data JPA y probaremos todo esto con herramientas como Postman.

Paso 1: preparar el entorno y crear un nuevo proyecto

Para empezar, crea un proyecto nuevo. Puedes hacerlo desde Spring Initializr:

Indica los siguientes parámetros:
- Project: Maven
- Language: Java
- Spring Boot Version: 3.0.x+
- Dependencies:
  - Spring Web
  - Spring Data JPA
  - H2 Database (base de datos en memoria para pruebas)
  - Spring Boot DevTools (para un desarrollo más cómodo)
Descarga el proyecto y ábrelo en tu IDE (por ejemplo, IntelliJ IDEA).

Paso 2: Configuración de la base de datos

Crea el archivo application.yml en la carpeta src/main/resources (si no existe). Configura la conexión a la base de datos H2 así:


spring:
  datasource:
    url: jdbc:h2:mem:customerdb
    driver-class-name: org.h2.Driver
    username: sa
    password: password
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true

Este archivo configura la base de datos en memoria (H2) y le indica a Hibernate que actualice automáticamente el esquema de las tablas. La opción show-sql permite ver las consultas SQL en la consola, lo cual es muy útil para depurar.

Paso 3: Crear la entidad `Customer`

Añade la clase Customer en el package com.example.customer:


package com.example.customer;

import jakarta.persistence.*;

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Generación automática del ID
    private Long id;

    @Column(nullable = false) // El campo no puede ser null
    private String name;

    @Column(nullable = false, unique = true)
    private String email;

    public Customer() {
        // Constructor por defecto para JPA
    }

    public Customer(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters y setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Hemos descrito la entidad Customer con los campos id, name y email. La anotación @Entity indica a JPA que esta clase se mapea a una tabla en la base de datos.

Paso 4: Crear el repositorio

Crea la interfaz CustomerRepository:


package com.example.customer;

import org.springframework.data.jpa.repository.JpaRepository;

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    // JpaRepository proporciona las operaciones CRUD básicas
}

Esta interfaz permite trabajar con la base fácilmente, evitando escribir SQL. Por ejemplo, los métodos save(), findById(), findAll() y deleteById() están disponibles nada más añadir el repositorio.

Paso 5: Crear el servicio

Añade la clase CustomerService:


package com.example.customer;

import org.springframework.stereotype.Service;

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

@Service
public class CustomerService {

    private final CustomerRepository customerRepository;

    public CustomerService(CustomerRepository customerRepository) {
        this.customerRepository = customerRepository;
    }

    public List<Customer> getAllCustomers() {
        return customerRepository.findAll();
    }

    public Customer getCustomerById(Long id) {
        return customerRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("Customer not found with id: " + id));
    }

    public Customer createCustomer(Customer customer) {
        return customerRepository.save(customer);
    }

    public Customer updateCustomer(Long id, Customer updatedCustomer) {
        Customer existingCustomer = getCustomerById(id);
        existingCustomer.setName(updatedCustomer.getName());
        existingCustomer.setEmail(updatedCustomer.getEmail());
        return customerRepository.save(existingCustomer);
    }

    public void deleteCustomer(Long id) {
        customerRepository.deleteById(id);
    }
}

Esta clase encapsula la lógica de negocio para trabajar con clientes.

Paso 6: Crear el controlador REST

Añade la clase CustomerController:


package com.example.customer;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/customers")
public class CustomerController {

    private final CustomerService customerService;

    public CustomerController(CustomerService customerService) {
        this.customerService = customerService;
    }

    @GetMapping
    public List<Customer> getAllCustomers() {
        return customerService.getAllCustomers();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Customer> getCustomerById(@PathVariable Long id) {
        try {
            Customer customer = customerService.getCustomerById(id);
            return ResponseEntity.ok(customer);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Customer createCustomer(@RequestBody Customer customer) {
        return customerService.createCustomer(customer);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Customer> updateCustomer(@PathVariable Long id, @RequestBody Customer updatedCustomer) {
        try {
            Customer customer = customerService.updateCustomer(id, updatedCustomer);
            return ResponseEntity.ok(customer);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteCustomer(@PathVariable Long id) {
        customerService.deleteCustomer(id);
    }
}

El controlador maneja las peticiones HTTP y llama a los métodos del servicio. Aquí usamos las anotaciones @RestController, @GetMapping, @PostMapping, @PutMapping y @DeleteMapping para enrutar las solicitudes.

Paso 7: Probar el REST API

Arranca la aplicación: pulsa Run en tu IDE o ejecuta el comando mvn spring-boot:run en la terminal.

Probar endpoints con Postman

Obtener todos los clientes (GET):
- URL: http://localhost:8080/customers
- Response: [ ] (por defecto lista vacía).
Crear un nuevo cliente (POST):
- URL: http://localhost:8080/customers
- Body (JSON):
```
{
  "name": "John Doe",
  "email": "john.doe@example.com"
}
```
- Response: el objeto creado.
Obtener cliente por ID (GET):
- URL: http://localhost:8080/customers/1.
Actualizar cliente (PUT):
- URL: http://localhost:8080/customers/1
- Body (JSON):
```
{
  "name": "Jane Doe",
  "email": "jane.doe@example.com"
}
```
Eliminar cliente (DELETE):
- URL: http://localhost:8080/customers/1.

Paso 8: Manejo de errores y mejoras

Si intentas eliminar o actualizar un cliente que no existe, la aplicación debería devolver 404. Esto ya está implementado en nuestro controlador usando ResponseEntity y excepciones personalizadas.

¡Enhorabuena! Acabas de crear tu primer microservicio con REST API. Ahora estás listo para crear más y escalarlo!

Anterior Lección anterior

Siguiente Siguiente lección

Comentarios

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION