La integración de MongoDB con Spring Framwork ofrece abstracciones potentes para la manipulación de datos. Principalmente, existen dos aproximaciones: el uso de MongoTemplate, que requiere una escritura manual de las operaciones, y MongoRepository, que proporciona una interfaz de alto nivel para realizar operaciones CRUD y consultas complejas de manera casi automática.

1. Definición del Modelo de Datos

Para comenzar, definimos una entidad que represente el documento en la base de datos. En este ejemplo, utilizaremos una clase denominada Usuario.

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import java.io.Serializable;

@Document(collection = "usuarios")
public class Usuario implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Id
    private String uid;
    private String nombrecompleto;
    private int años;

    // Getters y Setters
}

2. Creación del Repositorio

Al extender de MongoRepository, obtenemos acceso inmediato a métodos estándar sin necesidad de implementarlos.

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UsuarioRepository extends MongoRepository<Usuario, String> {
    // Definiremos métodos personalizados aquí más adelante
}

3. Implementación de Consultas en la Capa de Servicio

Inyectamos el repositorio en nuestra lógica de negocio para ejecutar las operaciones.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

@Service
public class GestionUsuariosService {
    @Autowired
    private UsuarioRepository repositorio;

    // 1. Obtener todos los registros
    public List<Usuario> listarTodo() {
        return repositorio.findAll();
    }

    // 2. Paginación de resultados
    // Nota: El índice de páginas en Spring Data comienza en 0
    public Page<Usuario> listarConPaginacion(int nroPagina, int tamaño) {
        PageRequest configuracionPagina = PageRequest.of(nroPagina, tamaño);
        return repositorio.findAll(configuracionPagina);
    }

    // 3. Conteo total de documentos
    public long obtenerTotal() {
        return repositorio.count();
    }
}

4. Consultas Derivadas por Nombre de Método

Spring Data permite generar consultas automáticamente analizando el nombre del método en la interfaz del repositorio.

En el Repositorio:

// Búsqueda exacta
Usuario findByNombrecompleto(String nombre);

// Búsqueda parcial (Like)
List<Usuario> findByNombrecompletoLike(String fragmento);

// Búsqueda parcial con paginación
Page<Usuario> findByNombrecompletoLike(String fragmento, Pageable pageable);

5. Uso de Proyecciones y la anotación @Query

Si necesitamos filtrar los campos devueltos para optimizar el rendimiento (por ejemplo, omitir la edad y solo traer el nombre), utilizamos la anotación @Query.

En el Repositorio:

import org.springframework.data.mongodb.repository.Query;

// value define el filtro, fields define qué columnas retornar (1 para incluir)
@Query(value = "{'nombrecompleto': ?0}", fields = "{'nombrecompleto': 1, 'uid': 1}")
Page<Usuario> buscarSoloNombres(String nombre, Pageable pageable);

Para buscar todos los registros donde un campo no sea nulo y aplicar proyecciones:

@Query(value = "{'_id': {'$ne': null}}", fields = "{'nombrecompleto': 1}")
Page<Usuario> recuperarNombresExistentes(Pageable pageable);

6. Operadores Lógicos y de Comparación

A continuación se presentan ejemplos de cómo estructurar métodos en el repositorio para diferentes condiciones lógicas de MongoDB:

• Mayor que (Greater Than): findByAñosGreaterThan(int limite)
  Equivalente BSON: {"años": {"$gt": limite}}
• Menor que (Less Than): findByAñosLessThan(int limite)
  Equivaletne BSON: {"años": {"$lt": limite}}
• Rangos (Between): findByAñosBetween(int min, int max)
  Equivalente BSON: {"años": {"$gt": min, "$lt": max}}
• Negación (Not): findByNombrecompletoNot(String nombre)
  Equivalente BSON: {"nombrecompleto": {"$ne": nombre}}
• Geolocalización (Near): findByUbicacionNear(Point punto)
  Equivalente BSON: {"ubicacion": {"$near": [x, y]}}

Esta estructura permite una gestión robusta de los datos en MongoDB sin la verbosidad de escribir consultas manuales, delegando la responsabilidad de la persistencia a la enfraestructura de Spring Data.