Antes de meternos de lleno en el código, refresquemos qué es CRUD. CRUD — es una abreviatura que representa cuatro operaciones principales al trabajar con datos en una base:
- Create (creación): añadir nuevos registros a la base de datos.
- Read (lectura): obtener datos de la base.
- Update (actualización): modificar registros ya existentes.
- Delete (eliminación): borrar registros de la base.
Ahora pasemos a la implementación de estas operaciones. Usaremos las entidades y repositorios que ya creaste antes. Si te perdiste algo, ¡es el momento de "sacar tu código del bolsillo"!
Crear una entidad de prueba
Tomemos, por ejemplo, una entidad sencilla Product:
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Double price;
// Constructores, getters y setters
public Product() {}
public Product(String name, Double price) {
this.name = name;
this.price = price;
}
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 Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
}
¡La entidad está lista! Ahora vamos al repositorio para trabajar con la base e implementar las cuatro operaciones CRUD.
Repositorio para trabajar con la base de datos
Anteriormente has conectado JpaRepository para trabajar con bases de datos. Aquí tienes un ejemplo de repositorio para nuestro Product:
import org.springframework.data.jpa.repository.JpaRepository;
public interface ProductRepository extends JpaRepository<Product, Long> {
// Los métodos básicos de CRUD ya están integrados
}
Ten en cuenta que heredamos la interfaz de JpaRepository, lo que significa que todos los métodos CRUD ya están disponibles. ¡Pero vamos a ver exactamente cómo usarlos!
Implementación de las operaciones CRUD
Vamos a lo más interesante. Creemos un service y un controller para ejecutar las operaciones CRUD.
1. Creación (Create)
Guardar un nuevo objeto en la base se hace con el método save().
Ejemplo de método para crear un producto en el service:
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
@Service
public class ProductService {
private final ProductRepository productRepository;
@Autowired
public ProductService(ProductRepository productRepository) {
this.productRepository = productRepository;
}
public Product createProduct(String name, Double price) {
Product product = new Product(name, price);
return productRepository.save(product);
}
}
Ahora añadimos el método en el controller:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/products")
public class ProductController {
private final ProductService productService;
@Autowired
public ProductController(ProductService productService) {
this.productService = productService;
}
@PostMapping
public Product createProduct(@RequestBody Product product) {
return productService.createProduct(product.getName(), product.getPrice());
}
}
Cuando envíes una petición HTTP POST a /products con un JSON en el body, será fácil lanzar esta operación.
Ejemplo de petición:
POST /products HTTP/1.1
Content-Type: application/json
{
"name": "Portátil",
"price": 1200.00
}
Tras ejecutar esa petición, ¡el nuevo producto se añadirá a la base de datos!
2. Lectura (Read)
Para obtener datos de la base puedes usar findById() o findAll().
Ejemplo en el service:
import java.util.Optional;
import java.util.List;
public List<Product> getAllProducts() {
return productRepository.findAll();
}
public Optional<Product> getProductById(Long id) {
return productRepository.findById(id);
}
Ahora implementamos los métodos en el controller:
@GetMapping
public List<Product> getAllProducts() {
return productService.getAllProducts();
}
@GetMapping("/{id}")
public Product getProductById(@PathVariable Long id) {
return productService.getProductById(id)
.orElseThrow(() -> new RuntimeException("Product not found"));
}
Estos endpoints hacen:
GET /products: devuelve la lista de todos los productos.GET /products/{id}: devuelve el producto por su ID.
3. Actualización (Update)
La actualización se realiza con el método save(). Si el objeto con el ID dado existe, se actualiza.
Primero añadimos el método de actualización en el service:
public Product updateProduct(Long id, String name, Double price) {
Product product = productRepository.findById(id)
.orElseThrow(() -> new RuntimeException("Product not found"));
product.setName(name);
product.setPrice(price);
return productRepository.save(product);
}
Y lo añadimos en el controller:
@PutMapping("/{id}")
public Product updateProduct(@PathVariable Long id, @RequestBody Product updatedProduct) {
return productService.updateProduct(id, updatedProduct.getName(), updatedProduct.getPrice());
}
Ejemplo de petición:
PUT /products/1 HTTP/1.1
Content-Type: application/json
{
"name": "Portátil actualizado",
"price": 1500.00
}
Si el producto con ID 1 existe, se actualizará.
4. Eliminación (Delete)
La eliminación se hace con deleteById().
Método en el service:
public void deleteProduct(Long id) {
productRepository.deleteById(id);
}
Método en el controller:
@DeleteMapping("/{id}")
public void deleteProduct(@PathVariable Long id) {
productService.deleteProduct(id);
}
Ahora envía la petición:
DELETE /products/1 HTTP/1.1
Esta petición borrará el producto con ID 1.
Manejo de errores
Al trabajar con bases de datos a menudo aparecen errores como EntityNotFoundException. Asegúrate de manejarlos correctamente, por ejemplo usando excepciones propias o handlers globales.
Aplicación práctica
En aplicaciones reales las operaciones CRUD son la base de cualquier sistema que maneje datos. Desde la gestión de usuarios y pedidos hasta libros en una biblioteca — estos métodos se usan por todas partes. Además, en entrevistas suelen preguntar sobre los métodos CRUD principales y pedir que demuestres código relacionado.
Ahora las operaciones CRUD ya no son un misterio para ti. Así que, ¡haz que las bases de datos sean tus aliadas!
GO TO FULL VERSION