Laboratorio de API Rest con Spring Boot.

Objetivo

El objetivo de este laboratorio es crear una API Rest con Spring Boot que permita realizar operaciones CRUD sobre una entidad de dominio, para ello utilizaremos Spring Data JPA y Lombok, levantaremos un contenedor de Docker con MySQL y utilizaremos el cliente Thunder Client para probar los servicios.

Requisitos

• JDK 17
• Maven 3.3.0
• IDE (IntelliJ IDEA, Eclipse, NetBeans, etc.)

Dependencias

• Spring Web
• Spring Data JPA
• Mysql Driver
• Lombok
• DevTools

Conceptos a aprender

API Rest

Una API Rest es una interfaz de programación de aplicaciones que utiliza el protocolo HTTP para realizar operaciones CRUD sobre recursos.

API Restful

Una API Restful es una API Rest que sigue los principios de la arquitectura REST.

Rest

REST (Representational State Transfer) es un estilo de arquitectura de software que define un conjunto de restricciones para el diseño de servicios web.

Crear un proyecto Spring Boot

Para crear un proyecto Spring Boot, se puede utilizar el Spring Initializr.

1. Ingresar a Spring Initializr.

2. Completar los campos del formulario.

• Project: Maven Project

• Language: Java

• Spring Boot: 3.1.1

• Group: com.aplication.rest

• Artifact: SpringBootRest

• Name: SpringBootRest

• Description: Api Rest with Spring Boot

• Package name: com.aplication.rest

• Packaging: Jar

• Java: 17

• Dependencies: Spring Web, Spring Data JPA, Mysql Driver, Lombok, DevTools

3. Hacer clic en el botón Generate.

Puedes utilizar el siguiente link para generar el proyecto.

4. Descomprimir el archivo zip descargado.

5. Importar el proyecto en el IDE.

Configurar la conexión a la base de datos

Para configurar la conexión a la base de datos, se debe modificar el archivo application.properties.

1. Abrir el archivo application.properties.

# Configuración de la Base de Datos
spring.datasource.url=jdbc:mysql://localhost:3306/rest_api_db
spring.datasource.username=root
spring.datasource.password=150919


## Configuración de Hibernate 
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Configuración de la Base de Datos

Para esta base de datos tenemos 2 opciones:

1. Crear un contenedor de Docker con MySQL.

2. Crear una base de datos en MySQL de forma nativa

En este laboratorio vamos a utilizar la opción 1.

Crear un contenedor de Docker con MySQL

1. Para crear el contenedor vamos a utilizar docker-compose.yml

version: '3.8'

services:
  db:
    container_name: mysql-db
    image: mysql:8
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 150919
      MYSQL_DATABASE: rest_api_db
    ports:
      - "3306:3306"
    volumes:
      - ./mysql-data:/var/lib/mysql

2. Vamos a probar si el contenedor se levanta correctamente.

docker compose up -d --build

Un resumen de lo que sucede en el comando anterior:

Inicialización de MySQL: El servidor MySQL se inicializa y se crean los archivos de la base de datos.

InnoDB: El motor InnoDB se inicializa satisfactoriamente.

Usuario root sin contraseña: Se crea el usuario root@localhost con una contraseña vacía. Esto se indica como una advertencia debido al uso de –initialize-insecure en tu configuración.

Inicio del servidor MySQL: El servidor MySQL se inicia y está listo para aceptar conexiones en el puerto 3306.

Advertencias sobre zonas horarias: Hay advertencias sobre la carga de archivos de zonas horarias que no se pueden cargar, pero no afectan la funcionalidad básica del servidor MySQL.

Creación de base de datos: Se crea la base de datos rest_api_db.

Detención del servidor temporal: Se detiene el servidor temporal que se inició inicialmente para realizar la inicialización.

MySQL listo para iniciar: El servidor MySQL está completamente iniciado y listo para aceptar conexiones.

3. Verificar si el contenedor se encuentra en ejecución.

docker ps

4. Conectarse al contenedor de MySQL.

docker exec -it mysql-db mysql -u root -p

Tip

El password es 150919

5. Verificar si la base de datos rest_api_db fue creada.

show databases;

6. Salir del contenedor de MySQL.

exit

Crear Entidades

1. Crear una nuevo paquete llamado entities.

2. Crear una nueva clase llamada Maker.

package com.aplication.rest.entities;

import jakarta.persistence.*;
import lombok.*;

import java.util.ArrayList;
import java.util.List;

@Getter
@Setter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "fabricante")
public class Maker {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "nombre")
    private String name;

    @OneToMany(mappedBy = "meker", cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
    private List<Product> productList = new ArrayList<>();
}

3. Crear una nueva clase llamada Product.

import jakarta.persistence.*;
import lombok.*;

import java.math.BigDecimal;

@Getter
@Setter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "producto")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "nombre")
    private String name;

    @Column(name = "precio")
    private BigDecimal price;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "id_fabricante", nullable = false)
    private Maker meker;
}

Probar el Servidor

1. Ejecutar el proyecto y verificamos si el servidor se encuentra en ejecución.

2. Verificar si la base de datos rest_api_db fue creada y las tablas fabricante y producto fueron creadas.

show databases;
use rest_api_db;
show tables;

3. Vamos a agregar datos en nuestras tablas.

Para ello vamos a crear un archivo import.sql en la carpeta resources.

INSERT INTO fabricante (nombre) VALUES ('Apple');
INSERT INTO fabricante (nombre) VALUES ('Samsung');
INSERT INTO fabricante (nombre) VALUES ('Xiaomi');

INSERT INTO producto (nombre, precio, id_fabricante) VALUES ('iPhone 13', 1000, 1);
INSERT INTO producto (nombre, precio, id_fabricante) VALUES ('Galaxy S21', 800, 2);
INSERT INTO producto (nombre, precio, id_fabricante) VALUES ('Redmi Note 10', 300, 3);

4. Ejecutar el proyecto y verificamos si los datos fueron insertados en las tablas.

5. Visualizamos los datos en la base de datos.

SELECT * FROM fabricante;
SELECT * FROM producto;

Creación del API Rest

Tip

En las entidades de nuestro proyecto es necesario agregar una anotación (JsonBackReference?) en la entidad Maker y Product para evitar un error de referencia cíclica.

    @JoinColumn(name = "id_fabricante", nullable = false)
1    @JsonBackReference
    private Maker maker;    

1

En la entidad Maker se agrega la anotación @JsonBackReference.

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "id_fabricante", nullable = false)
1    @JsonBackReference
    private Maker maker;

1

En la entidad Product se agrega la anotación @JsonBackReference.

Ahora vamos a crear un API Rest que permita realizar operaciones CRUD sobre las entidades Maker y Product.

1. Creamos un paquete llamado respository.

2. Creamos una interfaz llamada MakerRepository.

package com.aplication.rest.repository;

import com.aplication.rest.entities.Maker;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import java.util.Optional;

@Repository
public interface MakerRepository extends CrudRepository<Maker, Long>{
}

En el caso de la interfaz MakerRepository se extiende de CrudRepository que es una interfaz de Spring Data JPA que proporciona métodos CRUD para la entidad Maker.

3. Creamos una interfaz llamada ProductRepository.

package com.aplication.rest.repository;

import com.aplication.rest.entities.Product;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import java.math.BigDecimal;
import java.util.List;

@Repository
public interface ProductRepository extends CrudRepository<Product, Long> {
    List<Product> findByPriceBetween(BigDecimal minPrice, BigDecimal maxPrice);
}

En el caso de la interfaz ProductRepository se extiende de CrudRepository que es una interfaz de Spring Data JPA que proporciona métodos CRUD para la entidad Product.

4. Creamos un paquete llamado persistence

5. Creamos una interaz llamada IMakerDAO.

package com.aplication.rest.persistence;

import com.aplication.rest.entities.Maker;

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

public interface IMakerDAO {

    List<Maker> findAll();

    Optional<Maker> findById(Long id);

    void save(Maker maker);

    void deleteById(Long id);
}

En el código anterior se definen los métodos que se van a utilizar para realizar operaciones CRUD sobre la entidad Maker.

6. Creamos una interaz llamada IProductDAO.

package com.aplication.rest.persistence;

import com.aplication.rest.entities.Product;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

public interface IProductDAO {

    List<Product> findAll();

    Optional<Product> findById(Long id);

    List<Product> findByPriceinRange(BigDecimal minPrice, BigDecimal maxPrice);

    void save(Product product);

    void deleteById(Long id);

}

En el código anterior se definen los métodos que se van a utilizar para realizar operaciones CRUD sobre la entidad Product.

7. Creamos un paquete llamado impl dentro del paquete persistence.

8. Creamos una clase llamada MakerDAOImpl.

package com.aplication.rest.persistence.impl;

import com.aplication.rest.entities.Maker;
import com.aplication.rest.persistence.IMakerDAO;
import com.aplication.rest.repository.MakerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
public class MakerDAOImpl implements IMakerDAO {

    @Autowired
    private MakerRepository makerRepository;

    @Override
    public List<Maker> findAll() {
        return (List<Maker>) makerRepository.findAll();
    }

    @Override
    public Optional<Maker> findById(Long id) {
        return makerRepository.findById(id);
    }

    @Override
    public void save(Maker maker) {
        makerRepository.save(maker);
    }

    @Override
    public void deleteById(Long id) {
        makerRepository.deleteById(id);
    }
}

En el código anterior se implementan los métodos definidos en la interfaz IMakerDAO.

9. Creamos una clase llamada ProductDAOImpl.

package com.aplication.rest.persistence.impl;

import com.aplication.rest.entities.Product;
import com.aplication.rest.persistence.IProductDAO;
import com.aplication.rest.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

@Component
public class ProductDAOImpl implements IProductDAO {

    @Autowired
    private ProductRepository productRepository;

    @Override
    public List<Product> findAll() {
        return (List<Product>)productRepository.findAll();
    }

    @Override
    public Optional<Product> findById(Long id) {
        return productRepository.findById(id);
    }

    @Override
    public List<Product> findByPriceinRange(BigDecimal minPrice, BigDecimal maxPrice) {
        return productRepository.findByPriceBetween(minPrice, maxPrice);
    }

    @Override
    public void save(Product product) {
        productRepository.save(product);
    }

    @Override
    public void deleteById(Long id) {
        productRepository.deleteById(id);
    }
}

En el código anterior se implementan los métodos definidos en la interfaz IProductDAO.

10. Creamos un paquete llamado service.

11. Creamos una interfaz llamada IMakerService.

package com.aplication.rest.service;

import com.aplication.rest.entities.Maker;

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

public interface IMakerService {

    List<Maker> findAll();

    Optional<Maker> findById(Long id);

    void save(Maker maker);

    void deleteById(Long id);
}

El código anterior define los métodos que se van a utilizar para realizar operaciones CRUD sobre la entidad Maker.

12. Creamos una interfaz llamada IProductService.

package com.aplication.rest.service;

import com.aplication.rest.entities.Product;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

public interface IProductService {

    List<Product> findAll();

    Optional<Product> findById(Long id);

    List<Product> findByPriceinRange(BigDecimal minPrice, BigDecimal maxPrice);

    void save(Product product);

    void deleteById(Long id);
}

En el código anterior se definen los métodos que se van a utilizar para realizar operaciones CRUD sobre la entidad Product.

13. Creamos un paquete llamado impl dentro del paquete service.

14. Creamos una clase llamada MakerServiceImpl.

package com.aplication.rest.service.impl;

import com.aplication.rest.entities.Maker;
import com.aplication.rest.persistence.IMakerDAO;
import com.aplication.rest.service.IMakerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class MakerServiceImpl implements IMakerService {

    @Autowired
    private IMakerDAO makerDAO;

    @Override
    public List<Maker> findAll() {
        return makerDAO.findAll();
    }

    @Override
    public Optional<Maker> findById(Long id) {
        return makerDAO.findById(id);
    }

    @Override
    public void save(Maker maker) {
        makerDAO.save(maker);
    }

    @Override
    public void deleteById(Long id) {
        makerDAO.deleteById(id);
    }
}

En el código anterior se implementan los métodos definidos en la interfaz IMakerService.

15. Creamos una clase llamada ProductServiceImpl.

package com.aplication.rest.service.impl;

import com.aplication.rest.entities.Product;
import com.aplication.rest.persistence.IProductDAO;
import com.aplication.rest.service.IProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

@Service
public class ProductServiceImpl implements IProductService {

    @Autowired
    private IProductDAO productDAO;

    @Override
    public List<Product> findAll() {
        return productDAO.findAll();
    }

    @Override
    public Optional<Product> findById(Long id) {
        return productDAO.findById(id);
    }

    @Override
    public List<Product> findByPriceinRange(BigDecimal minPrice, BigDecimal maxPrice) {
        return productDAO.findByPriceinRange(minPrice, maxPrice);
    }

    @Override
    public void save(Product product) {
        productDAO.save(product);
    }

    @Override
    public void deleteById(Long id) {
        productDAO.deleteById(id);
    }
}

En el código anterior se implementan los métodos definidos en la interfaz IProductService.

16. Creamos un paquete llamado controllers.

17. Creamos el paquete llamado dto dentro del paquete controllers.

18. Creamos una clase llamada MakerDTO.

package com.aplication.rest.controllers.dto;

import com.aplication.rest.entities.Product;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class MakerDTO {

    private Long id;
    private String name;
    private List<Product> productList = new ArrayList<>();
}

En el código anterior se define una clase MakerDTO que se va a utilizar para mapear los datos de la entidad Maker.

19. Creamos una clase llamada ProductDTO.

package com.aplication.rest.controllers.dto;

import com.aplication.rest.entities.Maker;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class ProductDTO {
    private Long id;
    private String name;
    private BigDecimal price;
    private Maker maker;
}

En el código anterior se define una clase ProductDTO que se va a utilizar para mapear los datos de la entidad Product.

20. Creamos una clase llamada MakerController.

package com.aplication.rest.controllers;

import com.aplication.rest.controllers.dto.MakerDTO;
import com.aplication.rest.entities.Maker;
import com.aplication.rest.service.IMakerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/maker")
public class MakerController {

    @Autowired
    private IMakerService makerService;

    @GetMapping("/find/{id}")
    public ResponseEntity<?> findById(@PathVariable Long id) {
        Optional<Maker> makerOptional = makerService.findById(id);

        if (makerOptional.isPresent()) {
            Maker maker = makerOptional.get();

            MakerDTO makerDTO = MakerDTO.builder()
                    .id(maker.getId())
                    .name(maker.getName())
                    .productList(maker.getProductList())
                    .build();

            return ResponseEntity.ok(makerDTO);
        }

        return ResponseEntity.notFound().build();
    }

    @GetMapping("/findAll")
    public ResponseEntity<?> findAll() {
        List<MakerDTO> makerList = makerService.findAll()
                .stream()
                .map(maker -> MakerDTO.builder()
                        .id(maker.getId())
                        .name(maker.getName())
                        .productList(maker.getProductList())
                        .build())
                .toList();
        return ResponseEntity.ok(makerList);
    }

    @PostMapping("/save")
    public ResponseEntity<?> save(@RequestBody MakerDTO makerDTO) throws URISyntaxException {

        if(makerDTO.getName().isBlank()){
            return ResponseEntity.badRequest().build();
        }

        makerService.save(Maker.builder()
                .name(makerDTO.getName())
                .build());

        return ResponseEntity.created(new URI("/api/maker/save")).build();
    }

    @PutMapping("/update/{id}")
    public ResponseEntity<?> update(@PathVariable Long id, @RequestBody MakerDTO makerDTO) {

        Optional<Maker> makerOptional = makerService.findById(id);

        if (makerOptional.isPresent()) {
            Maker maker = makerOptional.get();
            maker.setName(makerDTO.getName());
            makerService.save(maker);
            return ResponseEntity.ok("Registro Actualizado");
        }
        return ResponseEntity.notFound().build();
    }

    @DeleteMapping("/delete/{id}")
    public ResponseEntity<?> delete(@PathVariable Long id) {

        if (id != null) {
            makerService.deleteById(id);
            return ResponseEntity.ok("Registro Eliminado");
        }
        return ResponseEntity.notFound().build();
    }
}

En el código anterior se define un controlador llamado MakerController que permite realizar operaciones CRUD sobre la entidad Maker.

21. Creamos una clase llamada ProductController.

package com.aplication.rest.controllers;

import com.aplication.rest.controllers.dto.ProductDTO;
import com.aplication.rest.entities.Product;
import com.aplication.rest.service.IProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/product")
public class ProductController {

    @Autowired
    private IProductService productService;

    @GetMapping("/find/{id}")
    public ResponseEntity<?> findById(@PathVariable Long id) {
        Optional<Product> productOptional = productService.findById(id);
        if (productOptional.isPresent()){
            Product product = productOptional.get();
            ProductDTO productDTO = ProductDTO.builder()
                    .id(product.getId())
                    .name(product.getName())
                    .price(product.getPrice())
                    .maker(product.getMaker())
                    .build();
            return ResponseEntity.ok(productDTO);
        } else {
            return ResponseEntity.badRequest().build();
        }
    }

    @GetMapping("/findAll")
    public ResponseEntity<?> findAll() {
        List<ProductDTO> productList = productService.findAll()
                .stream()
                .map(product -> ProductDTO.builder()
                        .id(product.getId())
                        .name(product.getName())
                        .price(product.getPrice())
                        .maker(product.getMaker())
                        .build()
                ).toList();
        return ResponseEntity.ok(productList);
    }

    @PostMapping("/save")
    public ResponseEntity<?> save(ProductDTO productDTO) throws URISyntaxException {
        if (productDTO.getName().isBlank() || productDTO.getPrice()==null || productDTO.getMaker()==null){
            return ResponseEntity.badRequest().build();
        }

        Product product = Product.builder()
                .name(productDTO.getName())
                .price(productDTO.getPrice())
                .maker(productDTO.getMaker())
                .build();
        productService.save(product);

        return ResponseEntity.created(new URI("/api/product/save")).build();
    }

    @PutMapping("/update/{id}")
    public ResponseEntity<?> update(@PathVariable Long id, @RequestBody ProductDTO productDTO) {

        Optional<Product> productOptional = productService.findById(id);

        if (productOptional.isPresent()){
            Product product = productOptional.get();
            product.setName(productDTO.getName());
            product.setPrice(productDTO.getPrice());
            product.setMaker(productDTO.getMaker());
            productService.save(product);
            return ResponseEntity.ok("Registro Actualizado");
        }

        return ResponseEntity.notFound().build();
    }

    @DeleteMapping("/delete/{id}")
    public ResponseEntity<?> deleteById(@PathVariable Long id) {

        if(id != null){
            productService.deleteById(id);
            return ResponseEntity.ok("Registro Eliminado");
        }
        return ResponseEntity.badRequest().build();
    }
}

En el código anterior se define un controlador llamado ProductController que permite realizar operaciones CRUD sobre la entidad Product.

Probar el API Rest

1. Ejecutar el proyecto y verificamos si el servidor se encuentra en ejecución.

Metodo findAll de Maker

Metodo find/{id} de Maker

Metodo save de Maker

Metodo update/{id} de Maker

Metodo delete/{id} de Maker

Reto

Warning

Existen algunos errores en el código del producto, en particular en el archivo ProductController y en el ProductDTO. Por favor corrigelos para cumplir con el Reto.

1. Implementar los métodos findAll y find/{id} de la entidad Product.

2. Implementar los métodos save, update/{id} y delete/{id}** de la entidad Product.

3. Probar los métodos implementados.

Conclusiones

• En este laboratorio se ha creado una API Rest con Spring Boot que permite realizar operaciones CRUD sobre las entidades Maker y Product.
• Se ha utilizado Spring Data JPA para realizar operaciones CRUD sobre las entidades.
• Se ha utilizado Lombok para reducir la cantidad de código boilerplate.
• Se ha utilizado Docker para crear un contenedor con MySQL.
• Se ha utilizado el cliente Thunder Client para probar los servicios.

Referencias

• Spring Boot
• Spring Data JPA
• Spring Initializr
• Docker
• MySQL
• Lombok
• Código del Proyecto