Spring Data: Tutorial de MongoDB

    Visión general

    Datos de Spring es un proyecto general que contiene muchos submódulos, cada uno específico para una base de datos en particular. En este artículo, cubriremos Spring Data MongoDB mediante la creación de una aplicación que almacena y recupera datos de MongoDB, una base de datos NO-SQL basada en documentos.

    Si desea leer más sobre Spring Data, lo hemos cubierto en detalle en – Guía para Spring Data JPA.

    MongoDB

    MongoDB es una base de datos NoSQL orientada a documentos que almacena documentos similares a JSON con esquemas dinámicos. Se utiliza comúnmente para el almacenamiento de datos de gran volumen.

    Antes de seguir adelante, sería bueno conocer algunos de los términos de la base de datos NoSQL. Tenga en cuenta que estos términos no son exactamente uno a uno en comparación con las bases de datos SQL relacionales:

    • Base de datos: Es un contenedor de colecciones y puede considerarse similar a una base de datos RDBMS, que es un contenedor de tablas.
    • Colección: Es equivalente a Tablas en RDBMS, pero a diferencia de una colección, tiene un esquema dinámico. Existe una colección dentro de una base de datos.
    • Documento: Es un registro único en una colección de MongoDB. Se puede considerar como una fila en RDBMS.
    • Campo: Un documento tiene cero o más campos. Es como una columna RDBMS que tiene un par clave-valor.

    Para configurar el servidor MongoDB en su máquina local, puede descargar el archivo instalable aquí según su sistema operativo. A continuación, también puede descargar una herramienta como Brújula para una buena GUI para interactuar con su servidor.

    Otra opción y la que usaremos es Atlas de MongoDB, que es una base de datos en la nube como servicio. Después de registrarse, inicie sesión y cree un clúster con el nivel gratuito:

    Para conectarnos a nuestro clúster, tenemos que crear un usuario:

    Creemos ahora nuestra base de datos y colección:

    Ahora estamos configurados para conectarnos a nuestra colección usando nuestra aplicación Spring.

    Proyecto Spring Data MongoDB

    Preparar

    La mejor manera de comenzar con un proyecto esqueleto es visitar Spring Initializr. Seleccione su versión preferida de Spring Boot y agregue el Web y MongoDB dependencias:

    Después de esto, generelo como un proyecto de Maven y ¡listo!

    Definición de una colección

    Primero, definamos nuestra colección Candidate clase modelo:

    @Document(collection = "candidate")
    public class Candidate {
        @Id
        private String id;
    
        private String name;
    
        private double exp;
    
        @Indexed(unique = true)
        private String email;
    
        // getters and setters
    }
    

    Ahora echemos un vistazo a estas anotaciones:

    • @Documento: Esto marca la clase como un objeto de dominio que se conservará en la base de datos. El nombre de colección predeterminado que se utiliza es el nombre de la clase (primer carácter en minúsculas). Podemos mapear a una colección diferente en la base de datos usando el collection atributo de la anotación.
    • @Carné de identidad: Esto marca el campo utilizado con fines de identidad.
    • @Indexed (único = verdadero): Se aplica al campo que se indexará con una restricción de único.

    Definición de repositorio

    Creamos un repositorio haciendo una interfaz:

    public interface CandidateRepository extends MongoRepository<Candidate, String> {}
    

    CandidateRepository extiende el MongoRepository interfaz y enchufa el tipo de datos del documento con el que estamos trabajando, es decir Candidate y String respectivamente.

    Esto nos dará acceso a todas las operaciones CRUD en torno a la colección MongoDB.

    Configuración de la conexión

    Para configurar una conexión adecuada, necesitamos definir las propiedades de la conexión en application.properties:

    spring.data.mongodb.uri=mongodb+srv://<USERNAME>:<PASSWORD>@<ClUSTER-NAME>-<INSTANCE-ID>/<DATABASE-NAME>?retryWrites=true
    

    Puede obtener estos valores directamente desde la interfaz de usuario de MongoDB Atlas:

    Nota: Si su contraseña contiene caracteres especiales, debe estar codificada como URL.

    De forma predeterminada, su clúster está protegido para no recibir solicitudes de ninguna IP de cliente. Necesitamos permitir que nuestra IP pueda conectarse a este clúster a través de una lista blanca de IP:

    Definición del controlador

    Ahora, usemos nuestro repositorio en nuestro CandidateController mediante el @Autowired anotación:

    @RestController
    @RequestMapping("/candidate")
    public class CandidateController {
    
        @Autowired
        private CandidateRepository candidateRepository;
    

    Operaciones CRUD simples

    Insertar

    Vamos a crear un POST mapeo que insertará datos en nuestro MongoDB:

    @PostMapping
    @ResponseStatus(code = HttpStatus.CREATED)
    public Candidate add(@RequestBody Candidate candidate) {
        return candidateRepository.save(candidate);
    }
    

    Usamos el save() método en el candidateRepository objeto. los Candidate el objeto es capturado por @RequestBody y se utiliza directamente en el save() método.

    Si intentamos usar la misma ID de correo electrónico nuevamente, obtendremos un error de clave duplicada:

    También podemos comprobar el estado de nuestra colección en Atlas:

    Leer

    Creemos un par de GET mapeos para recuperar nuestros registros.

    @GetMapping
    public List<Candidate> getAll() {
        return candidateRepository.findAll();
    }
    
    @GetMapping(value = "/{id}")
    public Candidate getOne(@PathVariable String id) {
        return candidateRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException());
    }
    

    findAll() devolverá todos los registros en nuestra base de datos, mientras que el findById() El método devolverá un único registro basado en la ID pasada.

    Si el registro no está presente, throws una excepción de tiempo de ejecución personalizada. ResourceNotFoundException es una clase personalizada que regresa 404 estado si se lanza:

    @ResponseStatus(value = HttpStatus.NOT_FOUND)
    public class ResourceNotFoundException extends RuntimeException {
        public ResourceNotFoundException() {
        }
    }
    

    Si desea leer más sobre esto, lo hemos cubierto en detalle en – Manejo de excepciones en Spring.

    Actualizar

    Ahora, para actualizar un registro en particular, usaremos un PUT cartografía:

    @PutMapping(value = "/{id}")
    public Candidate update(@PathVariable String id, @RequestBody Candidate updatedCandidate) {
        Candidate candidate = candidateRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException());
        candidate.setName(updatedCandidate.getName());
        candidate.setExp(updatedCandidate.getExp());
        candidate.setEmail(updatedCandidate.getEmail());
        return candidateRepository.save(candidate);
    }
    

    Primero comprobamos si el Candidate con lo dado id está presente o no. Si no, devolvemos un 404 estado, de lo contrario, actualizamos todo el objeto y lo guardamos usando el save() método:

    Eliminar

    Ahora, eliminemos un registro en particular mediante la DELETE cartografía:

    @DeleteMapping(value = "/{id}")
    @ResponseStatus(code = HttpStatus.ACCEPTED)
    public void delete(@PathVariable String id) {
        Candidate candidate = candidateRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException());
        candidateRepository.delete(candidate);
    }
    

    Usamos el delete() método en el candidateRepository para borrar la entrada:

    Métodos de consulta personalizados

    Podemos agregar algunos métodos a nuestro CandidateRepository para tener alguna funcionalidad adicional basada en nuestros requisitos comerciales:

    public interface CandidateRepository extends MongoRepository<Candidate, String> {
    
        Optional<Candidate> findByEmail(String email);
    
        List<Candidate> findByExpGreaterThanEqual(double exp);
    
        List<Candidate> findByExpBetween(double from, double to);
    }
    

    Arriba, agregamos la funcionalidad de búsqueda basada en el correo electrónico y la experiencia. Todo lo que tenemos que hacer es seguir una convención de nomenclatura establecida por Datos de Spring.

    Después de la findBy() método escribimos el nombre del atributo en caso de camello, seguido de cualquier otra restricción que queramos aplicar. Los argumentos del método deben coincidir con la expectativa de la cláusula where. Spring Data creará consultas reales para usted durante el inicio de la aplicación utilizando esta interfaz.

    Usemos esto en nuestro controlador:

    @GetMapping("/searchByEmail")
    public Candidate searchByEmail(@RequestParam(name = "email") String email) {
        return candidateRepository.findByEmail(email)
            .orElseThrow(() -> new ResourceNotFoundException());
    
    }
    
    @GetMapping("/searchByExp")
    public List<Candidate> searchByExp(@RequestParam(name = "expFrom") Double expFrom, @RequestParam(name = "expTo", required = false) Double expTo) {
        List<Candidate> result = new ArrayList<>();
        if (expTo != null) {
            result = candidateRepository.findByExpBetween(expFrom, expTo);
        } else {
            result = candidateRepository.findByExpGreaterThanEqual(expFrom);
        }
        return result;
    }
    

    Conclusión

    En este artículo, hemos cubierto cómo usar Spring Data MongoDB para conectarse a un servidor MongoDB. Primero creamos un servidor MongoDB en la nube usando MongoDB Atlas y luego usamos Spring Data para conectarnos a él. Después de eso, realizamos una operación CRUD simple y escribimos algunas consultas personalizadas.

    Como siempre, el código de los ejemplos utilizados en este artículo se puede encontrar en Github.

    Rate this post
    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *