Tutorial: Consultar MongoDB con datos de Spring

Cree consultas derivadas utilizando MongoRepository.

Navegue al directorio src/main/java/com/mongodb/resources en el proyecto spring-data-unlocked y abra la interfaz TransactionRepository. Esta interfaz incluye el siguiente método para buscar transacciones por tipo:

List<Transaction> findByTransactionType(String type);

Spring Data usa el nombre del método para crear una consulta. El prefijo findBy indica a Spring Data que cree una consulta y TransactionType especifica el campo por el que se filtrará.

Puede habilitar el registro de depuración para ver las consultas generadas agregando la siguiente línea a su archivo application.properties:

logging.level.org.springframework.data.mongodb=DEBUG

Cuando ejecuta la consulta findByTransactionType, la consola muestra un resultado similar al siguiente:

2024-10-15T18:30:33.855-03:00 DEBUG 28992
[SpringShop] [nio-8080-exec-6] o.s.data.mongodb.core.MongoTemplate:
find using query: { "transactionType" : "Transfer"} fields: Document{{}} sort: { "transactionType" : "Transfer"} for class: class com.mongodb.Transaction in collection: transactions

La interfaz TransactionRepository también incluye los siguientes métodos para buscar transacciones por monto y eliminar transacciones por tipo:

List<Transaction> findByAmountGreaterThan(double amount);
void deleteByTransactionType(String type);

Cree consultas utilizando la anotación @Query.

El TransactionRepository define un método findByStatus() que utiliza la anotación @Query para buscar transacciones por el valor de su campo status. Este método devuelve solo campos específicos y ordena los resultados.

@Query(
       value= "{ 'status' : ?0 }",
       fields="{ 'createdAt':  1, 'accountDetails' : 1, 'amount' : 1}",
       sort = "{ createdAt:  -1}"
)
List<Transaction> findByStatus(String status);

Los parámetros en la anotación @Query especifican lo siguiente:

• value especifica los criterios de filtro.

• fields define qué campos incluir en los resultados.

• sort ordena los resultados por el valor del campo createdAt en orden descendente.

Para obtener más información sobre la @Query anotación, consulte la documentación de Spring Data MongoDB.

Actualice los datos utilizando la anotación @Update.

La interfaz TransactionRepository incluye un método que combina las anotaciones @Query y @Update para actualizar el estado de una transacción:

@Query("{ '_id' : ?0 }")
@Update("{ '$set' : { 'status' : ?1 } }")
void updateStatus(String id, String status);

La anotación @Query encuentra el documento por ID y la anotación @Update modifica el campo de estado.

Para obtener más información, consulte la documentación de Spring Data MongoDB sobre operaciones de actualización.

Revisar los métodos de canalización de agregación.

La interfaz TransactionRepository incluye un método que utiliza la anotación @Aggregation para calcular el monto total agrupado por tipo de transacción:

@Aggregation(pipeline = {
       "{ '$match': { 'transactionType': ?0 } }",
       "{ '$group': { '_id': '$transactionType', 'amount': { '$sum': '$amount' } } }",
       "{ '$project': { 'amount': 1 } }"
})
List<Transaction> getTotalAmountByTransactionType(String transactionType);

Esta canalización de agregación realiza las siguientes operaciones:

• $match Filtra las transacciones por tipo.

• $group agrupa las transacciones por tipo y suma los importes.

• $project muestra el importe total.

Exportar transacciones erróneas a una nueva colección.

La interfaz TransactionRepository también incluye un método que utiliza la etapa $out para copiar transacciones de error a una nueva colección:

@Aggregation(pipeline = {
       "{ '$match': { 'status': 'error' } }",
       "{ '$project': { '_id': 1, 'amount': 1, 'status': 1, 'description': 1, 'createdAt': 1} }",
       "{ '$out': 'error_transactions' }"
})
void exportErrorTransactions();

Cuando llama a este método, MongoDB crea una nueva colección llamada error_transactions e inserta todos los documentos que tienen un estado de error.

Revise la anotación de búsqueda de texto.

El archivo SearchAggregate.java en el directorio src/main/java/com/mongodb/resources incluye el siguiente código que crea una anotación personalizada que realiza una búsqueda de texto.

import org.springframework.data.mongodb.repository.Aggregation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
@Aggregation(pipeline = {
       "{ '$search': { 'text': { 'query': ?0, 'path': ?1 } } }"
})
@interface SearchAggregate {
}

La interfaz TransactionRepository incluye el siguiente código que utiliza la anotación:

@SearchAggregate
List<Transaction> search(String query, String path);

Implementar paginación.

La interfaz MongoRepository extiende PagingAndSortingRepository, que proporciona compatibilidad con la paginación. Abra la clase TransactionService y agregue el siguiente método:

public Page<Transaction> findPageableTransactions(
       Pageable pageable
) {
   return transactionRepository.findAll(pageable);
}

La clase TransactionController en el directorio src/main/java/com/mongodb/application/web incluye el siguiente método de controlador que acepta parámetros de paginación:

@GetMapping("/pageable")
public PagedModel<Transaction> findAll(@RequestParam(defaultValue = "0") int page,
                                      @RequestParam(defaultValue = "100") int sizePerPage,
                                      @RequestParam(defaultValue = "ID") String sortField,
                                      @RequestParam(defaultValue = "DESC") Sort.Direction sortDirection) {
   Pageable pageable = PageRequest.of(page, sizePerPage, Sort.by(sortDirection, sortField));
   return new PagedModel<>(transactionService.findPageableTransactions(pageable));
}

Llame a este punto final ejecutando el siguiente comando desde su terminal mientras se ejecuta su aplicación:

curl --location 'http://localhost:8080/transactions?page=0&sizePerPage=10&sortField=description&sortDirection=ASC'

Configurar MongoTemplate.

La clase MongoTemplate ofrece mayor flexibilidad que MongoRepository para realizar operaciones en MongoDB. En los siguientes pasos, aprenderá a usar MongoTemplate para realizar operaciones masivas, consultas y agregaciones.

Navegue al directorio src/main/java/com/mongodb/resources para ver la clase de configuración denominada MongoConfig.java, que configura MongoTemplate:

package com.mongodb;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
@Configuration
public class MongoConfig  {
   @Bean
   public MongoClient mongoClient() {
       MongoClientSettings settings = MongoClientSettings.builder()
               .applyConnectionString(new ConnectionString("<your connection string>"))
               .build();
       return MongoClients.create(settings);
   }
   @Bean
   MongoOperations mongoTemplate(MongoClient mongoClient) {
       return new MongoTemplate(mongoClient, "springshop");
   }
}

Revise el modelo de Cliente.

El archivo Customer.java en el directorio src/main/java/com/mongodb/model define el siguiente registro:

package com.mongodb.model;
public record Customer(
       String name,
       String email,
       String accountNumber,
       String phone,
       Address address
) {
   public record Address(
           String street,
           String city
   ) {}
}

Realizar operaciones de inserción masiva.

La clase CustomerService en el directorio src/main/java/com/mongodb/domain/service incluye el siguiente método que inserta varios documentos a la vez:

public int bulkCustomerSample(List<Customer> customerList) {
    if (findAll().isEmpty()) {
        BulkWriteResult result = mongoOperations.bulkOps(BulkOperations.BulkMode.ORDERED, Customer.class)
                .insert(customerList)
                .execute();
        return result.getInsertedCount();
    }
    return 0;
}

El método bulkOps crea una operación masiva que inserta todos los documentos en la lista.

Consultar documentos con MongoTemplate.

La clase CustomerService incluye un método que encuentra un cliente por correo electrónico:

public Customer findCustomerByEmail(String email) {
    return mongoOperations.query(Customer.class)
            .matching(query(where("email").is(email)))
            .one()
            .orElseThrow(() -> new RuntimeException("Customer not found with email: " + email));
}

El método query acepta un objeto Criteria que define el filtro. Puede usar métodos como gt(), lt(), and() y or() para crear consultas complejas.

Para obtener más información, consulte la documentación de la clase Criteria.

Realizar agregaciones con MongoTemplate.

La clase CustomersByCity en el directorio src/main/java/com/mongodb/domain/model contiene el siguiente registro que contiene los resultados de agregación:

public record CustomersByCity(
       String id,
       int total
){}

El archivo CustomerService.java incluye un método que cuenta los clientes por ciudad:

public List<CustomersByCity> totalCustomerByCity() {
    TypedAggregation<Customer> aggregation = newAggregation(Customer.class,
            group("address.city")
                    .count().as("total"),
            Aggregation.sort(Sort.Direction.ASC, "_id"),
            project(Fields.fields("total", "_id")));
    AggregationResults<CustomersByCity> result = mongoOperations.aggregate(aggregation, CustomersByCity.class);
    return result.getMappedResults();
}

Este método agrupa a los clientes por ciudad y cuenta el número de clientes en cada ciudad.

Pon a prueba tus consultas.

Ejecute su aplicación ejecutando la clase SpringShopApplication en su IDE o ejecutando los siguientes comandos desde su terminal:

export MONGODB_URI="<YOUR_CONNECTION_STRING>"
./gradlew bootRun

La aplicación se ejecuta en el puerto 8080. Puede probar sus consultas enviando solicitudes a los puntos finales definidos en los pasos anteriores.

Para obtener más información sobre cómo probar los puntos finales en esta aplicación, consulte el archivo README en el repositorio spring-data-unlocked.