Un guide de MongoDB avec Java

1. Vue d'ensemble

Dans cet article, nous examinerons l'intégration de MongoDB, une base de données open source NoSQL très populaire avec un client Java autonome.

MongoDB est écrit en C ++ et possède un certain nombre de fonctionnalités solides telles que la réduction de carte, le partage automatique, la réplication, la haute disponibilité, etc.

2. MongoDB

Commençons par quelques points clés sur MongoDB lui-même:

  • stocke les données dans des documents de type JSON qui peuvent avoir différentes structures
  • utilise des schémas dynamiques, ce qui signifie que nous pouvons créer des enregistrements sans rien prédéfinir
  • la structure d'un enregistrement peut être modifiée simplement en ajoutant de nouveaux champs ou en supprimant des champs existants

Le modèle de données mentionné ci-dessus nous donne la possibilité de représenter des relations hiérarchiques, de stocker facilement des tableaux et d'autres structures plus complexes.

3. Terminologies

Comprendre les concepts de MongoDB devient plus facile si nous pouvons les comparer aux structures de bases de données relationnelles.

Voyons les analogies entre Mongo et un système MySQL traditionnel:

  • Table dans MySQL devient une collection dans Mongo
  • Row devient un document
  • La colonne devient un champ
  • Les jointures sont définies comme des liens et des documents incorporés

C'est une manière simpliste de regarder les concepts de base de MongoDB bien sûr, mais néanmoins utile.

Passons maintenant à l'implémentation pour comprendre cette puissante base de données.

4. Dépendances de Maven

Nous devons commencer par définir la dépendance d'un pilote Java pour MongoDB:

 org.mongodb mongo-java-driver 3.4.1  

Pour vérifier si une nouvelle version de la bibliothèque a été publiée, suivez les versions ici.

5. Utilisation de MongoDB

Maintenant, commençons à implémenter les requêtes Mongo avec Java. Nous suivrons avec les opérations CRUD de base car elles sont les meilleures pour commencer.

5.1. Établissez une connexion avec MongoClient

Tout d'abord, établissons une connexion à un serveur MongoDB. Avec la version> = 2.10.0, nous utiliserons MongoClient :

MongoClient mongoClient = new MongoClient("localhost", 27017);

Et pour les anciennes versions, utilisez la classe Mongo :

Mongo mongo = new Mongo("localhost", 27017);

5.2. Connexion à une base de données

Maintenant, connectons-nous à notre base de données. Il est intéressant de noter que nous n'avons pas besoin d'en créer un. Lorsque Mongo verra que cette base de données n'existe pas, il la créera pour nous:

DB database = mongoClient.getDB("myMongoDb");

Parfois, par défaut, MongoDB s'exécute en mode authentifié. Dans ce cas, nous devons nous authentifier lors de la connexion à une base de données.

Nous pouvons le faire comme présenté ci-dessous:

MongoClient mongoClient = new MongoClient(); DB database = mongoClient.getDB("myMongoDb"); boolean auth = database.authenticate("username", "pwd".toCharArray());

5.3. Afficher les bases de données existantes

Affiche toutes les bases de données existantes. Lorsque nous voulons utiliser la ligne de commande, la syntaxe pour afficher les bases de données est similaire à MySQL:

show databases;

En Java, nous affichons les bases de données à l'aide de l'extrait ci-dessous:

mongoClient.getDatabaseNames().forEach(System.out::println);

La sortie sera:

local 0.000GB myMongoDb 0.000GB

Ci-dessus, local est la base de données Mongo par défaut.

5.4. Créer une collection

Commençons par créer une Collection (table équivalente pour MongoDB) pour notre base de données. Une fois que nous nous sommes connectés à notre base de données, nous pouvons créer une collection comme:

database.createCollection("customers", null);

Maintenant, affichons toutes les collections existantes pour la base de données actuelle:

database.getCollectionNames().forEach(System.out::println);

La sortie sera:

customers

5.5. Enregistrer - Insérer

The save operation has save-or-update semantics: if an id is present, it performs an update, if not – it does an insert.

When we save a new customer:

DBCollection collection = database.getCollection("customers"); BasicDBObject document = new BasicDBObject(); document.put("name", "Shubham"); document.put("company", "Baeldung"); collection.insert(document);

The entity will be inserted into a database:

{ "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"), "name" : "Shubham", "company" : "Baeldung" }

Next, we’ll look at the same operation – save – with update semantics.

5.6. Save – Update

Let’s now look at save with update semantics, operating on an existing customer:

{ "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"), "name" : "Shubham", "company" : "Baeldung" }

Now, when we save the existing customer – we will update it:

BasicDBObject query = new BasicDBObject(); query.put("name", "Shubham"); BasicDBObject newDocument = new BasicDBObject(); newDocument.put("name", "John"); BasicDBObject updateObject = new BasicDBObject(); updateObject.put("$set", newDocument); collection.update(query, updateObject);

The database will look like this:

{ "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"), "name" : "John", "company" : "Baeldung" }

As you can see, in this particular example, save uses the semantics of update, because we use object with given _id.

5.7. Read a Document From a Collection

Let's search for a Document in a Collection by making a query:

BasicDBObject searchQuery = new BasicDBObject(); searchQuery.put("name", "John"); DBCursor cursor = collection.find(searchQuery); while (cursor.hasNext()) { System.out.println(cursor.next()); }

It will show the only Document we have by now in our Collection:

[ { "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"), "name" : "John", "company" : "Baeldung" } ]

5.8. Delete a Document

Let's move forward to our last CRUD operation, deletion:

BasicDBObject searchQuery = new BasicDBObject(); searchQuery.put("name", "John"); collection.remove(searchQuery);

With above command executed, our only Document will be removed from the Collection.

6. Conclusion

This article was a quick introduction to using MongoDB from Java.

L'implémentation de tous ces exemples et extraits de code peut être trouvée sur GitHub - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.