Java MongoDB Driver, con ejemplos (Video)

El proyecto de este post lo puedes descargar pulsando AQUI.

En esta entrada vamos hacer un sencillo ejemplo de como utilizar el driver (o librerias) de Java para trabajar con MongoDB, en el que veremos como se hace la conexión al servidor y un sencillo CRUD. El objetivo de este tutorial es el de proporcionar un ejemplo que sirva como base para todos aquellos que empeceis a trabajar con MongoDB utilizando Java y podais profundizar más, haciendo consultas más complejas, etc.

Aunque el objetivo de este tutorial no es el de enseñar los conceptos, queries, características de MongoDB, etc. si que empezaremos mostrando una "tabla de equivalencia" entre los conceptos de las Bases de Datos Relacionales y MongoDB para que podáis serguir el tutorial.

Lo primero que tenemos que hacer antes de empezar a "picar código" es importarnos el driver de Java para MongoDB. En este tutorial vamos a crearnos un proyecto Maven (sino sabeis que es Maven, ver los siguientes tutoriales: Maven y Maven para Eclipse) por tanto en nuestro fichero "pom.xml" debemos de copiar la dependencia del driver de Java como mostramos a continuación. Sino utilizais Maven, debeis de importaros a vuestro proyecto el ".jar" del driver de MongoDB.

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>2.13.0</version>
</dependency>	

En este tutorial vamos ha guardar en una colección de la base de datos que llamaremos "Futbolistas", información relacionada sobre futbolistas. Para ello lo primero que vamos ha hacer para estructurar bien el proyecto es definir la clase Futbolista que tendrá la siguiente forma:

public class Futbolista {

	private String nombre;
	private String apellidos;
	private Integer edad;
	private ArrayList<String> demarcacion;
	private Boolean internacional;

        // Constructor
        // getter y setter
}

En nuestro método Main nos vamos a crear 6 objetos de la clase futbolista que guardaremos en un ArrayList para posteriormente hacer un CRUD con ellos en MongoDB. Los objetos futbolista son los siguientes:

ArrayList<Futbolista> futbolistas = new ArrayList<Futbolista>();

futbolistas.add(new Futbolista("Iker", "Casillas", 33, 
		new ArrayList<String>(Arrays.asList("Portero")), true));
futbolistas.add(new Futbolista("Carles", "Puyol", 36, 
		new ArrayList<String>(Arrays.asList("Central", "Lateral")), true));
futbolistas.add(new Futbolista("Sergio", "Ramos", 28, 
		new ArrayList<String>(Arrays.asList("Lateral", "Central")), true));
futbolistas.add(new Futbolista("Andrés", "Iniesta", 30, 
		new ArrayList<String>(Arrays.asList("Centrocampista", "Delantero")), true));
futbolistas.add(new Futbolista("Fernando", "Torres", 30, 
		new ArrayList<String>(Arrays.asList("Delantero")), true));
futbolistas.add(new Futbolista("Leo", " Baptistao", 22, 
		new ArrayList<String>(Arrays.asList("Delantero")), false));

Como vemos en el ejemplo que estamos poniendo, utilizamos tipos de datos diferentes (String, Integer, Array, Boolean) para que el ejemplo sea algo más completo y las queries sean diferentes como veremos a continuación.

Una vez definido lo que queremos guardar en nuestra base de datos, vamos a ver como nos conectamos a la misma para poder hacer las queries que queramos. En primer lugar hay que hacer una conexión al servidor donde esta alojado nuestro "MongoDB server":

// PASO 1: Conexión al Server de MongoDB Pasandole el host y el puerto
MongoClient mongoClient = new MongoClient("localhost", 27017);

En este ejemplo el "server" será nuestra propia máquina "localhost" (Muy importante: debeis de tener instalado MongoDB en vuestra máquina "Instalar mongoDB en Mac OS X") y nos conectaremos por el puerto 27017 que es el puerto que utiliza MongoDB si hacemos la instalación por defecto. Si vuestro MongoDB esta alojado en otra máquina, debeis de poner bien la URL o la IP de la misma, seguido del puerto.

Después de habernos conectado al Server, debemos de conectarnos a la Base de Datos que hemos llamado "Futbol" y después expecificaremos la Colección (en SQL seria la tabla) con la que vamos a trabajar que se llamará "Futbolistas":

// PASO 2: Conexión a la base de datos
DB db = mongoClient.getDB("Futbol");

// PASO 3: Obtenemos una coleccion para trabajar con ella
DBCollection collection = db.getCollection("Futbolistas");

Llegados a este punto ya tenemos hecha nuestra conexión a la base de datos y tenemos una referencia a la colección "Futbolistas" (con la variable 'collection') con la que haremos el CRUD. Aunque lo he pasado por alto, decir que para hacer las conexiones pertienetes, hemos creado objetos de las clases MongoCliene, DB y DBCollection que son clases que nos proporciona el driver de Java.

Ya que tenemos la conexión a MongoDB, vamos a pasar ha hacer el CRUD de los objetos futbolista, pero antes hay que decir una cosa muy importante a la hora de trabajar con las librerias de Java para MongoDB. La libreria de MongoDB "no entiende" los objetos Java y por tanto no sabe trabajar con ellos. Esta librería solo entiende de objetos de la clase "BasicDBObject" (que implementa la interface "DBObject") que es una clase a la que se le pasan dos parámetros que son el nombre del campo del documento (el field) y el valor del campo, por tanto por decirlo de alguna forma es un objeto "mapeador" o "adaptador" de la clase Java al documento de MongoDB:

Por tanto para trabajar tanto con objetos Java como con objetos BasicDBObject, me voy a crear en la clase Futbolista un método que convierta un objeto Java a un objecto BasicDBObject que las queries de la libreria de Java entienda. Este método es el siguiente, en el que podeis ver como por un lado se la pasa el nombre del campo (o field) y por otro lado el valor:

public BasicDBObject toDBObjectFutbolista() {

    // Creamos una instancia BasicDBObject
    BasicDBObject dBObjectFutbolista = new BasicDBObject();

    dBObjectFutbolista.append("nombre", this.getNombre());
    dBObjectFutbolista.append("apellidos", this.getApellidos());
    dBObjectFutbolista.append("edad", this.getEdad());
    dBObjectFutbolista.append("demarcacion", this.getDemarcacion());
    dBObjectFutbolista.append("internacional", this.getInternacional());

    return dBObjectFutbolista;
}

Crear este método que convierta un objeto Java a otro que entienda MongoDB no es que sea necesario hacerlo, pero creo que es una buena práctica tener este tipo de métodos para que nuestro código sea más limpio y escueto.

Dado que ya tenemos todo lo necesario para hacer el CRUD, vamos a ello:

CREATE:

Vamos a insertar en la coleccion Futbolistas cada uno de los objetos futbolista que nos hemos creado y que tenemos en el ArrayList 'futbolistas'. Para ello vamos a utilizar el método "insert" de la clase "DBCollection" que como hicimos anteriormente nos hemos creado un objeto de esa clase llamada 'collection'. Al método "insert" le vamos a pasar el objeto "BasicDBObject" que debe de insertar en la Base de Datos. Para ello utilizamos el método "toDBObjectFutbolista()" que hemos definido anteriormente. Recorriendo el ArrayList de futbolistas, nos inserta en la Base de Datos, los datos de los futbolistas:

for (Futbolista fut : futbolistas) {
    collection.insert(fut.toDBObjectFutbolista());
}

En la colección Futbolistas, tenemos lo siguiente:

{
	"_id" : ObjectId("55084a2d0364d3a7933fe621"),
	"nombre" : "Iker",
	"apellidos" : "Casillas",
	"edad" : 33,
	"demarcacion" : [
		"Portero"
	],
	"internacional" : true
}
{
	"_id" : ObjectId("55084a2d0364d3a7933fe622"),
	"nombre" : "Carles",
	"apellidos" : "Puyol",
	"edad" : 36,
	"demarcacion" : [
		"Central",
		"Lateral"
	],
	"internacional" : true
}
......
......

Vemos como efectivamente nos ha insertado en la colección los datos de los futbolistas, asignandoles un "_id".

READ:

Como primera consulta, vamos a leer todos los documentos de la colección Futbolistas. Para hacer lecturas se utiliza un objeto de la clase "DBCursor", que es un cursor con los documentos seleccionados. Vamos a ver como hacemos un "db.Futbolistas.find()" y lo mostramos por pantalla:

DBCursor cursor = collection.find();
try {
	while (cursor.hasNext()) {
	    System.out.println(cursor.next().toString());
    }
} finally {
	cursor.close();
}

Como vemos, tenemos los documentos en el cursor y lo vamos recorriendo para imprimirlo por pantalla, de forma muy similar a como recorreriamos un ArrayList. Es resultado es el siguiente:

{ "_id" : { "$oid" : "55084a2d0364d3a7933fe621"} , "nombre" : "Iker" , "apellidos" : "Casillas" , "edad" : 33 , "demarcacion" : [ "Portero"] , "internacional" : true}
{ "_id" : { "$oid" : "55084a2d0364d3a7933fe622"} , "nombre" : "Carles" , "apellidos" : "Puyol" , "edad" : 36 , "demarcacion" : [ "Central" , "Lateral"] , "internacional" : true}
{ "_id" : { "$oid" : "55084a2d0364d3a7933fe623"} , "nombre" : "Sergio" , "apellidos" : "Ramos" , "edad" : 28 , "demarcacion" : [ "Lateral" , "Central"] , "internacional" : true}
{ "_id" : { "$oid" : "55084a2d0364d3a7933fe624"} , "nombre" : "Andrés" , "apellidos" : "Iniesta" , "edad" : 30 , "demarcacion" : [ "Centrocampista" , "Delantero"] , "internacional" : true}
{ "_id" : { "$oid" : "55084a2d0364d3a7933fe625"} , "nombre" : "Fernando" , "apellidos" : "Torres" , "edad" : 30 , "demarcacion" : [ "Delantero"] , "internacional" : true}
{ "_id" : { "$oid" : "55084a2d0364d3a7933fe626"} , "nombre" : "Leo" , "apellidos" : " Baptistao" , "edad" : 22 , "demarcacion" : [ "Delantero"] , "internacional" : false}

Ahora vamos ha hacer una consulta en la que nos muestre los futbolistas que pueden jugar o juegan en la demarcación de Delantero. En este caso ya es una query con una condición, por tanto vamos a ver como se hace:

DBObject query = new BasicDBObject("demarcacion", new BasicDBObject("$regex", "Delantero"));
cursor = collection.find(query);
try {
	while (cursor.hasNext()) {
		Futbolista futbolista = new Futbolista((BasicDBObject) cursor.next());
		System.out.println(futbolista.toString());
	}
} finally {
	cursor.close();
}

Como vemos, nos creamos una query que será un objeto de la clase "BasicDBObject", que diremos que nos busque en el campo "demarcacion" (que es un array) aquellos documentos que contengan la demarcación de delantero. Cuando tenemos esos datos en el cursor los imprimimos usando el constructor de la clase Futbolista que dado un BasicDBObject lo pasa a un objeto Java, teniendo como resultado lo siguiente:

Nombre: Andrés Iniesta / Edad: 30 / Demarcación: [Centrocampista, Delantero] / Internacional: true
Nombre: Fernando Torres / Edad: 30 / Demarcación: [Delantero] / Internacional: true
Nombre: Leo  Baptistao / Edad: 22 / Demarcación: [Delantero] / Internacional: false

UPDATE:

Pasamos ahora ha hacer una actualización o modificación de los documentos. Para este ejemplo, vamos a sumar '100' a todos aquellos futbolistas cuya edad sea mayor de 30. Las consultas de actualización requieren dos parámetros; uno que es la búsqueda de los documentos a actualizar o otro que es el campo que se actualiza. Veamos el ejemplo:

DBObject find = new BasicDBObject("edad", new BasicDBObject("$gt", 30));
DBObject updated = new BasicDBObject().append("$inc", new BasicDBObject().append("edad", 100));
collection.update(find, updated, false, true);

En primer lugar (en la variable 'find') buscamos aquellos documentos con el campo edad mayor a '30' y por otro lado en la variable 'updated' hacemos el incremento de '+100' en el campo edad. Por último llamamos al método "update" que tiene 4 parámetros. El primero es la búsqueda de los documentos que han de actualizar y el segundo la actualización que debe hacer, por tanto le pasamos esos dos parámetros que son objetos de la clase "BasicDBObject". Los otros 2 parámetros (el 3º y 4º) son los parámetros de Upsert (si el campo existe se actualiza y sino se crea) y Multiple (si se aplica la modificación a todos los documentos o solo al primero que encuentra), pero esto ya es cosa de saber como son las consultas de MongoDB más que del driver de java. Con la ejecución de este código se modifican dos documentos que son los siguientes:

{
	"_id" : ObjectId("55084a2d0364d3a7933fe621"),
	"nombre" : "Iker",
	"apellidos" : "Casillas",
	"edad" : 133,
	"demarcacion" : [
		"Portero"
	],
	"internacional" : true
}
{
	"_id" : ObjectId("55084a2d0364d3a7933fe622"),
	"nombre" : "Carles",
	"apellidos" : "Puyol",
	"edad" : 136,
	"demarcacion" : [
		"Central",
		"Lateral"
	],
	"internacional" : true
}

DELETE:

Por último vamos a mostrar como borrar documentos. Para ello se utilizará el método "remove" de la clase "DBCollection" al que se la pasa como parámetro la búsqueda de los documentos a eliminar. En el ejemplo, vamos a eliminar todos los documentos que tenga como valor 'true' el campo 'internacional':

DBObject findDoc = new BasicDBObject("internacional", true);
collection.remove(findDoc);

Vemos como en primer lugar hacemos la búsqueda de los documentos con "internacional = true" y luego el método 'remove' los elimina, quedando por tanto en la base de datos un único documento con "internacional = false" que es el siguiente:

{
	"_id" : ObjectId("550849e303645b46b491c39e"),
	"nombre" : "Leo",
	"apellidos" : " Baptistao",
	"edad" : 22,
	"demarcacion" : [
		"Delantero"
	],
	"internacional" : false
}

Con todo esto ya hemos visto como utilizar el driver de Java para MongoDB, conectandonos al Server y haciendo un CRUD muy sencillo que se puede complicar todo lo que querais en función de las queries que tengais que hacer. No tomeis este tutorial como forma de trabajar con MongoDB en Java ya que solo tiene como finalidad mostrar un ejemplo que os sirva como base para los que empezais. Si quereis hacer algo más grande y más complejo os recomiendo que utiliceis el Framework de "Spring Data MongoDB" y estructureis mejor vuestro proyecto ya que como podeis ver si os descargais el proyecto de GitHub, no he estructurado este proyecto siguiendo el patrón MVC que es como se debe hacer en estos casos, así que tomaros este tutorial como lo que es, una primera toma de contacto con MongoDB para Java.

A continuación copio el código completo del proyecto:

Main.java

package com.jarroba.MongoJava.MongoJava_ejemplo;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;

public class Main {

  public static void main(String args[]) {

    ArrayList<Futbolista> futbolistas = new ArrayList<Futbolista>();

    futbolistas.add(new Futbolista("Iker", "Casillas", 33, 
                    new ArrayList<String>(Arrays.asList("Portero")), true));
    futbolistas.add(new Futbolista("Carles", "Puyol", 36, 
                    new ArrayList<String>(Arrays.asList("Central", "Lateral")), true));
    futbolistas.add(new Futbolista("Sergio", "Ramos", 28, 
                    new ArrayList<String>(Arrays.asList("Lateral", "Central")), true));
    futbolistas.add(new Futbolista("Andrés", "Iniesta", 30, 
                    new ArrayList<String>(Arrays.asList("Centrocampista", "Delantero")), true));
    futbolistas.add(new Futbolista("Fernando", "Torres", 30, 
                    new ArrayList<String>(Arrays.asList("Delantero")), true));
    futbolistas.add(new Futbolista("Leo", " Baptistao", 22, 
                    new ArrayList<String>(Arrays.asList("Delantero")), false));

    try {
    // PASO 1: Conexión al Server de MongoDB Pasandole el host y el puerto
      MongoClient mongoClient = new MongoClient("localhost", 27017);

    // PASO 2: Conexión a la base de datos
      DB db = mongoClient.getDB("Futbol");

    // PASO 3: Obtenemos una coleccion para trabajar con ella
      DBCollection collection = db.getCollection("Futbolistas");

    // PASO 4: CRUD (Create-Read-Update-Delete)

      // PASO 4.1: "CREATE" -> Metemos los objetos futbolistas (o documentos en Mongo) en la coleccion Futbolista
      for (Futbolista fut : futbolistas) {
        collection.insert(fut.toDBObjectFutbolista());
      }

      // PASO 4.2.1: "READ" -> Leemos todos los documentos de la base de datos
      int numDocumentos = (int) collection.getCount();
      System.out.println("Número de documentos en la colección Futbolistas: " + numDocumentos + "\n");

      // Busco todos los documentos de la colección y los imprimo
      DBCursor cursor = collection.find();
      try {
        while (cursor.hasNext()) {
          System.out.println(cursor.next().toString());
        }
      } finally {
        cursor.close();
      }

      // PASO 4.2.2: "READ" -> Hacemos una Query con condiciones y lo pasamos a un objeto Java
      System.out.println("\nFutbolistas que juegan en la posición de Delantero");
      DBObject query = new BasicDBObject("demarcacion", new BasicDBObject("$regex", "Delantero"));
      cursor = collection.find(query);
      try {
        while (cursor.hasNext()) {
          Futbolista futbolista = new Futbolista((BasicDBObject) cursor.next());
          System.out.println(futbolista.toString());
        }
      } finally {
        cursor.close();
      }

      // PASO 4.3: "UPDATE" -> Actualizamos la edad de los jugadores.
      DBObject find = new BasicDBObject("edad", new BasicDBObject("$gt", 30));
      DBObject updated = new BasicDBObject().append("$inc", new BasicDBObject().append("edad", 100));
      collection.update(find, updated, false, true);

      // PASO 4.4: "DELETE" -> Borramos todos los futbolistas que sean internacionales (internacional = true)
      DBObject findDoc = new BasicDBObject("internacional", true);
      collection.remove(findDoc);

    // PASO FINAL: Cerrar la conexion
      mongoClient.close();

    } catch (UnknownHostException ex) {
      System.out.println("Exception al conectar al server de Mongo: " + ex.getMessage());
    }
  }
}

Futbolista.java

package com.jarroba.MongoJava.MongoJava_ejemplo;

import java.util.ArrayList;

import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;

public class Futbolista {

	private String nombre;
	private String apellidos;
	private Integer edad;
	private ArrayList<String> demarcacion;
	private Boolean internacional;

	public Futbolista() {
	}

	public Futbolista(String nombre, String apellidos, Integer edad, ArrayList<String> demarcacion, Boolean internacional) {
		this.nombre = nombre;
		this.apellidos = apellidos;
		this.edad = edad;
		this.demarcacion = demarcacion;
		this.internacional = internacional;
	}

	// Transformo un objecto que me da MongoDB a un Objecto Java
	public Futbolista(BasicDBObject dBObjectFutbolista) {
		this.nombre = dBObjectFutbolista.getString("nombre");
		this.apellidos = dBObjectFutbolista.getString("apellidos");
		this.edad = dBObjectFutbolista.getInt("edad");

		// Cuidado cuando trabajamos con Arrays o Listas
		BasicDBList listDemarcaciones = (BasicDBList) dBObjectFutbolista.get("demarcacion");
		this.demarcacion = new ArrayList<String>();
		for (Object demarc : listDemarcaciones) {
			this.demarcacion.add(demarc.toString());
		}

		this.internacional = dBObjectFutbolista.getBoolean("internacional");
	}

	public BasicDBObject toDBObjectFutbolista() {

		// Creamos una instancia BasicDBObject
		BasicDBObject dBObjectFutbolista = new BasicDBObject();

		dBObjectFutbolista.append("nombre", this.getNombre());
		dBObjectFutbolista.append("apellidos", this.getApellidos());
		dBObjectFutbolista.append("edad", this.getEdad());
		dBObjectFutbolista.append("demarcacion", this.getDemarcacion());
		dBObjectFutbolista.append("internacional", this.getInternacional());

		return dBObjectFutbolista;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public String getApellidos() {
		return apellidos;
	}

	public void setApellidos(String apellidos) {
		this.apellidos = apellidos;
	}

	public Integer getEdad() {
		return edad;
	}

	public void setEdad(Integer edad) {
		this.edad = edad;
	}

	public ArrayList<String> getDemarcacion() {
		return demarcacion;
	}

	public void setDemarcacion(ArrayList<String> demarcacion) {
		this.demarcacion = demarcacion;
	}

	public Boolean getInternacional() {
		return internacional;
	}

	public void setInternacional(Boolean internacional) {
		this.internacional = internacional;
	}

	@Override
	public String toString() {
		return "Nombre: " + this.getNombre() + " " + this.getApellidos() + " / Edad: " + this.edad + " / Demarcación: " + this.demarcacion.toString() + " / Internacional: " + this.internacional;
	}
}

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.jarroba.MongoJava</groupId>
	<artifactId>MongoJava_ejemplo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>MongoJava_ejemplo</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
	
		<!-- Añadimos el driver de MongoDB para java -->
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>2.13.0</version>
		</dependency>

	</dependencies>
</project>