Mejora el Rendimiento Agrupando Inserciones con JPA

/ JPA, Spring Data JPA / Por

Mejora del Rendimiento en Java: ¿Cómo Agrupar Múltiples Inserciones en la Base de Datos Usando Spring Data JPA?

1. Overview

Al interactuar con bases de datos, todos sabemos que realizar consultas puede ser costoso en términos de rendimiento. Sin embargo, hay formas de mejorar este rendimiento mediante la agrupación de múltiples inserciones en una única operación. En este tutorial, analizaremos cómo llevar a cabo esta tarea utilizando Spring Data JPA, una potente biblioteca que simplifica la interacción de aplicaciones Java con bases de datos.

A medida que avanzamos en este artículo, cubriremos la creación de una entidad de cliente, la configuración de un repositorio y la implementación de un controlador REST que aproveche la capacidad de agrupamiento de inserciones de Spring Data JPA.

2. Spring JPA Repository

Creación de la Entidad

Primero, necesitamos definir una entidad simple. En este caso, llamaremos a nuestra entidad Customer. A continuación, se muestra el código que define la entidad, que consiste en un identificador único y los nombres del cliente:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String firstName;
    private String lastName;

    // Constructor, getters y setters
    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public Long getId() {
        return id;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }
}

Creación del Repositorio

A continuación, necesitamos establecer nuestra interfaz de repositorio para la entidad Customer. Utilizaremos CrudRepository, que proporciona métodos CRUD básicos. Observe que, además de los métodos estándar, esta interfaz expone un método saveAll que nos permitirá agrupar varias inserciones en una sola operación.

import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository {
}

Controlador REST

Ahora, implementemos un controlador que maneje las solicitudes para insertar nuevos clientes. Creamos un controlador REST con un método insertCustomers que utiliza el repositorio para guardar una lista de clientes. Aquí está el código:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.List;

@RestController
public class CustomerController {   

    @Autowired
    CustomerRepository customerRepository;   

    @PostMapping("/customers")
    public ResponseEntity<String> insertCustomers() {        
        Customer c1 = new Customer("James", "Gosling");
        Customer c2 = new Customer("Doug", "Lea");
        Customer c3 = new Customer("Martin", "Fowler");
        Customer c4 = new Customer("Brian", "Goetz");
        List<Customer> customers = Arrays.asList(c1, c2, c3, c4);
        customerRepository.saveAll(customers);
        return ResponseEntity.created("/customers").build();
    }
}

3. Testing Our Endpoint

Para asegurarnos de que nuestro código funciona correctamente, usaremos la clase MockMvc para probar el endpoint de inserciones de cliente. A continuación, se incluye el código de prueba que ejecuta una solicitud POST al endpoint y verifica que el estado de la respuesta es 201 Created:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class CustomerControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test 
    public void whenInsertingCustomers_thenCustomersAreCreated() throws Exception {
        this.mockMvc.perform(post("/customers"))
          .andExpect(status().isCreated());
    }
}

4. Are We Sure We’re Batching?

A continuación, realizaremos algunas configuraciones adicionales para verificar que realmente estamos agrupando las inserciones. Es importante considerar que la agrupación no está habilitada por defecto en algunos casos, como cuando utilizamos la generación automática de identificadores.

Verificando Configuraciones

Primero, debemos activar la generación de estadísticas de Hibernate. Agregue lo siguiente en su archivo application.properties:

spring.jpa.properties.hibernate.generate_statistics=true

Cuando corremos la prueba, deberíamos obtener estadísticas que indican cómo se realizaron las inserciones. Se espera un resultado similar a este:

11232586 nanoseconds spent preparing 4 JDBC statements;
4076610 nanoseconds spent executing 4 JDBC statements;
0 nanoseconds spent executing 0 JDBC batches;

Como podemos ver, aunque hemos creado cuatro clientes, ninguno de ellos se procesó dentro de un lote.

Activando la Agrupación

El problema se debe a que la agrupación se encuentra desactivada por defecto en algunas configuraciones. Para habilitar la agrupación, agregue lo siguiente a su application.properties:

spring.jpa.properties.hibernate.jdbc.batch_size=4
spring.jpa.properties.hibernate.order_inserts=true
  • hibernate.jdbc.batch_size: Esta propiedad indica a Hibernate que agrupe las inserciones en lotes de cuatro.
  • hibernate.order_inserts: Esta propiedad optimiza la agrupación al agrupar las inserciones por entidad.

Ejecución de las Pruebas Nuevamente

Después de aplicar estos cambios, si ejecutamos la prueba nuevamente, deberíamos ver que las inserciones ahora se realizan de manera agrupada:

16577314 nanoseconds spent preparing 4 JDBC statements;
2207548 nanoseconds spent executing 4 JDBC statements;
2003005 nanoseconds spent executing 1 JDBC batches;

Aquí se muestra claramente que las inserciones han sido agrupadas correctamente.

5. Conclusion

Aprovechar la capacidad de agrupar inserciones en base de datos usando Spring Data JPA puede resultar en incrementos significativos en el rendimiento, especialmente cuando se trabaja con grandes volúmenes de datos. Sin embargo, es crucial recordar que la agrupación está desactivada en algunas configuraciones por defecto, y debemos estar atentos a esto antes de implementar nuestras soluciones en producción.

Consejos Prácticos para Programadores

  • Habilita la agrupación: Siempre verifique y habilite la agrupación de inserciones al trabajar con Hibernate.
  • Monitorea el rendimiento: Utilize las estadísticas generadas por Hibernate para verificar que la agrupación está ocurriendo como se espera.
  • Conciencia de configuraciones: Tenga en cuenta que situaciones como la auto-generación de identificación pueden afectar la funcionalidad de agrupamiento.
  • Pruebas exhaustivas: Realice pruebas exhaustivas para asegurarse de que todas las configuraciones estén funcionando como se espera.

Siguiendo estas prácticas, mejorará significativamente la eficiencia y rendimiento de las interacciones de su aplicación con la base de datos.

Si deseas aprender más sobre JPA, consulta el tutorial de Spring Data JPA.