Ejemplo de Tutorial de CRUD en MongoDB Java

Tutoriales
MongoDB

Bienvenido al Tutorial de Ejemplo de MongoDB Java. Anteriormente aprendimos cómo instalar MongoDB en máquinas Unix y ejecutamos algunos comandos desde la terminal. Hoy veremos las características del Controlador de MongoDB Java y cómo realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) comunes.

MongoDB Java

  1. Descarga del Controlador de MongoDB Java

  2. Creación de Conexión Java MongoDB

  3. Conexión a la Base de Datos MongoDB

  4. MongoDB y Colecciones

  5. Ejemplo de MongoDB Java

  6. Descarga del controlador Java de MongoDB

    Si tienes un proyecto Maven, simplemente agrega la siguiente dependencia para incluir el controlador Java de MongoDB en tu aplicación.

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

    Si tienes un proyecto independiente, puedes descargar el controlador Java de MongoDB desde este enlace e incluirlo en la ruta de construcción de tu proyecto. Ahora, veamos algunos usos básicos del controlador Java de MongoDB y luego veremos un programa de ejemplo de Java de MongoDB para operaciones CRUD.

  7. Creando Conexión Java con MongoDB

    MongoClient es la interfaz entre nuestro programa Java y el servidor MongoDB. MongoClient se utiliza para crear una conexión, conectarse a la base de datos, recuperar nombres de colecciones y crear/leer/actualizar/eliminar bases de datos, colecciones, documentos, etc. Una de las características que más me gusta del controlador Java de MongoDB es que es seguro para subprocesos, por lo que podemos crear una instancia de MongoClient una vez y reutilizarla. Incluso si varios hilos acceden a ella simultáneamente, se devuelve una conexión desde la piscina de conexiones interna mantenida por ella. Para cada solicitud a la base de datos (buscar, insertar, etc.), el hilo Java obtendrá una conexión de la piscina, ejecutará la operación y liberará la conexión. Esto significa que la conexión (socket) utilizada puede ser diferente cada vez. A continuación, se presentan algunos de los métodos comunes para conectarse a un servidor MongoDB.

    MongoClient mongoClient = new MongoClient(); // se conecta al host y puerto predeterminados, es decir, 127.0.0.1:27017
// o
MongoClient mongoClient = new MongoClient("localhost"); // se conecta al puerto predeterminado, es decir, 27017
// o
MongoClient mongoClient = new MongoClient("localhost", 27017); // siempre se debe usar esto

// o, para conectarse a un conjunto de réplicas, con descubrimiento automático del primario
MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
                                      new ServerAddress("localhost", 27018),
                                      new ServerAddress("localhost", 27019)));

  8. Conexión a la Base de Datos MongoDB

    Una vez que conseguimos la conexión al servidor de MongoDB, el siguiente paso es crear la conexión a la base de datos, como se muestra a continuación. Nota que si la base de datos no está presente, MongoDB la creará por ti.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");

    MongoClient proporciona un método útil para obtener todos los nombres de las bases de datos, como se muestra a continuación.

    MongoClient mongo = new MongoClient("localhost", 27017);
List<String> dbs = mongo.getDatabaseNames();
System.out.println(dbs); // [journaldev, local, admin]

    Podemos tener autenticación basada en usuario-contraseña para las bases de datos, en ese caso necesitamos proporcionar credenciales de autorización como a continuación.

    MongoCredential journaldevAuth = MongoCredential.createPlainCredential("pankaj", "journaldev", "pankaj123".toCharArray());
MongoCredential testAuth = MongoCredential.createPlainCredential("pankaj", "test", "pankaj123".toCharArray());
List<MongoCredential> auths = new ArrayList<MongoCredential>();
auths.add(journaldevAuth);
auths.add(testAuth);

ServerAddress serverAddress = new ServerAddress("localhost", 27017);
MongoClient mongo = new MongoClient(serverAddress, auths);

    Si estás utilizando versiones anteriores, necesitas proporcionar detalles de autenticación después de obtener el objeto de la base de datos como a continuación.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
boolean auth = db.authenticate("pankaj", "pankaj123".toCharArray());

    Puedes darte cuenta fácilmente de los defectos en el enfoque anterior, la autenticación debería hacerse en una etapa temprana porque no podemos recuperarnos de ella. Podemos eliminar una base de datos ya sea usando el método MongoClient dropDatabase(String db) o por el método DB dropDatabase(). Dado que estamos eliminando la base de datos, prefiero usar el método MongoClient.

  9. MongoDB y Colecciones

    Cada base de datos puede tener cero o múltiples colecciones, son como tablas en servidores de bases de datos relacionales excepto que no tienen un formato específico de datos. Piensa en ello como una lista genérica frente a una lista de cadenas en términos del lenguaje de programación Java. Podemos obtener todos los nombres de las colecciones usando el código siguiente.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
		
Set<String> colecciones = db.getCollectionNames();
System.out.println(colecciones); // [datos, nombres, system.indexes, usuarios]

    Podemos obtener una colección específica proporcionando su nombre, como se muestra a continuación.

    DB db = mongo.getDB("journaldev");	
DBCollection col = db.getCollection("usuarios");

    Nuevamente, si la colección no existe, MongoDB la creará por ti. Todos los datos en MongoDB van a alguna colección, por lo que en este punto estamos listos para realizar operaciones de inserción/actualización/eliminación. Podemos usar el método drop() de DBCollection para eliminar una colección de la base de datos.

  10. Ejemplo de MongoDB en Java

Even though we can work on any valid JSON document in MongoDB collection, in real life we have POJO classes that are mapped with these data. So I will create a java bean and use it for my examples. `User.java`

```
package com.journaldev.mongodb.model;

public class User {

	private int id;
	private String name;
	private String role;
	private boolean isEmployee;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public boolean isEmployee() {
		return isEmployee;
	}
	public void setEmployee(boolean isEmployee) {
		this.isEmployee = isEmployee;
	}
}
```

Here is the complete MongoDB java example program showing all the CRUD operations one by one. `MongoDBExample.java`

```
package com.journaldev.mongodb.main;

import java.net.UnknownHostException;

import com.journaldev.mongodb.model.User;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.WriteResult;

public class MongoDBExample {

	public static void main(String[] args) throws UnknownHostException {
	
		User user = createUser();
		DBObject doc = createDBObject(user);
		
		MongoClient mongo = new MongoClient("localhost", 27017);
		DB db = mongo.getDB("journaldev");
		
		DBCollection col = db.getCollection("users");
		
		//crear usuario
		WriteResult result = col.insert(doc);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//ejemplo de lectura
		DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
		DBCursor cursor = col.find(query);
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		
		//ejemplo de actualización
		user.setName("Pankaj Kumar");
		doc = createDBObject(user);
		result = col.update(query, doc);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//ejemplo de eliminación
		result = col.remove(query);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//cerrar recursos
		mongo.close();
	}

	private static DBObject createDBObject(User user) {
		BasicDBObjectBuilder docBuilder = BasicDBObjectBuilder.start();
								
		docBuilder.append("_id", user.getId());
		docBuilder.append("name", user.getName());
		docBuilder.append("role", user.getRole());
		docBuilder.append("isEmployee", user.isEmployee());
		return docBuilder.get();
	}

	private static User createUser() {
		User u = new User();
		u.setId(2);
		u.setName("Pankaj");
		u.setEmployee(true);
		u.setRole("CEO");
		return u;
	}
	
	

}
```

A sample execution results in following output.

```
null
0
false
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
{ "_id" : 2 , "name" : "Pankaj" , "role" : "CEO" , "isEmployee" : true}
null
1
true
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
null
1
false
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
```

Notice that I am saving User id with **\_id** name, this is a reserved key for the primary key of any record in the collection. If we don't provide one, MongoDB will create one for us. It's like sequencer or auto increment column in relational database tables. Since I am deleting the created record, further execution won't cause any issues. But if there are duplicate record, then we will get below errors.

```
Exception in thread "main" com.mongodb.MongoException$DuplicateKey: { "serverUsed" : "localhost:27017" , "ok" : 1 , "n" : 0 ,
 "err" : "insertDocument :: caused by :: 11000 E11000 duplicate key error index: journaldev.users.$_id_  dup key: { : 1 }" , 
"code" : 11000}
	at com.mongodb.CommandResult.getWriteException(CommandResult.java:88)
	at com.mongodb.CommandResult.getException(CommandResult.java:79)
	at com.mongodb.DBCollectionImpl.translateBulkWriteException(DBCollectionImpl.java:314)
	at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:189)
	at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:165)
	at com.mongodb.DBCollection.insert(DBCollection.java:93)
	at com.mongodb.DBCollection.insert(DBCollection.java:78)
	at com.mongodb.DBCollection.insert(DBCollection.java:120)
	at com.journaldev.mongodb.main.MongoDBExample.main(MongoDBExample.java:27)
```

Eso es todo para comenzar con el controlador de MongoDB en Java, exploraremos más características en próximas publicaciones.

Source:
https://www.digitalocean.com/community/tutorials/mongodb-java-crud-example-tutorial