Usar la base de datos NoSQL MongoDB con Java

Escrito por el 04/06/2017.
java planeta-codigo programacion
Enlace permanente Comentarios

MongoDB

Java

En un artículo anterior hacía una pequeña introducción a la base de datos NoSQL MongoDB comentando sus características, como empezar a usarla con Docker y como lanzar algunos comandos para crear bases de datos y colecciones junto las operaciones básicas de inserción, actualización, eliminación y búsquedas con consultas desde la shell que ofrece MongoDB para esta base de datos que guarda documentos.

La shell sirve para hacer estas consultas pero el caso de uso principal es usarlo desde una aplicación con alguno de los lenguajes de programación para los que se proporciona un controlador. MongoDB se puede usar desde cualquiera de los lenguajes de programación más populares entre ellos Java. En este artículo muestro con un ejemplo como realizar las operaciones que utilizaba desde la shell de MongoDB pero desde una aplicación Java.

Para el ejemplo uso una aplicación Java con Spring Boot en la que hay que incluir la dependencia org.springframework.boot:spring-boot-starter-data-mongodb que proporciona el acceso a esta base de datos. Para comunicación con el servidor de MongoDB hay que crear una instancia del cliente de la base de datos, una instancia de la clase MongoClient para lo que simplemente necesitamos el host y puerto en la que está arrancado el servidor. En el caso del ejemplo localhost y el puerto de MongoDB que por defecto es 27017. Al usar Spring defino un nuevo servicio en el contenedor de dependencias y la inyecto en la clase de la aplicación para hacer uso de ella, dado lo simple que es el ejemplo en el mismo archivo de código fuente.

Los documentos en MongoDB están en formato JSON, como Java no ofrece de una sintaxis sencilla de literales de listas y mapas para el uso de documentos JSON hay que usar algunas clases de la API de MongoDB para la construcción de los documentos, para las búsquedas en las que indicaremos filtros usaremos la clase Filters, Updates para las actualizaciones y para la construcción de documentos de datos y actualizaciones Document. Con la instancia de la clase cliente que da acceso a la base de datos MongoDB desde Java se listan las bases de datos, colecciones y lanzan los comandos.

Con la referencia a una colección se realizan las operaciones de inserción de un documento, actualización del documento completo o de una parte, eliminación de un documento y búsqueda de documentos con una consulta.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


package io.github.picodotdev.blogbitix.holamundomongodb;

import com.mongodb.BasicDBObject;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.function.Consumer;

@SpringBootApplication
public class Main implements CommandLineRunner {

    @Autowired
    private MongoClient mongoClient;

    @Bean
    public MongoClient buildMongoClient() {
        return new MongoClient("localhost");
    }

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        MongoDatabase test = mongoClient.getDatabase("test");
        MongoCollection users = test.getCollection("users");

        // Insertar un documento
        users.insertOne(new Document().append("username", "smith").append("age", 30));

        // Listar bases de datos y colecciones
        mongoClient.listDatabases().forEach((Consumer<Document>) (Document d) -> { System.out.println(d.toJson()); });
        test.listCollections().forEach((Consumer<Document>) (Document d) -> { System.out.println(d.toJson()); });

        // Búsqueda
        users.find().forEach((Consumer<Document>) (Document d) -> { System.out.println(d.toJson()); });
        users.find(Filters.eq("username", "smith")).forEach((Consumer<Document>) (Document d) -> { System.out.println(d.toJson()); });

        // Actualización
        users.updateMany(Filters.eq("username", "smith"), Updates.set("age", 32));

        users.find(Filters.eq("username", "smith")).forEach((Consumer<Document>) (Document d) -> { System.out.println(d.toJson()); });

        // Agregación
        System.out.println(users.count());

        // Eliminación
        users.deleteMany(Filters.eq("username", "smith"));
    }
}

Main.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'org.springframework.boot'

description = 'HolaMundoMongoDB'
version = '0.1'
sourceCompatibility = 1.8
targetCompatibility = 1.8

mainClassName = 'io.github.picodotdev.blogbitix.holamundomongodb.Main'

buildscript {
	ext {
		springBootVersion = '1.5.3.RELEASE'
	}
	repositories {
		mavenCentral()
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
	}
}

repositories {
    mavenCentral()
}

dependencies {
    compile('org.springframework.boot:spring-boot-starter-data-mongodb')
}

build.gradle

La instancia del servidor de MongDB la inicio usando Docker con un archivo de Docker Compose y el comando docker-compose up. En la serie de artículos sobre Docker que escribí puedes aprender como empezar a usar Docker y adquirir un conocimiento hasta un nivel intermedio.

1
2
3
4


mongo:
    image: mongo:latest
    ports:
        - 27017:27017

docker-compose.yml

El resultado en la terminal de ejecutar el ejemplo con el comando gradlew run es el siguiente donde se muestran las bases de datos, la colección users creada en el ejemplo, los usuarios de la colección y una búsqueda de un usuario, el resultado de actualizar la propiedad de un documento y finalmente el número de documentos en la colección.

1
2
3
4
5
6
7
8


{ "name" : "admin", "sizeOnDisk" : 12288.0, "empty" : false }
{ "name" : "local", "sizeOnDisk" : 8192.0, "empty" : false }
{ "name" : "test", "sizeOnDisk" : 8192.0, "empty" : false }
{ "name" : "users", "type" : "collection", "options" : { }, "info" : { "readOnly" : false }, "idIndex" : { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "test.users" } }
{ "_id" : { "$oid" : "5933e9a6a8e0bf17dd0dd9c5" }, "username" : "smith", "age" : 30 }
{ "_id" : { "$oid" : "5933e9a6a8e0bf17dd0dd9c5" }, "username" : "smith", "age" : 30 }
{ "_id" : { "$oid" : "5933e9a6a8e0bf17dd0dd9c5" }, "username" : "smith", "age" : 32 }
1

System.out

Spring ofrece en su API mediante el proyecto Spring Data MongoDB algunas clases adicionales para facilitar el acceso y obtención de datos de MongoDB. Entre estas clases están MongoTemplate, MongoOperations y MongoRepository cuyo uso puede consultarse en su manual de referencia.

En el libro MongDB in Action comentan más detalladamente y de forma más completa las opciones que se pueden utilizar en el lenguaje de consulta, muchas de las opciones son equivalentes a las que son conocidas del lenguaje SQL de las bases de datos relacionales.

MongoDB in Action

El código fuente completo del ejemplo puedes descargarlo del repositorio de ejemplos de Blog Bitix alojado en GitHub y probarlo en tu equipo ejecutando siguiente comando:
docker-compose up, ./gradlew run

Referencia:

Este artículo incluye algunos enlaces de afiliado como Amazon que considero relevante en el contenido del artículo y para el lector. En caso de hacer una comprar a través de estos enlaces recibo una pequeña comisión, sin que afecte al precio del producto, que me ayuda a seguir publicando nuevos artículos y realizar pequeñas donaciones a proyectos de software libre. En caso de que el artículo te haya resultado de interés y útil considera realizar la compra a través de alguno de los enlaces de afiliado del artículo, es correcto también ignorarlos.

Usar la base de datos NoSQL MongoDB con Java

Luces navideñas con la Raspberry Pi y Java

Controlar un servomotor con la Raspberry Pi y Java

Ejemplo sensor de golpes y detector de movimiento en la Raspberry Pi con Java

Cómo usar un diodo LED, un pulsador y un zumbador con la Raspberry Pi y Java

Obtener la temperatura y humedad con el sensor DHT11, la Raspberry Pi, C y Java

Ejemplo de JNI, usar código en C desde Java