Un microservicio es una pequeña aplicación autocontenida que se enfoca en una única
funcionalidad de negocio. En nuestro caso, crearemos un microservicio que gestionará las
operaciones CRUD de una entidad (por ejemplo, Producto).
Aquí te explico la arquitectura y el proceso paso a paso.
Arquitectura del Microservicio CRUD
Nuestro microservicio tendrá las siguientes capas:
1. Capa de Presentación (Controller): Recibe las peticiones HTTP (GET, POST, PUT,
DELETE) y se encarga de llamar a la capa de servicio. Utilizaremos @RestController
para crear una API REST.
2. Capa de Lógica de Negocio (Service): Contiene la lógica de negocio y las validaciones.
Llama a la capa de datos para interactuar con la base de datos.
3. Capa de Acceso a Datos (Repository): Interactúa directamente con la base de datos.
Usaremos Spring Data JPA para simplificar esta tarea al máximo, sin necesidad de escribir
código SQL manualmente.
4. Base de Datos (MySQL): Almacena los datos.
Paso 1: Configuración del Proyecto en NetBeans
1. Crear un Proyecto Spring Boot:
• Abre Apache NetBeans 26.
• Ve a File > New Project....
• Selecciona Maven > Spring Boot.
• Haz clic en Next.
• Dale un nombre a tu proyecto, por ejemplo, producto-microservicio.
• Haz clic en Next.
• Selección de Dependencias: Aquí está la parte más importante. En la ventana de
dependencias, busca y selecciona las siguientes:
• Spring Web: Para construir APIs REST.
• Spring Data JPA: Para interactuar con la base de datos de manera sencilla.
• MySQL Driver: El conector JDBC para MySQL.
• Lombok: Opcional pero muy recomendable para reducir el código repetitivo
(getters, setters, etc.).
2. Generar el Proyecto: Haz clic en Finish. NetBeans descargará automáticamente todas las
dependencias de Maven.
Paso 2: Configuración de la Base de Datos ([Link])
Una vez que el proyecto se ha creado, ve al archivo
src/main/resources/[Link]. Aquí configurarás la conexión a tu
base de datos MySQL.
Reemplaza el contenido con lo siguiente, ajustando los valores a tu configuración de MySQL.
Properties
# Configuración del servidor
[Link]=8080
# Configuración de la base de datos MySQL
[Link]=jdbc:mysql://localhost:3306/mi_bd_crud?
useSSL=false&serverTimezone=UTC
[Link]=root
[Link]=tu_contraseña_de_mysql
[Link]-class-name=[Link]
# Configuración de JPA/Hibernate
# 'update' crea las tablas si no existen, 'none' no hace nada.
# En producción, se recomienda 'none' o 'validate'.
[Link]-auto=update
[Link]-sql=true
[Link]=[Link].MySQL8Dialect
Nota: Asegúrate de tener una base de datos llamada mi_bd_crud en tu servidor MySQL. Si no la
tienes, créala con una herramienta como MySQL Workbench o desde la línea de comandos.
Paso 3: Crear las Clases del Microservicio
Ahora, crea los paquetes para organizar tu código: entity, repository, service y
controller.
1. Clase de Entidad ([Link])
Esta clase representa la tabla productos en tu base de datos. Usa anotaciones de JPA para el
mapeo.
Crear la clase: En
src/main/java/[Link].producto_microservicio, crea un
nuevo paquete llamado entity y dentro, la clase [Link].
Java
package [Link].producto_microservicio.entity;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link]; // Anotación de Lombok para Getters, Setters, etc.
import [Link];
import [Link];
@Entity // Le dice a JPA que esta es una entidad mapeada a una tabla
@Data // Genera getters, setters, toString, etc.
@NoArgsConstructor // Genera un constructor sin argumentos
@AllArgsConstructor // Genera un constructor con todos los argumentos
public class Producto {
@Id // Marca este campo como la clave primaria
@GeneratedValue(strategy = [Link]) // Generación automática
del ID
private Long id;
private String nombre;
private Double precio;
private Integer stock;
}
2. Repositorio (Interface [Link])
Esta es la capa de acceso a datos. Con Spring Data JPA, solo necesitas definir una interfaz. Spring
se encargará de implementar los métodos CRUD por ti.
Crear la interfaz: En el paquete repository, crea la interfaz [Link].
Java
package [Link].producto_microservicio.repository;
import [Link].producto_microservicio.[Link];
import [Link];
import [Link];
@Repository // Marca esta interfaz como un componente de repositorio
public interface ProductoRepository extends JpaRepository<Producto, Long> {
// JpaRepository<Tipo de Entidad, Tipo de la clave primaria>
// Con esta línea, ya tienes métodos CRUD listos: save(), findById(),
findAll(), deleteById(), etc.
}
3. Capa de Servicio (Interface y Clase)
Esta capa contiene la lógica de negocio.
Crear la interfaz [Link]:
Java
package [Link].producto_microservicio.service;
import [Link].producto_microservicio.[Link];
import [Link];
import [Link];
public interface ProductoService {
List<Producto> obtenerTodos();
Optional<Producto> obtenerPorId(Long id);
Producto guardarProducto(Producto producto);
Producto actualizarProducto(Long id, Producto producto);
void eliminarProducto(Long id);
}
Crear la implementación [Link]:
Java
package [Link].producto_microservicio.service;
import [Link].producto_microservicio.[Link];
import
[Link].producto_microservicio.[Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Service // Marca esta clase como un servicio de Spring
public class ProductoServiceImpl implements ProductoService {
@Autowired // Inyecta automáticamente la instancia del repositorio
private ProductoRepository productoRepository;
@Override
public List<Producto> obtenerTodos() {
return [Link](); // Método de JpaRepository
}
@Override
public Optional<Producto> obtenerPorId(Long id) {
return [Link](id); // Método de JpaRepository
}
@Override
public Producto guardarProducto(Producto producto) {
return [Link](producto); // Método de JpaRepository
}
@Override
public Producto actualizarProducto(Long id, Producto producto) {
// Lógica para actualizar:
// 1. Verificar si el producto existe
// 2. Si existe, actualizar sus campos y guardar
// 3. Si no existe, puedes lanzar una excepción
return [Link](id)
.map(productoExistente -> {
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
return [Link](productoExistente);
})
.orElse(null); // O podrías lanzar una excepción
}
@Override
public void eliminarProducto(Long id) {
[Link](id); // Método de JpaRepository
}
}
4. Controlador REST ([Link])
Esta es la capa de la API que expone los endpoints HTTP.
Crear la clase: En el paquete controller, crea [Link].
Java
package [Link].producto_microservicio.controller;
import [Link].producto_microservicio.[Link];
import [Link].producto_microservicio.[Link];
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link];
@RestController // Indica que esta clase es un controlador REST
@RequestMapping("/api/productos") // Ruta base para todos los endpoints
public class ProductoController {
@Autowired
private ProductoService productoService;
// --- READ (Leer todos) ---
// GET [Link]
@GetMapping
public List<Producto> obtenerTodos() {
return [Link]();
}
// --- READ (Leer por ID) ---
// GET [Link]
@GetMapping("/{id}")
public ResponseEntity<Producto> obtenerPorId(@PathVariable Long id) {
return [Link](id)
.map(ResponseEntity::ok) // Si se encuentra, retorna 200 OK
.orElse([Link]().build()); // Si no, retorna 404
Not Found
}
// --- CREATE (Crear) ---
// POST [Link]
@PostMapping
@ResponseStatus([Link]) // Retorna 201 Created
public Producto crearProducto(@RequestBody Producto producto) {
return [Link](producto);
}
// --- UPDATE (Actualizar) ---
// PUT [Link]
@PutMapping("/{id}")
public ResponseEntity<Producto> actualizarProducto(@PathVariable Long id,
@RequestBody Producto producto) {
Producto productoActualizado = [Link](id,
producto);
if (productoActualizado != null) {
return [Link](productoActualizado); // Retorna 200 OK
}
return [Link]().build(); // Retorna 404 Not Found
}
// --- DELETE (Eliminar) ---
// DELETE [Link]
@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT) // Retorna 204 No Content
public void eliminarProducto(@PathVariable Long id) {
[Link](id);
}
}
Paso 4: Ejecutar y Probar el Microservicio
1. Ejecutar la aplicación: En NetBeans, haz clic derecho en el archivo principal de tu
proyecto (el que tiene la anotación @SpringBootApplication) y selecciona Run
File o Run Project.
2. Verificar la conexión: La consola de NetBeans mostrará los logs de Spring Boot y
Hibernate. Si la conexión a MySQL es exitosa, verás mensajes como "Connected to
database".
3. Usar una herramienta de cliente REST: Para probar tu API, necesitarás una herramienta
como Postman, Insomnia o la extensión REST Client en Visual Studio Code.
Ejemplos de Peticiones HTTP para probar el CRUD:
• Crear (POST):
• URL: POST [Link]
• Body (JSON):
JSON
{
"nombre": "Laptop Gamer",
"precio": 1500.00,
"stock": 10
}
• Leer todos (GET):
• URL: GET [Link]
• Leer por ID (GET):
• URL: GET [Link] (cambia el ID)
• Actualizar (PUT):
• URL: PUT [Link]
• Body (JSON):
JSON
{
"nombre": "Laptop Gamer Pro",
"precio": 1800.00,
"stock": 8
}
• Eliminar (DELETE):
• URL: DELETE [Link]
¡Y listo! Con estos pasos, has creado un microservicio REST completo en Java con Spring Boot
y MySQL usando Apache NetBeans 26. Este microservicio está listo para ser consumido por
cualquier frontend (como una aplicación web con Thymeleaf, un frontend de React, o una app
móvil).
