Hoy pasamos a lo más interesante: la práctica. En esta lección crearemos un microservicio sencillo usando Spring Boot.
Parte 1: Preparación del entorno y herramientas
Primero preparamos el entorno para nuestro microservicio. Para eso usamos Spring Initializr, para generar rápidamente el proyecto inicial.
Paso 1: Crear el proyecto con Spring Initializr
Entramos en Spring Initializr y elegimos los parámetros del proyecto:
- Project: Maven (o Gradle, si eres fan).
- Spring Boot Version: elige la versión actual (por ejemplo, 3.0.0+).
- Dependencies:
- Spring Web — para crear el REST API.
- Spring Data JPA — para trabajar con la base de datos.
- H2 Database — para una base de datos embebida simple (en un proyecto real puedes cambiarla por MySQL, PostgreSQL, etc.).
Rellenamos el resto de parámetros del proyecto, por ejemplo:
- Group:
com.example - Artifact:
orderservice - Name:
OrderService
Después pulsamos "Generate", descargamos el zip y lo descomprimimos.
Paso 2: Importar el proyecto en la IDE
Importa el proyecto en tu IDE favorito (por ejemplo, IntelliJ IDEA o Eclipse). Luego abre el archivo pom.xml y asegúrate de que todas las dependencias se hayan descargado correctamente. Si usas Gradle, revisa el archivo build.gradle.
Parte 2: Desarrollo del microservicio
Crearemos un microservicio para gestionar pedidos (OrderService). Nuestro microservicio expondrá un REST API para realizar operaciones CRUD sobre la entidad Order.
Paso 1: Configurar las entidades y la base de datos
Entidad Order
Creamos el paquete com.example.orderservice.model, y dentro de él la clase Order:
package com.example.orderservice.model;
import jakarta.persistence.*;
import java.time.LocalDateTime;
@Entity
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String product;
private Integer quantity;
private Double price;
private LocalDateTime orderDate;
// Getters and Setters...
// Constructor sin argumentos
public Order() {}
// Constructor con parámetros
public Order(String product, Integer quantity, Double price, LocalDateTime orderDate) {
this.product = product;
this.quantity = quantity;
this.price = price;
this.orderDate = orderDate;
}
}
@Entity, JPA educadamente ignorará tu clase, y la base de datos ni siquiera sabrá de su existencia.
Configuración de la base de datos
En el archivo application.properties (o application.yml) añade la configuración para H2:
spring.datasource.url=jdbc:h2:mem:ordersdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update
Ahora tenemos una base de datos embebida y podemos interactuar con ella vía JPA.
Paso 2: Crear el repository
Añadimos la interfaz del repositorio para trabajar con nuestra entidad.
Crea el paquete com.example.orderservice.repository y dentro crea OrderRepository:
package com.example.orderservice.repository;
import com.example.orderservice.model.Order;
import org.springframework.data.jpa.repository.JpaRepository;
public interface OrderRepository extends JpaRepository<Order, Long> {
}
Con esta interfaz obtenemos todas las operaciones CRUD estándar.
Paso 3: Implementar la lógica de negocio (capa service)
Añadimos la clase service. Crea el paquete com.example.orderservice.service y la clase OrderService:
package com.example.orderservice.service;
import com.example.orderservice.model.Order;
import com.example.orderservice.repository.OrderRepository;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class OrderService {
private final OrderRepository orderRepository;
public OrderService(OrderRepository orderRepository) {
this.orderRepository = orderRepository;
}
public List<Order> getAllOrders() {
return orderRepository.findAll();
}
public Order getOrderById(Long id) {
return orderRepository.findById(id).orElseThrow(() -> new RuntimeException("Order not found"));
}
public Order createOrder(Order order) {
return orderRepository.save(order);
}
public Order updateOrder(Long id, Order updatedOrder) {
Order order = getOrderById(id);
order.setProduct(updatedOrder.getProduct());
order.setQuantity(updatedOrder.getQuantity());
order.setPrice(updatedOrder.getPrice());
return orderRepository.save(order);
}
public void deleteOrder(Long id) {
orderRepository.deleteById(id);
}
}
Paso 4: Implementar el REST API (controller)
Ahora creamos el REST API. Crea el paquete com.example.orderservice.controller y la clase OrderController:
package com.example.orderservice.controller;
import com.example.orderservice.model.Order;
import com.example.orderservice.service.OrderService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/orders")
public class OrderController {
private final OrderService orderService;
public OrderController(OrderService orderService) {
this.orderService = orderService;
}
@GetMapping
public List<Order> getAllOrders() {
return orderService.getAllOrders();
}
@GetMapping("/{id}")
public ResponseEntity<Order> getOrderById(@PathVariable Long id) {
return ResponseEntity.ok(orderService.getOrderById(id));
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public Order createOrder(@RequestBody Order order) {
return orderService.createOrder(order);
}
@PutMapping("/{id}")
public Order updateOrder(@PathVariable Long id, @RequestBody Order order) {
return orderService.updateOrder(id, order);
}
@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void deleteOrder(@PathVariable Long id) {
orderService.deleteOrder(id);
}
}
Parte 3: Pruebas y depuración
Paso 1: Ejecuta la aplicación
Arrancamos OrderServiceApplication — la clase principal de nuestro microservicio:
package com.example.orderservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class OrderServiceApplication {
public static void main(String[] args) {
SpringApplication.run(OrderServiceApplication.class, args);
}
}
Si todo está bien configurado, la aplicación se ejecutará en el puerto 8080.
Paso 2: Probar con Postman o curl
Ejemplos de peticiones:
- GET
/api/orders— obtener todos los pedidos. - POST
/api/orderscon el body:
{
"product": "Laptop",
"quantity": 2,
"price": 1200.00,
"orderDate": "2023-10-01T10:00:00"
}
- PUT
/api/orders/1para actualizar un pedido existente. - DELETE
/api/orders/1para eliminar un pedido.
Parte 4: ¿Qué sigue?
¡Enhorabuena! Hemos creado un microservicio básico para gestionar pedidos. Este ejemplo sencillo se puede ampliar, añadiendo funcionalidades como validación de entrada, manejo de errores, autenticación, o integración con Kafka para una arquitectura basada en eventos. ¡Todo eso nos espera más adelante!
GO TO FULL VERSION