Auteur : Fabrice Missonnier.
Contexte
La direction marketing a décidé de travailler sur un projet transversal pour diversifier les activités de l’entreprise GSB. En plus de fournir des prestations aux médecins, le directeur souhaite produire des applications à ses clients qui se soucient de compositions nutritionnelles d’aliments (diététiciens, médecins et, potentiellement, des particuliers).
Les données « CIQUAL » utilisées dans ce travail sont issues des compositions officielles fournies par l’ANSES (Agence Nationale de Sécurité Sanitaire). Elles sont déjà utilisées dans l’entreprise pour d’autres projets, libres de droit et ont été migrées sous MySQL.
Au-delà de l’aspect benchmark des bases de données NoSQL, le chef de projet pense qu’il serait utile que l’entreprise s’investisse sur de la veille approfondie dans ces technologies. Ayant participé dernièrement à une conférence sur les méthodes agiles, il a pu discuter avec plusieurs programmeurs Mean Stack. Il apparaît que ces langages deviennent incontournables dans les packs logiciels qu’une entreprise doit utiliser.
L’exemple de Mean Stack est assez parlant : en quelques années, AngularJS et NodeJS se sont imposés sur le front-office. Il est possible que la partie back-office s’oriente de plus en plus vers la base de données MongoDB.
Il demande donc à un des membres de son équipe de produire une veille technologique sur MongoDB.
https://www.anses.fr/fr/content/etiquetage-nutritionnel
Guide de démarrage MongoDB
La documentation officielle de MongoDB est disponible à cette adresse :
http://docs.mongodb.org/getting-started/java/introduction
La première étape consiste à installer le serveur MongoDB.
Travail à faire
https://www.mongodb.org/downloads#production
- Installer MongoDB sur une machine serveur
https://docs.mongodb.org/master/tutorial/install-mongodb-on-os-x/
https://docs.mongodb.org/master/tutorial/install-mongodb-on-windows/
https://docs.mongodb.org/master/tutorial/install-mongodb-on-debian/
https://docs.mongodb.org/manual/tutorial/install-mongodb-on-ubuntu/
- Sur une deuxième machine, installer MongoDB de la même manière. Elle servira uniquement de poste client.
| Sous Windows | Sous Ubuntu 14.04 LTS |
| Créer le répertoire c:\data\db
Lancer une console puis exécuter mongod depuis le répertoire d’installation, typiquement mongod –dbpath C:\Program Files\MongoDB\data\db |
sudo apt-key adv –keyserver hkp://keyserver.ubuntu.com:80 –recv EA312927
sudo apt-get update sudo apt-get install -y mongodb-org sudo service mongod start sudo apt-get install openjdk-7-jdk Télécharger et installer Netbeans (https://netbeans.org/downloads) : Dans le dossier des téléchargements, changer les permissions sur le fichier téléchargé (sudo chmod 755 netbeans-8.1-linux.sh) et exécuter le fichier ( ./netbeans-8.1-linux.sh). |
Si un pare-feu est activé sur la machine serveur, il faut ouvrir le port 27017, par exemple sous Linux :
sudo iptables -I INPUT -p tcp --dport 27017 --syn -j ACCEPT sudo service iptables save
Il faut aussi désactiver SELinux pour les systèmes Linux l’utilisant (ou créer des règles d’accès).
La deuxième étape doit permettre de gérer les utilisateurs et de restaurer une base de données.
Le langage de contrôle de MongoDB est différent du SQL et se rapproche de la programmation objet (voir annexe 1 p.14). Le document de référence pour la gestion des utilisateurs est disponible à ce lien :
https://docs.mongodb.org/manual/reference/built-in-roles/#database-user-roles
Par défaut, un utilisateur avec un rôle « administrateur » est créé lors de l’installation de MongoDB. Dans une invite de commandes locale, on se loggue directement sans nom d’utilisateur et sans mot de passe avec la commande :
mongo
Attention : la commande mongo correspond au client tandis que mongod permet de lancer le serveur.
La gestion des utilisateurs est présentée dans l’annexe n°2 p.16. Il est à noter que MongoDB enregistre les informations en BSON (Binary JSON), qui est une représentation binaire du code JSON :
https://www.mongodb.com/json-and-bson
Travail à faire
- Autoriser les connexions sur le serveur de clients MongoDB distants.
- Créer deux utilisateurs : un administrateur global de toutes les bases de données et un utilisateur propriétaire de la base GSB_CIQUAL.
- Redémarrer le serveur et tester les connexions en local puis à partir de la machine distante.
- Récupérer le répertoire de dump de la base de données fourni dans ce côté labo (\GSB_CIQUAL). Se placer dans le répertoire père de ce dossier.
- Restaurer la base de données avec la commande
mongorestore -d GSB_CIQUAL GSB_CIQUAL/ -u adminciqual --password adminciqual
où -d GSB_CIQUAL correspond au nom de la base de données et GSB_CIQUAL/ correspond au répertoire de la question 4.
Requêtes MongoDB
Les données CIQUAL ont été récupérées en csv à l’adresse https://pro.anses.fr/tableciqual/. Elles sont sous licence ouverte promouvant « la réutilisation la plus large en autorisant la reproduction, la redistribution, l’adaptation et l’exploitation commerciale des données. » Le laboratoire GSB a donc le droit de les utiliser et de les exploiter de manière commerciale.
Voici le schéma relationnel de la base :
Genre (numGenre, nomAnGenre, nomFrGenre) numGenre : clé primaire Aliment (numAliment, nomFrAliment, nomAnAliment, numGenre) numAliment : clé primaire numGenre : clé étrangère en référence à Genre(numGenre) Constituant (numConst, origineFrConst, origineAnConst) numConst : clé primaire CompNutri (numAliment, numConst, valNutri, valMinNutri, valMaxNutri, nbEchantNutri, ccEurNutri) numAliment, numConst : clé primaire numAliment : clé étrangère en référence à Aliment(numAliment) numConst : clé étrangère en référence à Constituant(numConst)
La base comporte environ 1 400 aliments répertoriés dans une centaine de genres. Chaque constituant (57 au total) est identifié pour chaque aliment.
Un résumé des principales commandes MongoDB est proposé dans l’annexe 1 p.11.On retrouve les commandes de base MongoDB à l’adresse
https://docs.mongodb.org/manual/reference/mongo-shell/
Par défaut, les objets de la base sont « référencés » (voir l’annexe 1). Par exemple, dans la base, une composition nutritionnelle (CompNutri) se réfère à un aliment et à un constituant donnés :
Dans ce cas, les _id ont été automatiquement générés par MongoDB.
Il est aussi possible de créer ses propres identifiants (à la manière d’une clé étrangère sous MySQL). Par exemple un aliment fait référence à un genre donné :
Le choix de référencer les données est arbitraire : il aurait été possible de dupliquer chaque objet en les plaçant dans des objet « embarqués ».
Travail à faire (requêtes MongoDB)
Les valeurs retournées par MongoDB sont par défaut formatées dans le langage JSON. Les requêtes d’interrogation de la base ont un format JavaScript. Programmer les requêtes suivantes dans une invite de commande. Il faut être connecté à MongoDB sur la base de données précédemment créée.
mongo GSB_CIQUAL -u adminciqual -p
- Lister tous les genres d’aliments.
- Lister les 25 premiers genres d’aliments de la base.
- Lister les noms français des genres d’aliments de la base.
L’opérateur LIKE en SQL correspond à la recherche d’une chaîne dans une sous-chaîne. La recherche dans des documents sous MongoDB se fait à base d’expressions régulières. On utilise fréquemment les expressions régulières en développement d’applications : dans les scripts bash, awk, en programmation Java, dans des fichiers de configuration Linux, etc. C’est un outil à la fois répandu mais complexe :
https://docs.mongodb.org/manual/reference/operator/query/regex/#op._S_regex
- En utilisant une expression régulière, lister les genres qui ont “biscuit” dans leur intitulé français.
- Compter le nombre de Genres.
Les genres et les sous-genres sont identifiés dans la base par un point : par exemple le genre 13 et le sous-genre 13.1 correspondent aux lignes suivantes :
NumGenre | NomFrGenre | NomAnGenre
13 | Fish and batrachians | Poissons et batraciens
13.1 | Fish and batrachians | Poissons et batraciens non transformés
- Lister tous les sous-genres.
- Modifier le nom des sous genres pour qu’ils soient différents de leurs genres
- le sous-genre 13.1 “Fish and batrachians” deviendra “Unprocessed fish and batrachians”,
- le sous-genre 14.1 “Shellfish and mollusks” deviendra “Unprocessed shellfish and mollusks”
- Compter le nombre d’aliments.
- Donner tous les aliments qui ont le mot clé « Pain » dans leur nom français.
- Sélectionner les aliments dont le genre est « 00 » (‘non défini’).
- Sélectionner les aliments dont le genre est « 01.1 » ( ‘Farines et amidons’).
- Trier les aliments par nom français, de A à Z.
- Trier les aliments par nom français, de Z à A.
Comme dans un langage de POO, il n’existe pas de jointure sous MongoDB. En Java ou en C#, on récupère une collection, puis on boucle sur chaque élément en récupérant l’adresse de l’objet cible référencé. On pratique de la même manière avec MongoDB.
- Que font les trois requêtes suivantes ?
db.Aliment.aggregate([
{
$lookup:
{
from: "Genre",
localField: "numGenre",
foreignField: "numGenre",
as: "leGenre"
}
}
])
db.Aliment.aggregate([
{
$match: {"nomFrAliment": "Riz rouge, cuit"},
}
])
db.Aliment.aggregate([
{$match: {nomFrAliment: "Riz rouge, cuit"}},
{
$lookup: {
from: "Genre",
localField: "numGenre",
foreignField: "numGenre",
as: "leGenre"}
}
])
- Donner la composition nutritionnelle de l’aliment “Cidre doux”.
- Donner les aliments ayant du “Sucre” dans leur composition.
- Quel est le résultat de la requête suivante ?
db.Aliment.aggregate(
[
{ $group :
{
_id: "$numGenre",
count: { $sum: 1 }
}
}
]
)
- Donner le numéro et le nom des aliments qui ont le même genre que la « Pêche melba ». Il faut produire le résultat en plusieurs requêtes et passer par un tableau en résultat.
- Quels sont les genres qui n’apparaissent jamais dans les aliments ?
- Vérifier qu’il existe bien 57 constituants dans la base.
- Donner tous les constituants classés par numéro croissant.
- Fournir les constituants qui sont dosés en mg/100g (indiqué dans le champ origineFrConst).
- Compter le nombre de constituants dosés en mg/100g (dans l’origine française puis dans l’origine anglaise).
Annexe 1 : Sémantique du langage MongoDB
Dans MongoDB, les données sont enregistrées sous forme de documents ; ces documents sont représentés par des « objets » JSON. Il est possible de réaliser des sous ensemble, i.e. les valeurs peuvent être des documents, des tableaux ou tableaux de documents.
Voici une analogie entre les termes utilisés en Java, modèle relationnel et MongoDB (voir aussi http://docs.mongodb.org/manual/reference/sql-comparison/)
| Modèle relationnel | Mongo DB | POO |
| table | collection | classe |
| tuple | document | objet |
| clé primaire | n’existe pas en tant que tel (_id) | adresse de l’objet en mémoire |
| clé étrangère | référence à un identifiant | référence à une adresse |
Tous les documents sont enregistrés dans des collections. La structure du document est dissociée de la structure de la collection.
Comme un langage objet (Powershell, Java, C# par exemple), MongoDB utilise un format de notation pointée, avec des méthodes appliquées sur des collections. Il ne faut donc pas oublier les parenthèses :
db.Aliment.find()
show collections est pratique pour visualiser toutes les collections de la base.
Puisque le NoSQL n’impose aucune contrainte sur les données (pas de typage ni de schéma de table), il n’existe pas de langage de définition des données, au sens SQL du terme. C’est le langage de manipulation de données qui gère automatiquement.
Comme en POO, il n’existe pas non plus de « jointures » entre les objets : en Java ou en C#, pour accéder à une référence, il faut passer par un accesseur sur l’objet. Par exemple, si une commande correspond à un seul client, on crée la commande et on utilise un accesseur pour récupérer le client.
Par conséquent, il n’y a pas de clés primaires ni de clés étrangères. C’est l’objet inséré qui a un identifiant interne. Pour faire un lien, on travaille comme en POO avec les adresses des objets déjà insérés.
Lors de la création d’un document, MongoDB génère à chaque fois un attribut spécifique _id :
La relation 1-1 (one-to-one) se fait par l’intermédiaire de ces identifiants :
http://docs.mongodb.org/manual/tutorial/model-embedded-one-to-one-relationships-between-documents/
Dans une relation 1-1, les objets sont
- soit embarqués (donc dupliqués) : ils appartiennent au document en cours d’insertion
db.client.insert (
{
nomCli: "Milze",
adresseCli: "10 rue du Monastère",
codePostalCli: "15000",
villeCli: "Aurillac",
telephoneCli: "0145247000",
representant: {
nomRep: "Jovovitch",
prenomRep: "Milla"
}
}
)
- soit référencés : ils sont créés dans une autre collection et l’identifiant est la seule référence
db.client.insert (
{
nomCli: "Milze",
adresseCli: "10 rue du Monastère",
codePostalCli: "15000",
villeCli: "Aurillac",
telephoneCli: "0145247000",
representant_id: "54886acdc47a3a832bd1c40a"
}
)
Les accolades {} indiquent une structure de données comportant plusieurs étiquettes, un sous-ensemble. S’il est nécessaire qu’une étiquette possède plusieurs valeurs, on utilise un tableau [ ]
On pourrait aussi embarquer plusieurs objets ou plusieurs références (un client aurait plusieurs représentants).
L’insertion de document se fait aussi avec le format JSON.
La récupération des résultats des requêtes d’interrogation peut se faire sous différents formats (JSON ou tableau associatif). Les requêtes directement passées dans une invite de commande fournissent un résultat au format JSON. Lorsqu’on interroge en PHP, le middleware fournit en résultat des tableaux associatifs :
http://www.lafermeduweb.net/billet/nosql-mongodb-et-php-premiere-approche-781.html
Langage de définition des données (LDD)
(SQL : LMD = INSERT INTO, DELETE et UPDATE)
MongoDB est une base de données qu’on pourrait considérer comme « faiblement typée. » Alors qu’en SQL il faut spécifier un type à chaque attribut lorsqu’on crée une table, MongoDB se débrouille pour gérer ces contraintes automatiquement.
Par exemple, on insère une donnée avec la fonction insert appliquée sur la collection :
db.users.insert(
{
name: "sue",
age: 26,
status: "A"
}
)
Cela équivaut en SQL à la requête
Pour vérifier qu’une valeur a été insérée, on utilise la méthode find() sur l’objet collection créé :
db.users.find()
On peut ajouter un autre objet dans la collection users, en ajoutant directement une colonne sans se soucier de la structure initiale :
db.users.insert(
{
name: "Dupont",
age: 26,
status: "A",
prenom: "Jean"
}
)
Pour la mise à jour et la suppression de document, on peut se référer à la documentation :
http://docs.mongodb.org/manual/core/write-operations-introduction/
Exemple sur la base de données GSB_CIQUAL
db.Aliment.insert(
{
"nomFrAliment" : "Jus multifruit, pur jus, multivitaminé",
"nomAnAliment" : "Fruit juice, mixed, enri",
"numGenre" : "19"
}
)
var alim = { //on crée une variable JavaScript
"nomFrAliment" : "Jus multifruit, pur jus, multivitaminé",
"nomAnAliment" : "Fruit juice, mixed, enri",
"numGenre" : "19"
}
db.Aliment.insert( alim )
La suppression s’effectue avec remove
db.Aliment.remove({ _id: ObjectId("532d40c72d150b4635b8cfc9")})
Langage d’interrogation des données (LID)
Rappel SQL : LID = SELECT
Le plus simple pour accéder aux données d’une collection est d’utiliser la méthode find(). Le détail se trouve ici : http://docs.mongodb.org/manual/core/read-operations-introduction/
Une analogie entre le LID SQL et le langage MongoDB est proposée dans la documentation. Attention toutefois à ne pas raisonner de la même manière, les deux langages ayant une sémantique différente :
https://docs.mongodb.org/manual/reference/sql-comparison/
Par exemple :
On peut convertir un résultat JSON en tableau (« curseur » ou encore « jeu d’enregistrement ») grâce à une méthode appliquée sur l’objet retourné par find()
db.Aliment.find().toArray()
Ce curseur peut à son tour être stocké dans une variable pour être réutilisé dans une autre requête :
var monTableau = db.Aliment.find().toArray()
Il n’existe pas de « jointures » entre les objets car, comme en programmation orientée objet, cela n’a pas vraiment de sens. En POO, pour accéder à une référence, il faut passer par un accesseur sur l’objet. Par exemple, si une commande correspond à un seul client, on crée la commande et on utilise un accesseur pour récupérer le client.
Langage de définition des données (LDD)
Rappel SQL : LDD = CREATE, DROP et ALTER TABLE
Ce paragraphe est sans objet car on ne crée pas de tables dans MongoDB. C’est le langage de manipulation de données qui s’en occupe automatiquement.
Annexe 2 : Détails de configuration de MongoDB (utilisateurs, interfaces web, etc.)
Pour effectuer le travailler de requêtage, il faut bien vérifier que la version 3.2 est installée (mongod –version)
Si MongoDB est installé sur une machine serveur distante, son accès par les machines clientes se fera en commentant la ligne bindIp dans le fichier /etc/mongod.conf :
# network interfaces net: port: 27017 # bindIp: 127.0.0.1
Sur le serveur, la commande mongod (sans paramètre) permet de se loguer avec l’utilisateur admin défini par défaut.
Gestion des utilisateurs
Pour pouvoir travailler avec plusieurs utilisateurs, il faut changer le mécanisme d’authentification de MongoDB en exécutant les instructions suivantes à partir de la console « mongo » :
var schema = db.system.version.findOne({"_id" : "authSchema"})
schema.currentVersion = 3
db.system.version.save(schema)
Il n’y a pas de commande de création de base de données, c’est use qui le fait automatiquement.
En se connectant directement avec la commande mongo sur le serveur local, on peut créer un administrateur dans la base de données admin :
use admin
db.createUser(
{
user: "administrateur",
pwd: "unPassword",
roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
}
)
Sous MongoDB, un utilisateur est toujours lié à une base de données (il ne sera pas visible dans une autre base, sauf si on le crée à nouveau). La requête suivante permet de créer un utilisateur propriétaire de sa base de données. Il n’aura bien sûr pas accès aux autres bases.
use GSB_CIQUAL
db.createUser(
{
user: "adminciqual",
pwd: "unAutrePassword",
roles: [ { role: "dbOwner", db: "GSB_CIQUAL" } ]
}
)
L’instruction use GSB_CIQUAL crée directement la base de données.
Pour pouvoir se connecter à l’aide de ces nouveaux utilisateurs, il faut insérer les lignes suivantes dans le fichier mongodb.conf (en général dans /etc )
security:
authorization: enabled
Pour se connecter avec de nouveaux utilisateurs, l’autorisation doit être placée dans le fichier /etc/mongodb.conf en y ajoutant
security:
authorization: enabled
Après avoir redémarré le serveur (sudo service mongod restart ou tuer et redémarrer le processus sous Windows), la connexion se fait avec le client mongo comme sous MySQL:
mongo GSB_CIQUAL -u adminciqual -p mongo admin -u administrateur -p
Pour se connecter à un serveur distant, on utilisera
mongo GSB_CIQUAL --host 192.168.1.4 -u adminciqual -p
Pour visualiser le rôle d’un utilisateur, on utilisera
use GSB_CIQUAL
db.getUser("adminciqual")
Il existe de nombreuses commandes pour la gestion d’utilisateurs. Pour vérifier que les utilisateurs ne sont créés que dans la base en cours, on se servira de la commande
use GSB_CIQUAL db.getUser()
Pour changer le mot de passe d’un utilisateur, la commande suivante est pratique :
db.changeUserPassword("administrateur", "monNouveauPasswd")
Pour plus de détail sur les rôles, la documentation complète est à l’adresse
https://docs.mongodb.org/manual/reference/built-in-roles/#database-user-roles
Interfaces web PHP (« mongomyadmin » !)
http://us.php.net/manual/en/mongo.installation.php
Quasiment toutes les interfaces d’administration pour MongoDB utilisent PHP. Le driver de connexion PHP s’installe sous Linux avec les commandes suivantes :
sudo yum install gcc php-devel git clone https://github.com/mongodb/mongo-php-driver-legacy.git cd mongo-php-driver-legacy phpize ./configure make all sudo make install
La dernière ligne copie le fichier mongo.so dans le répertoire des extensions PHP. Il faut ensuite modifier le fichier php.ini pour qu’il monte le driver :
- ouvrir le fichier sudo nano /etc/php.init
- ajouter la ligne extension=mongo.so
- sauvegarder le fichier
- redémarrer le serveur apache sudo service httpd restart
De nombreux outils ont été développés pour avoir une interface d’administration un peu plus conviviale que la ligne de commande :
https://docs.mongodb.org/ecosystem/tools/administration-interfaces/
En général plutôt bien implémentés, ils interdisent la création de requêtes directes sur la base pour les utilisateurs non administrateurs (db.Aliment.find() ne fonctionnera pas, par exemple). Par contre, ces interfaces permettent de lister simplement les collections.
Un choix possible sous Linux est PHPMongoDB. Le guide d’installation se trouve à l’adresse
https://github.com/phpmongodb/phpmongodb
Annexe 3 : Convertir une base de données MySQL en MongoDB
Les outils de conversion de données MySQL vers MongoDB ne sont pas très nombreux. Il n’en existe pas de vraiment fonctionnels à ce jour sous Windows, et peu sous Linux.
Le choix s’est porté sur un Mongify, outil développé en ruby et fonctionnant sous Linux CentOS ou Mac OS.
La documentation de Mongify se trouve à l’adresse suivante :
http://www.rubydoc.info/gems/mongify/
L’installation sous CentOS se fait avec les commandes
sudo yum install gcc mysql-devel ruby-devel rubygems gem install mongify gem install activerecord-mysql-adapter
Mongify ne fonctionne qu’avec le mode administrateur standard de MongoDB : il faut donc commenter la ligne authorization: enabled dans le fichier /etc/mongod.conf et redémarrer le serveur.
Pour rappel, comme en programmation objet, il n’existe pas de clés ni de jointures sous MongoDB. C’est l’objet inséré qui a un identifiant interne.
Avec Mogify, on peut utiliser soit des objets embarqués, soit référencés (voir Sémantique du langage MongoDB p.13). Il faut donc opter pour une dénormalisation complète en « embarquant » les objets, ou créer des références.
La deuxième solution (plus cohérente mais moins rapide pour les accès) est présentée ici. Le fichier de configuration de Mongify devra permettre
- de garder le numéro de Genre dans un attribut et de générer un _id correspondant à une adresse spécifique MongoDB
- à la collection Aliment de référencer l’id du Genre
- à la collection Composant Nutritionnelle de référencer l’adresse de l’aliment ainsi que l’adresse du Constituant.
A partir de la documentation Mongify (http://www.rubydoc.info/gems/mongify/), il faut créer les fichiers database.config et translation.rb
database.config sql_connection do adapter "mysql" host "localhost" username "root" encoding "utf8" password "votrePassword" database "GSB_CIQUAL" end mongodb_connection :force => true do host "localhost" database "GSB_CIQUAL_MDB" end translation.rb table "Genre" do column "id", :key column "numGenre", :string column "nomAnGenre", :string column "nomFrGenre", :string end table "Aliment" do column "numAliment", :key column "nomFrAliment", :string column "nomAnAliment", :string column "idGenre", :integer, :references => :Genre end table "Constituant" do column "numConst", :key column "origineFrConst", :string column "origineAnConst", :string end table "CompNutri" do column "id", :key column "numAliment", :integer, :references => :Aliment column "numConst", :integer, :references => :Constituant column "valNutri", :string column "valMinNutri", :double column "valMaxNutri", :double column "nbEchantNutri", :double column "ccEurNutri", :string end
Pour être référencés avec des adresses, les id doivent forcément être en type integer. La conversion peut prendre plusieurs minutes en fonction de la puissance de la machine serveur.
La conversion se fait avec la commande
mongify process database.config translation.rb
Annexe 4 : Utilisation de MongoDB dans du code Java
Dans NetBeans, créer un nouveau projet (Java Application).
Télécharger le driver mongodb (mongo-java-driver3.0.4.jar) puis l’ajouter aux librairies du projet :
https://oss.sonatype.org/content/repositories/releases/org/mongodb/mongo-java-driver/3.0.4/
Pour vérifier que l’installation est effective, vous pouvez utiliser le code suivant en modifiant selon vos paramètres l’adresse et le port .
//connexion à la base de données
//localhost correspond à l’adresse du serveur, ici 127.0.0.1
//27017 est le numéro du port.
MongoClient mongo = new MongoClient("localhost", 27017);
//On recherche la base Certa, si elle n’existe pas, elle sera créée.
MongoDatabase db = mongo.getDatabase("GSB_CIQUAL");
//On créé un document Aliment
MongoCollection<Document> collection = db.getCollection("Aliment");
/*insertion d’un document JSON suivant :
{
"nomFrAliment" : "Jus multifruit, pur jus, multivitaminé",
"nomAnAliment" : "Fruit juice, mixed, enri",
"numGenre" : "19"
}
*/
Document doc = new Document("Aliment", "Jus multifruit, pur jus, multivitaminé ")
.append("nomAnAliment ", "padawan")
.append("numGenre", "Fruit juice, mixed, enri" );
collection.insertOne(doc);
//On recherche le premier document et on l’affiche
Document myDoc = collection.find().first();
System.out.println(myDoc.toJson());
Pour voir les données sous NetBeans, on peut installer le plugin NBMongo (Tools / Plugins / Available Plugins) ou http://plugins.netbeans.org/plugin/52638/nbmongo.
Puis aller dans l’onglet Services. Clic droit sur mongo db pour réaliser une nouvelle connexion en fonction des paramètres. Les bases de données s’afficheront.