Vamos a poner en práctica lo aprendido y crear un REST API para trabajar con entidades.
Plan paso a paso para crear el REST API
En esta lección crearemos un REST API para gestionar la entidad "Usuario" (User). Empezaremos creando un proyecto Spring Boot y paso a paso implementaremos un API CRUD (Create, Read, Update, Delete).
1. Crear proyecto Spring Boot
Para empezar necesitaremos un nuevo proyecto Spring Boot.
Usamos Spring Initializr:
- Ve a Spring Initializr.
- Indica los siguientes parámetros:
- Project: Maven
- Language: Java
- Spring Boot: 2.x.x (o más reciente)
- Dependencies: Spring Web, Spring Data JPA, H2 Database (u otra), Lombok (opcional, pero útil).
- Descarga y descomprime el proyecto.
2. Configuración de application.properties
Primero configuramos la base de datos. En el archivo src/main/resources/application.properties indica los parámetros para conectar con H2 Database:
# Configuración H2 Database
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
Usamos H2 — una base de datos embebida para facilitar el desarrollo. Si quieres usar otra base de datos, por ejemplo PostgreSQL, tendrás que hacer los cambios correspondientes.
3. Crear la entidad User
Es hora de ponerse manos a la obra. Primero definimos la entidad User, que representará al usuario en nuestro sistema.
package com.example.demo.entity;
import jakarta.persistence.*;
import lombok.Data;
@Data // Anotación de Lombok para la generación automática de getters/setters
@Entity // Marcamos la clase como entidad JPA
@Table(name = "users") // Indicamos el nombre de la tabla
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY) // Generación automática del ID
private Long id;
@Column(nullable = false) // El campo no puede estar vacío
private String name;
@Column(nullable = false, unique = true) // Email único
private String email;
@Column(nullable = false)
private Integer age;
}
4. Crear el repositorio JPA
Ahora creamos el repositorio para interactuar con la base de datos.
package com.example.demo.repository;
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
// JpaRepository proporciona métodos listos para trabajar con la BD
public interface UserRepository extends JpaRepository<User, Long> {
}
5. Crear el controlador REST
Ahora viene lo más interesante — la implementación del REST API. Crearemos un controlador que gestione las operaciones CRUD para la entidad User.
Ejemplo de código:
package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController // Marcamos la clase como REST-controller
@RequestMapping("/api/users") // Ruta base para todos los endpoints
public class UserController {
private final UserRepository userRepository;
// Inyectamos la dependencia vía constructor
public UserController(UserRepository userRepository) {
this.userRepository = userRepository;
}
// Obtener todos los usuarios (GET /api/users)
@GetMapping
public List<User> getAllUsers() {
return userRepository.findAll();
}
// Obtener un usuario por ID (GET /api/users/{id})
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
return userRepository.findById(id)
.map(ResponseEntity::ok) // Si se encuentra el usuario
.orElse(ResponseEntity.notFound().build()); // Si no se encuentra
}
// Crear un nuevo usuario (POST /api/users)
@PostMapping
public User createUser(@RequestBody User user) {
return userRepository.save(user);
}
// Actualizar usuario existente (PUT /api/users/{id})
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
return userRepository.findById(id)
.map(user -> {
user.setName(updatedUser.getName());
user.setEmail(updatedUser.getEmail());
user.setAge(updatedUser.getAge());
return ResponseEntity.ok(userRepository.save(user));
})
.orElse(ResponseEntity.notFound().build());
}
// Eliminar usuario (DELETE /api/users/{id})
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
return userRepository.findById(id)
.map(user -> {
userRepository.delete(user);
return ResponseEntity.noContent().build();
})
.orElse(ResponseEntity.notFound().build());
}
}
ResponseEntity para que el cliente reciba el código de estado HTTP correcto (por ejemplo, 404 si no se encuentra el usuario).
6. Probar el API
Ahora vamos a probar nuestro API. Puedes usar una herramienta como Postman para enviar peticiones.
Ejemplos de peticiones:
- GET /api/users — obtener todos los usuarios.
- POST /api/users — crear usuario. Ejemplo del body de la petición:
{ "name": "Ivan Ivanov", "email": "ivan@example.com", "age": 25 } - GET /api/users/1 — obtener el usuario con ID = 1.
- PUT /api/users/1 — actualizar usuario. Ejemplo del body de la petición:
{ "name": "Ivan Petrov", "email": "petrov@example.com", "age": 30 } - DELETE /api/users/1 — eliminar el usuario con ID = 1.
7. Posibles errores y cómo resolverlos
Problema: el campo email no es único
Si intentas añadir dos usuarios con el mismo email, obtendrás un error de la base de datos. Para evitarlo, puedes añadir preprocesamiento de los datos (por ejemplo, comprobar si el email ya existe antes de crear al usuario).
Problema: validación
Ahora mismo los datos no se validan. Por ejemplo, se podría crear un usuario con el nombre vacío. Lo arreglaremos más adelante usando la anotación @Valid.
Problema: errores de serialización
Si un objeto tiene referencias a otras entidades con dependencias cíclicas, Jackson puede lanzar un error. Solución: usar la anotación @JsonIgnore (volveremos a esto en el futuro).
8. Aplicación en proyectos reales
El REST API creado en esta lección es la base de cualquier aplicación moderna. Podrás usar este enfoque para gestionar entidades como productos, pedidos, empleados y mucho más. Estas habilidades son necesarias para trabajar como desarrollador Java, especialmente en aplicaciones web y microservicios.
Ahora sabes cómo crear un REST API "desde cero". En la siguiente lección veremos cómo diseñar correctamente los URI y trabajar con recursos, para que tu API sea cómoda y profesional.
GO TO FULL VERSION