Exemple de tutoriel CRUD MongoDB Java

Tutoriels
MongoDB

Bienvenue dans le tutoriel d’exemple MongoDB Java. Plus tôt, nous avons appris comment installer MongoDB sur des machines Unix et exécuté quelques commandes depuis le terminal. Aujourd’hui, nous examinerons les fonctionnalités du pilote MongoDB Java et comment effectuer des opérations CRUD (Create, Read, Update, Delete) courantes.

MongoDB Java

  1. Téléchargement du pilote MongoDB Java

  2. Création de la connexion MongoDB Java

  3. Connexion à la base de données MongoDB

  4. MongoDB et Collections

  5. Exemple MongoDB Java

  6. Téléchargement du pilote MongoDB Java

    Si vous avez un projet Maven, ajoutez simplement la dépendance ci-dessous pour inclure le pilote Java MongoDB dans votre application.

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

    Si vous avez un projet autonome, vous pouvez télécharger le pilote MongoDB Java depuis ce lien et l’inclure dans le chemin de construction de votre projet. Maintenant, passons en revue quelques utilisations de base du pilote Java MongoDB, puis nous examinerons le programme Exemple Java MongoDB pour les opérations CRUD.

  7. Création de la connexion MongoDB Java

    MongoClient est l’interface entre notre programme Java et le serveur MongoDB. MongoClient est utilisé pour créer une connexion, se connecter à la base de données, récupérer les noms de collection et créer/lire/mettre à jour/supprimer des bases de données, des collections, des documents, etc. Une des fonctionnalités du pilote Java MongoDB que j’apprécie le plus est qu’il est thread-safe, donc nous pouvons créer une instance de MongoClient une fois et la réutiliser. Même si plusieurs threads y accèdent simultanément, une connexion est renvoyée à partir du pool de connexions interne qu’il maintient. Pour chaque requête à la base de données (recherche, insertion, etc.), le thread Java obtiendra une connexion à partir du pool, exécutera l’opération, puis libérera la connexion. Cela signifie que la connexion (le socket) utilisée peut être différente à chaque fois. Voici quelques-unes des méthodes courantes pour se connecter à un serveur MongoDB.

    MongoClient mongoClient = new MongoClient(); // se connecte à l'hôte et au port par défaut, c'est-à-dire 127.0.0.1:27017
// ou
MongoClient mongoClient = new MongoClient( "localhost" ); // se connecte au port par défaut, c'est-à-dire 27017
// ou
MongoClient mongoClient = new MongoClient( "localhost" , 27017 ); // devrait toujours être utilisé

// ou, pour se connecter à un ensemble de répliques, avec découverte automatique du primaire
MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
                                      new ServerAddress("localhost", 27018),
                                      new ServerAddress("localhost", 27019)));

  8. Connexion à la base de données MongoDB

    Une fois que nous avons établi la connexion au serveur MongoDB, la prochaine étape consiste à créer la connexion à la base de données, comme indiqué ci-dessous. Notez que si la base de données n’est pas présente, MongoDB la créera pour vous.

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

    MongoClient fournit une méthode utile pour obtenir tous les noms de base de données, comme indiqué ci-dessous.

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

    Nous pouvons avoir une authentification basée sur l’utilisateur et le mot de passe pour les bases de données, dans ce cas, nous devons fournir des informations d’identification d’autorisation comme ci-dessous.

    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 vous utilisez des versions plus anciennes, vous devez fournir les détails d’authentification après avoir obtenu l’objet de base de données comme ci-dessous.

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

    Vous pouvez facilement identifier les failles dans l’approche précédente, l’authentification devrait être effectuée à un stade précoce car nous ne pouvons pas nous en remettre. Nous pouvons supprimer une base de données soit en utilisant la méthode dropDatabase(String db) de MongoClient, soit en utilisant la méthode dropDatabase() de DB. Comme nous supprimons la base de données, je préfère utiliser la méthode MongoClient.

  9. MongoDB et Collections

    Chaque base de données peut avoir zéro ou plusieurs collections, elles sont similaires aux tables dans les serveurs de bases de données relationnelles, sauf qu’elles n’ont pas de format spécifique de données. Pensez à une liste générique par rapport à une liste de chaînes dans le langage de programmation Java. Nous pouvons obtenir tous les noms de collections en utilisant le code ci-dessous.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
		
Set<String> collections = db.getCollectionNames();
System.out.println(collections); // [datas, names, system.indexes, users]

    Nous pouvons obtenir une collection spécifique en fournissant son nom, comme indiqué ci-dessous.

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

    Encore une fois, si la collection n’existe pas, MongoDB la créera pour vous. Toutes les données dans MongoDB vont dans une collection, donc à ce stade, nous sommes prêts à effectuer des opérations d’insertion/mise à jour/suppression. Nous pouvons utiliser la méthode drop() de DBCollection pour supprimer une collection de la base de données.

  10. Exemple Java MongoDB

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");
		
		//créer utilisateur
		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());
		
		//exemple de lecture
		DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
		DBCursor cursor = col.find(query);
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		
		//exemple de mise à jour
		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());
		
		//exemple de suppression
		result = col.remove(query);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//fermer les ressources
		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)
```

C’est tout pour commencer avec le pilote Java MongoDB, nous examinerons plus de fonctionnalités dans les prochains articles.

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