Empezando con MongoDB en Java en 5 pasos

Empezando con MongoDB en Java en 5 pasos

¿Qué es MongoDB?

Hoy en día con el auge de las bases de datos NoSQL es difícil no conocer MongoDB, es una base de datos orientada a documentos, esto implica que en vez de guardar registros como hacemos en las bases de datos relacionales guardamos documentos. Es open source y está diseñada para el fácil desarrollo y escalabilidad.

MongoDB logo enterprise

Documentos

Un registro de MongoDB es un documento, estructura de datos compuesta por pares de campos y de valor, estos documentos son similares a los objetos JSON. Los valores de los campos pueden incluir otros documentos, matrices y conjuntos de documentos. Puedes verlo en este ejemplo disponible en la documentación de MongoDB:

{
  "address": {
     "building": "1007",
     "coord": [ -73.856077, 40.848447 ],
     "street": "Morris Park Ave",
     "zipcode": "10462"
  },
  "borough": "Bronx",
  "cuisine": "Bakery",
  "grades": [
     { "date": { "$date": 1393804800000 }, "grade": "A", "score": 2 },
     { "date": { "$date": 1378857600000 }, "grade": "A", "score": 6 },
     { "date": { "$date": 1358985600000 }, "grade": "A", "score": 10 },
     { "date": { "$date": 1322006400000 }, "grade": "A", "score": 9 },
     { "date": { "$date": 1299715200000 }, "grade": "B", "score": 14 }
  ],
  "name": "Morris Park Bake Shop",
  "restaurant_id": "30075445"
}

 

Algunas ventajas de usar documentos
  • Los documentos vistos como objetos se corresponden con los datos nativos en muchos lenguajes de programación
  • La incrustación de documentos y arrays reduce el coste de los joins de las bases de datos relacionales
  • Esquema dinámico
Características
  • Alto rendimiento: MongoDB proporciona la persistencia de datos de alto rendimiento.
  • EL soporte para los modelos de datos incrustados reduce la actividad de E/S.
  • Los índices soportan consultas más rápidas y pueden incluir claves de documentos y arrays embebidos.
  • Escalado automático horizontal como parte de su funcionamiento
Colecciones

MongoDB almacena documentos en colecciones, estás son análogas a las tablas en las bases de datos relacionales, con la diferencia de que no tienen que tener la misma esctructura.

En MongoDB, documentos almacenados en una colección deben tener un campo _id única que actúa como una clave principal.

MongoDB desde Java
  1. Instalación
  2. Creamos el proyecto en Netbeans y añadimos las librerías
  3. Estableciendo la conexión con MongoDB desde Java
  4. MongoDB INSERT
  5. Consultas y filtros

 

MongoDB

MongoDB database logo

MongoDB is an open-source, document database designed for ease of development and scaling.MongoDB

 

 

1. Instalación y configuración de MongoDB

Para empezar a hacer pruebas con lo primero que tenemos que hacer es instalar la base de datos en nuestro equipo o servidor, en Downloads MongoDB tienes las instrucciones y descargar para la instalación.

Instalación de MongoDB en Ubuntu

En esta publicación no nos interesa profundizar en la instalación de MongoDB y sus configuraciones, sino hacer una instalación básica para hacer pruebas, entender como se establece una conexión, como accedemos a los datos y como los podemos manipular, es por eso que voy a utilizar la instalación básica de Ubuntu utilizando apt-get, simplemente ejecuta:

sudo apt-get install mongodb

 

Así de sencillo, ya tienes instalado MongoDB, ahora pongamos en marcha nuestra base de datos NoSQL:

sudo service mongodb start

 

Veamos la información de nuestra instalación con el mostrando por pantalla el log:

sudo more /var/log/mongodb/mongodb.log 

 

Esto es lo que nos muestra el log:

run:
dic 13, 2015 11:59:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Cluster created with settings {hosts=[127.0.0.1:27017], mode=SINGLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
dic 13, 2015 11:59:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: No server chosen by PrimaryServerSelector from cluster description ClusterDescription{type=UNKNOWN, connectionMode=SINGLE, all=[ServerDescription{address=127.0.0.1:27017, type=UNKNOWN, state=CONNECTING}]}. Waiting for 30000 ms before timing out
dic 13, 2015 11:59:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Opened connection [connectionId{localValue:1, serverValue:8}] to 127.0.0.1:27017
dic 13, 2015 11:59:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Monitor thread successfully connected to server with description ServerDescription{address=127.0.0.1:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[2, 6, 10]}, minWireVersion=0, maxWireVersion=2, electionId=null, maxDocumentSize=16777216, roundTripTimeNanos=512821}
dic 13, 2015 11:59:11 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Opened connection [connectionId{localValue:2, serverValue:9}] to 127.0.0.1:27017
BUILD SUCCESSFUL (total time: 0 seconds)

 

Ya hemos visto como arrancar nuestra base de datos, si la quieres parar simplemente ejecuta:

sudo service mongodb stop

 

Cargamos la base de datos de pruebas para Java

Para esta primera publicación con MongoDB vamos a utilizar la base de datos test que nos proporcionan en la documentación para eso necesitamos instalarla en nuestra base de datos. EL dataset que nos proporcionan está disponible en https://raw.githubusercontent.com/mongodb/docs-assets/primer-dataset/dataset.json, donde los podemos descargar, en mi caso mantengo el nombre proporcionado dataset.json, ahora ejecuta la siguiente instrucción desde consola para importar la base de datos.

xules@xulescode:~/xulpro/LearningProject/LPNoSQLMongodb$ mongoimport --db test --collection restaurants --drop --file dataset.json

 

Este es el resultado que te muestra por pantalla después de la importación, como puedes ver al no indicar el host y el puerto de la conexión se toman los valores por defecto:

connected to: 127.0.0.1
2015-11-25T23:58:16.359+0100 dropping: test.restaurants
2015-11-25T23:58:17.313+0100 check 9 25359
2015-11-25T23:58:17.400+0100 imported 25359 objects

 

2. Creamos el proyecto en Netbeans y añadimos las librerías

 

Creamos el proyecto en Netbeans

Para estas pruebas voy a utilizar Netbeans, creamos un proyecto básico Java:

  • Creamos el proyecto: File > New Project
  • Seleccionamos: Java > Java Application para crear un proyecto sencillo para trabajar con nuestros ejemplos.

 

Añadimos la librería Netbeans

Para añadir la librería en Netbeans para después incluirla en el proyecto, primero descargamos el driver: Java MongoDB driver, ahí encontrarás las versiones disponibles.

Una vez descargado en nuestro proyecto situándonos sobre la carpeta Libraries seleccionamos Add Library y pulsamos el botón Create, nos aparece está ventana para darle nombre a nuestra librería y añadir los jar correspondientes:

MongoDB driver - Creamos una nueva librería

MongoDB driver – Creamos una nueva librería

 

Ahora añadimos el jar del driver, como puedes ver también se pueden añadir: Javadoc (documentación de las clases y métodos utilizados) y Sources (fuentes del driver), es útil añadir los Javadoc para poder consultar sobre cada método utilizado su documentación:

MongoDB driver - Añadimos el jar del driver

MongoDB driver – Añadimos el jar del driver

Si tienes algún proyecto creado con maven puedes seguir la guía de instalación, básicamente lo que necesitas es añadir las dependencias a tu proyecto:

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver</artifactId>
        <version>3.0.4</version>
    </dependency>
</dependencies>

 

3. Estableciendo la conexión con MongoDB desde Java

Ya podemos crear nuestra primera conexión a la base de datos con MongoDB, nos vamos a conectar con la configuración por defecto que es en localhost y el puerto 27017, para esto creamos una nueva instancia con MongoClient mongoClient = new MongoClient(); que se conectará a una instancia mongod en ejecución:

Para conectar con la base de datos simplemente utilizamos el método getDatabase(“test”), donde test es el nombre de la base de datos que estamos utilizando, así quedaría nuestro código para la conexión a la base de datos test desde Java:

package org.xulescode.mongodb;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
/**
 * Java basic MongoDB connection.
 * Conexión básica en Java a MongoDB.
 * @author xules
 */
public class JavaBasicMongodb {
    /**
     * Testing Java basic Mongodb connection.
     * Probando la conexión básica en Java a Mongodb.
     * @param args the command line arguments
     */
    public static void main(String[] args) {        
        MongoClient mongoClient = new MongoClient();
        MongoDatabase db = mongoClient.getDatabase("test");
    }    
}

 
Si todo fue bien está es la información que aparecerá en tu pantalla:

run:
dic 12, 2015 3:51:45 PM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Cluster created with settings {hosts=[127.0.0.1:27017], mode=SINGLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
BUILD SUCCESSFUL (total time: 2 seconds)

 

La clase MongoClient con el cliente de MongoDB, también nos permite indicar el host y el puerto de la conexión, estos son algunos ejemplos:

 
 MongoClient mongoClient1 = new MongoClient("localhost");
 MongoClient mongoClient2 = new MongoClient("localhost", 27017);
 MongoClient mongoClient4 = new MongoClient(new ServerAddress("localhost")); 

 

También, nos podemos conectar a un conjunto de replicas de una forma sencilla pasando una lista de direcciones de servidor con ServerAddress al constructor de MongoClient, por ejemplo:

 MongoClient mongoClient = new MongoClient(Arrays.asList(
   new ServerAddress("localhost", 27017),
   new ServerAddress("localhost", 27018),
   new ServerAddress("localhost", 27019)));

 

4. MongoDB INSERT

En la documentación del Driver de Java puedes encontrar información de los elementos que vamos a utilizar para añadir datos a la base de datos, usaremos: insertOne, insertMany y org.bson.Document.

 

Añadiendo un documento insertOne

Para nuestro primer ejemplo vamos a introducir un único documento usando el método insertOne y creando un documento de tipo org.bson.Document para la inserción, si el documento no tiene id el driver generará uno.

El resto de explicaciones las encontrarás sobre la clase, lista para ejecutar e introducir un documento, como puedes ver en el método main:

package org.xulescode.mongodb;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Locale;

import static java.util.Arrays.asList;
import java.util.LinkedList;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Class tests for inserting data into MongoDB with <b> insertOne </ b> and <b> insertMany </ b>.
 * Clase de pruebas para la inserción de datos en MongoDB con <b>insertOne</b> y <b>insertMany</b>
 * @author xules
 */
public class JavaMongodbInsertData {
    private MongoClient mongoClient;    // Java MongoDB client (Cliente Java MongoDB)
    private MongoDatabase mongodb;      // Database object (Objeto base de datos)
    /**
     * We establish the connection with the database <b>test</b>.
     * Establecemos la conexión con la base de datos <b>test</b>.
     */
    public void connectDatabase(){
        setMongoClient(new MongoClient());             
        setMongodb(getMongoClient().getDatabase("test"));
    }
    /**
     * We use the method <b>insertOne</b> to add a document to the database example.
     * Usamos el método <b>insertOne</b> para añadir un documento a la base de datos de ejemplo.
     */
    public void insertOneDataTest(){
        try {            
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ENGLISH);
            // We add a document to the database directly (Añadimos un documento a la base de datos directamente).
            getMongodb().getCollection("restaurants").insertOne(
                    new Document("address", asList(
                            new Document()
                                    .append("street", "Avenida Castrelos 25 Bajo")
                                    .append("zipcode", "36210")
                                    .append("building", "180")
                                    .append("coord", asList(-73.9557413, 40.7720266)),
                            new Document()
                                    .append("street", "Urzáiz 77 Bajo")
                                    .append("zipcode", "36004")
                                    .append("building", "40")
                                    .append("coord", asList(-73.9557413, 40.7720266))))
                            .append("borough", "Vigo")
                            .append("cuisine", "Galician")
                            .append("grades", asList(
                                    new Document()
                                            .append("date", format.parse("2015-10-11T00:00:00Z"))
                                            .append("grade", "A")
                                            .append("score", 12),
                                    new Document()
                                            .append("date", format.parse("2015-12-11T00:00:00Z"))
                                            .append("grade", "B")
                                            .append("score", 18)))
                            .append("name", "Xules"));
        } catch (ParseException ex) {
            Logger.getLogger(JavaMongodbInsertData.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }
    public MongoClient getMongoClient() {
        return mongoClient;
    }

    public void setMongoClient(MongoClient mongoClient) {
        this.mongoClient = mongoClient;
    }

    public MongoDatabase getMongodb() {
        return mongodb;
    }

    public void setMongodb(MongoDatabase mongodb) {
        this.mongodb = mongodb;
    } 
    
    /**
     * Adding data to the test database MongoDB Java: insertOne and insertMany example.
     * Añadiendo datos a la base test de MongoDB con Java: ejemplos insertOne e insertMany .
     * @param args 
     */
    public static void main(String args[]){
        JavaMongodbInsertData javaMongodbInsertData = new JavaMongodbInsertData();
        javaMongodbInsertData.connectDatabase();
        javaMongodbInsertData.insertOneDataTest();        
    }
}

 

run:
dic 13, 2015 11:38:51 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Cluster created with settings {hosts=[127.0.0.1:27017], mode=SINGLE, requiredClusterType=UNKNOWN, serverSelectionTimeout='30000 ms', maxWaitQueueSize=500}
dic 13, 2015 11:38:51 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: No server chosen by PrimaryServerSelector from cluster description ClusterDescription{type=UNKNOWN, connectionMode=SINGLE, all=[ServerDescription{address=127.0.0.1:27017, type=UNKNOWN, state=CONNECTING}]}. Waiting for 30000 ms before timing out
dic 13, 2015 11:38:52 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Opened connection [connectionId{localValue:1, serverValue:2}] to 127.0.0.1:27017
dic 13, 2015 11:38:52 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Monitor thread successfully connected to server with description ServerDescription{address=127.0.0.1:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[2, 6, 10]}, minWireVersion=0, maxWireVersion=2, electionId=null, maxDocumentSize=16777216, roundTripTimeNanos=563900}
dic 13, 2015 11:38:52 AM com.mongodb.diagnostics.logging.JULLogger log
INFORMACIÓN: Opened connection [connectionId{localValue:2, serverValue:3}] to 127.0.0.1:27017
BUILD SUCCESSFUL (total time: 1 second)

 

Como puedes ver todo es información de la conexión ya que el método insertOne no devuelve ninguna información. En el siguiente apartado comprobaremos mediante el filtrado del dataset si se ha introducido correctamente este nuevo documento.
 

Añadiendo varios documentos insertMany

Vamos a introducir ahora un conjunto de datos utilizando una lista: LinkedList dataList = new LinkedList<>(), primero añadimos un par de documentos a la lista como puedes ver en el código, y después hacemos un inserta de la misma en la base de datos utilizando el método getMongodb().getCollection(“restaurants”).insertMany(dataList), introduce el nuevo método en la clase creada anteriormente y comprueba el resultado actualizando y ejecutando el método main:

    /**
     * We use the method <b>insertMany</b> to add a set of documents to the database example.
     * Usamos el método <b>insertMany</b> para añadir un conjunto de documentos a la base de datos de ejemplo.
     */
    public void insertManyDataTest(){
        try {            
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ENGLISH);
            // We create a List<Document> (Creamos una List<Document>).
            LinkedList<Document> dataList = new LinkedList<>();
            // We add a document to the list (Añadimos un documento a la lista).
            dataList.add(new Document("address", asList(
                            new Document()
                                    .append("street", "Avenida Castrelos 25 Bajo")
                                    .append("zipcode", "36210")
                                    .append("building", "180")
                                    .append("coord", asList(-73.9557413, 40.7720266)),
                            new Document()
                                    .append("street", "Urzáiz 77 Bajo")
                                    .append("zipcode", "36004")
                                    .append("building", "40")
                                    .append("coord", asList(-73.9557413, 40.7720266))))
                            .append("borough", "Vigo")
                            .append("cuisine", "Galician")
                            .append("grades", asList(
                                    new Document()
                                            .append("date", format.parse("2015-10-11T00:00:00Z"))
                                            .append("grade", "A")
                                            .append("score", 12),
                                    new Document()
                                            .append("date", format.parse("2015-12-11T00:00:00Z"))
                                            .append("grade", "B")
                                            .append("score", 18)))
                            .append("name", "Xules"));
            dataList.add(new Document("address", asList(                            
                            new Document()
                                    .append("street", "Avenida Ruz Perez")
                                    .append("zipcode", "30204")
                                    .append("building", "50")
                                    .append("coord", asList(-73.9557413, 40.7720266))))
                            .append("borough", "Ourense")
                            .append("cuisine", "Galician")
                            .append("grades", asList(
                                    new Document()
                                            .append("date", format.parse("2015-09-01T00:00:00Z"))
                                            .append("grade", "A")
                                            .append("score", 10),
                                    new Document()
                                            .append("date", format.parse("2015-12-01T00:00:00Z"))
                                            .append("grade", "B")
                                            .append("score", 14)))
                            .append("name", "Código Xules"));        
            // Now we insert all documents in the database (Ahora introducimos todos los documentos en la base de datos).
            getMongodb().getCollection("restaurants").insertMany(dataList);
        } catch (ParseException ex) {
            Logger.getLogger(JavaMongodbInsertData.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }

 

Actualiza ahora el método main de la clase anterior para hacer una inserción múltiple, en el siguiente apartado comprobaremos el resultado:

    /**
     * Adding data to the test database MongoDB Java: insertOne and insertMany example.
     * Añadiendo datos a la base test de MongoDB con Java: ejemplos insertOne e insertMany .
     * @param args 
     */
    public static void main(String args[]){
        JavaMongodbInsertData javaMongodbInsertData = new JavaMongodbInsertData();
        javaMongodbInsertData.connectDatabase();     
        javaMongodbInsertData.insertManyDataTest();
    }

 
Si quieres más información sobre la inserción de documentos, puedes obtenerla en el tutorial de MongoDB: Insert documents.
 

5. Consultas y filtros

Utilizaremos el método de find para realizar una consulta para recuperar datos de una colección en MongoDB.

Las consultas pueden devolver todos los documentos en una colección o sólo los documentos que coinciden con un filtro o criterio especificado.

Consulta sobre todos los documentos

La consulta de todos los documentos de la base de datos será devuelta en una colección, así que es importante conocer su funcionamiento en Java para operar con los resultados, pero para hacer una prueba inicial simplemente ejecuta el código y entiende el funcionamiento.

En este caso para devolver todos los documentos no aplicamos ningún filtro o criterio a la consulta, como veremos en el siguiente apartado. Ahora vamos a utilizar el método de búsqueda find() que devuelve los resultados de la consulta en un FindIterable, que será el objeto sobre el que haremos las iteraciones para obtener los documentos.

FindIterable<Document> iterable = db.getCollection("restaurants").find();

Con esto obtenemos los resultados en iterable, ahora simplemente los podemos manejar como un objeto más de Java.

package org.xulescode.mongodb;

import org.bson.Document;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoDatabase;

/**
 * Class tests for MongoDB queries by using collections.
 * Clase de pruebas para las consultas a MongoDB mediante el uso de colecciones.
 * @author xules
 */
public class JavaMongodbList { 
    private MongoClient mongoClient;    // Java MongoDB client (Cliente Java MongoDB)
    private MongoDatabase mongodb;      // Database object (Objeto base de datos)
    /**
     * We establish the connection with the database <b>test</b>.
     * Establecemos la conexión con la base de datos <b>test</b>.
     */
    public void connectDatabase(){
        setMongoClient(new MongoClient());             
        setMongodb(getMongoClient().getDatabase("test"));
    }
    /**
     * Get the list of all the restaurants (each is a document) in the database
     * and shown on screen.
     * Obtenemos la lista de todos los restaurantes (cada uno es un documento)
     * de la base de datos y los mostramos por pantalla.
     */
    public void listRestaurants(){ 
        // To return all documents in a collection, call the find method without a criteria document.
        // Para devolver todos los documentos en una colección, llamamos al método find sin ningún documento <b>criteria</b>
        FindIterable<Document> iterable = getMongodb().getCollection("restaurants").find();
        // Iterate the results and apply a block to each resulting document.
        // Iteramos los resultados y aplicacimos un bloque para cada documento.
        iterable.forEach(new Block<Document>() {
            @Override
            public void apply(final Document document) {
                System.out.println(document);
            }
        });   
    }
    public MongoClient getMongoClient() {
        return mongoClient;
    }

    public void setMongoClient(MongoClient mongoClient) {
        this.mongoClient = mongoClient;
    }

    public MongoDatabase getMongodb() {
        return mongodb;
    }

    public void setMongodb(MongoDatabase mongodb) {
        this.mongodb = mongodb;
    }
    /**
     * We execute methods to display restaurants.
     * Ejecutamos los métodos para mostrar los restaurantes.
     * @param args 
     */
    public static void main(String args[]){
        JavaMongodbList javaMongodbList = new JavaMongodbList();
        javaMongodbList.connectDatabase();
        // javaMongodbList.listRestaurants();
        javaMongodbList.listRestaurantsByCuisine("Galician");
    }
}

 

Filtrando por un documento

Con el driver de Java podemos establecer condiciones de igualdad fácilmente con el documento de la siguiente forma new Document( , ).

Si el es en un documento incrustado o una matriz utilizaremos los puntos para acceder al campo, ahora simplemente vamos a establecer nuestra primera condición de igualdad para el : cuisine y con el valuez< que le pasamos en el método listRestaurantsByCuisine(String cuisine).

Actualiza la clase JavaMongodbList con el siguiente método:

    /**
     * Obtenemos la lista de todos los restaurantes de la base de datos filtrando
     * por el tipo de cocina con el paso del parámetro <b>cuisine</b> y los mostramos por pantalla.
     * @param cuisine <code>String</code> data value to filter (valor para filtrar)
     */
    public void listRestaurantsByCuisine(String cuisine){ 
        // We return documents with the find method by setting a <b>criteria</ b> element equal to the cuisine.
        // Devolvemos los documentos con el método find estableciendo un <b>criteria</b> igual para el elemento cuisine.
        FindIterable<Document> iterable = getMongodb().getCollection("restaurants").find(new Document("cuisine", cuisine));
        // Iterate the results and apply a block to each resulting document.
        // Iteramos los resultados y aplicacimos un bloque para cada documento.
        iterable.forEach(new Block<Document>() {
            @Override
            public void apply(final Document document) {
                System.out.println(document);
            }
        });
    } 

 

Ejecuta ahora el método de listRestaurantsByCuisine(String cuisine) modificando el método main:

    /**
     * We execute methods to display restaurants.
     * Ejecutamos los métodos para mostrar los restaurantes.
     * @param args 
     */
    public static void main(String args[]){
        JavaMongodbList javaMongodbList = new JavaMongodbList();
        javaMongodbList.connectDatabase();        
        javaMongodbList.listRestaurantsByCuisine("Galician");
    }
}

 
Este será el resultado si todo ha ido bien:

Document{{_id=566d4f7f5eb618789e5af3b8, address=[Document{{street=Avenida Castrelos 25 Bajo, zipcode=36210, building=180, coord=[-73.9557413, 40.7720266]}}, Document{{street=Urzáiz 77 Bajo, zipcode=36004, building=40, coord=[-73.9557413, 40.7720266]}}], borough=Vigo, cuisine=Galician, grades=[Document{{date=Sun Oct 11 00:00:00 CEST 2015, grade=A, score=12}}, Document{{date=Fri Dec 11 00:00:00 CET 2015, grade=B, score=18}}], name=Xules}}
Document{{_id=566d85dc5eb61804ead28d7e, address=[Document{{street=Avenida Castrelos 25 Bajo, zipcode=36210, building=180, coord=[-73.9557413, 40.7720266]}}, Document{{street=Urzáiz 77 Bajo, zipcode=36004, building=40, coord=[-73.9557413, 40.7720266]}}], borough=Vigo, cuisine=Galician, grades=[Document{{date=Sun Oct 11 00:00:00 CEST 2015, grade=A, score=12}}, Document{{date=Fri Dec 11 00:00:00 CET 2015, grade=B, score=18}}], name=Xules}}
Document{{_id=566d85dc5eb61804ead28d7f, address=[Document{{street=Avenida Ruz Perez, zipcode=30204, building=50, coord=[-73.9557413, 40.7720266]}}], borough=Ourense, cuisine=Galician, grades=[Document{{date=Tue Sep 01 00:00:00 CEST 2015, grade=A, score=10}}, Document{{date=Tue Dec 01 00:00:00 CET 2015, grade=B, score=14}}], name=Código Xules}}
BUILD SUCCESSFUL (total time: 3 seconds)

 

Hasta aquí ha llegado este tutorial, en el siguiente exploraremos las diferentes posibilidades de filtrado que nos ofrece el driver. Si quieres seguir explorando los métodos y las posibilidad del driver lo puedes consultar en Find or Query Data with Java Driver

 

Documentación

 

Espero que te haya sido útilXules

Ehhhhhhhhhhh!

Si te ha gustado no te vayas sin echar un vistazo

 

Aplicación Web CRUD, segura y multiidioma con Spring Roo con PostgreSQL

Logo_SpringRoo

Aplicación Web CRUD, segura y multiidioma con Spring Roo con PostgreSQL – Guía Spring Roo 1. Con Spring Roo definimos nuestra entidades, generamos la aplicación Web CRUD, le añadimos Spring Security y diferentes idiomas para la aplicación desde nuestra consola Roo.Código Xules

 

Tutorial Primefaces (1): Definición del proyecto y creación de Primefaces CRUD

Primefaces logo

Vamos a crear un proyecto para comprobar el desarrollo de aplicaciones con el framework PrimefacesCódigo Xules

Deja un comentario

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