MongoDB
 sql >> Base de données >  >> NoSQL >> MongoDB

Guide MongoDB BSON

1. Présentation

Dans ce didacticiel, nous examinerons BSON et comment nous pouvons l'utiliser pour interagir avec MongoDB.

Maintenant, une description détaillée de MongoDB et de toutes ses capacités dépasse le cadre de cet article. Cependant, il sera utile de comprendre quelques concepts clés.

MongoDB est un moteur de stockage de documents NoSQL distribué. Les documents sont stockés sous forme de données BSON et regroupés dans des collections. Les documents d'une collection sont analogues aux lignes d'une table de base de données relationnelle .

Pour un aperçu plus approfondi, consultez l'article d'introduction de MongoDB.

2. Qu'est-ce que BSON ?

BSON signifie JSON binaire . C'est un protocole de sérialisation binaire de données de type JSON.

JSON est un format d'échange de données populaire dans les services Web modernes. Il fournit un moyen flexible de représenter des structures de données complexes.

BSON offre plusieurs avantages par rapport à l'utilisation de JSON standard :

  • Compact :dans la plupart des cas, le stockage d'une structure BSON nécessite moins d'espace que son équivalent JSON
  • Types de données :BSON fournit des types de données supplémentaires introuvable dans JSON normal, tel que Date et BinData

L'un des principaux avantages de l'utilisation de BSON est qu'il est facile à traverser . Les documents BSON contiennent des métadonnées supplémentaires qui permettent une manipulation facile des champs d'un document, sans avoir à lire l'intégralité du document lui-même.

3. Le pilote MongoDB

Maintenant que nous avons une compréhension de base de BSON et de MongoDB, voyons comment les utiliser ensemble. Nous allons nous concentrer sur les principales actions de l'acronyme CRUD (C réate, R lis, U pdate, D supprimer).

MongoDB fournit des pilotes logiciels pour la plupart des langages de programmation modernes. Les pilotes sont construits sur la bibliothèque BSON , ce qui signifie que nous travaillerons directement avec l'API BSON lors de la création de requêtes. Pour plus d'informations, consultez notre guide sur le langage de requête MongoDB.

Dans cette section, nous verrons comment utiliser le pilote pour se connecter à un cluster et utiliser l'API BSON pour effectuer différents types de requêtes. Notez que le pilote MongoDB fournit un Filtres classe qui peut nous aider à écrire du code plus compact. Pour ce didacticiel, cependant, nous nous concentrerons uniquement sur l'utilisation de l'API BSON principale.

Au lieu d'utiliser directement le pilote MongoDB et BSON, consultez notre guide Spring Data MongoDB.

3.1. Connexion

Pour commencer, nous ajoutons d'abord le pilote MongoDB en tant que dépendance dans notre application :

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>3.10.1</version>
</dependency>

Ensuite, nous créons une connexion à une base de données et une collection MongoDB :

MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection<Document> collection = database.getCollection("employees");

Les sections restantes examineront la création de requêtes à l'aide de la collection référence.

3.2. Insérer

Disons que nous avons le JSON suivant que nous voulons insérer en tant que nouveau document dans un employés collecte :

{
  "first_name" : "Joe",
  "last_name" : "Smith",
  "title" : "Java Developer",
  "years_of_service" : 3,
  "skills" : ["java","spring","mongodb"],
  "manager" : {
     "first_name" : "Sally",
     "last_name" : "Johanson"
  }
}

Cet exemple JSON montre les types de données les plus courants que nous rencontrerions avec les documents MongoDB :texte, numérique, tableaux et documents intégrés.

Pour insérer ceci en utilisant BSON, nous utiliserions le Document de MongoDB API :

Document employee = new Document()
    .append("first_name", "Joe")
    .append("last_name", "Smith")
    .append("title", "Java Developer")
    .append("years_of_service", 3)
    .append("skills", Arrays.asList("java", "spring", "mongodb"))
    .append("manager", new Document()
                           .append("first_name", "Sally")
                           .append("last_name", "Johanson"));
collection.insertOne(employee);

Le Document class est l'API principale utilisée dans BSON. Il étend la Map Java interface et contient plusieurs méthodes surchargées. Cela facilite l'utilisation des types natifs ainsi que des objets courants tels que les ID d'objet, les dates et les listes.

3.3. Trouver

Pour trouver un document dans MongoDB, nous fournissons un document de recherche qui spécifie les champs sur lesquels interroger. Par exemple, pour trouver tous les documents dont le nom de famille est "Smith", nous utiliserons le document JSON suivant :

{  
  "last_name": "Smith"
}

Écrit en BSON, cela donnerait :

Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);

Les requêtes "Rechercher" peuvent accepter plusieurs champs et le comportement par défaut consiste à utiliser la logique et opérateur de les combiner. Cela signifie que seuls les documents qui correspondent à tous les champs seront renvoyés .

Pour contourner ce problème, MongoDB fournit le ou opérateur de requête :

{
  "$or": [
    { "first_name": "Joe" },
    { "last_name":"Smith" }
  ]
}

Cela trouvera tous les documents qui ont soit le prénom "Joe" ou le nom de famille "Smith". Pour écrire ceci comme BSON, nous utiliserions un Document imbriqué tout comme la requête d'insertion ci-dessus :

Document query = 
  new Document("$or", Arrays.asList(
      new Document("last_name", "Smith"),
      new Document("first_name", "Joe")));
List results = new ArrayList<>();
collection.find(query).into(results);

3.4. Mettre à jour

Les requêtes de mise à jour sont un peu différentes dans MongoDB car elles nécessitent deux documents :

  1. Les critères de filtrage pour trouver un ou plusieurs documents
  2. Un document de mise à jour précisant les champs à modifier

Par exemple, disons que nous voulons ajouter une compétence « sécurité » à chaque employé qui possède déjà une compétence « ressort ». Le premier document trouvera tous les employés ayant des compétences "de printemps", et le second ajoutera une nouvelle entrée "sécurité" à leur tableau de compétences.

En JSON, ces deux requêtes ressembleraient à :

{
  "skills": { 
    $elemMatch:  { 
      "$eq": "spring"
    }
  }
}

{
  "$push": { 
    "skills": "security"
  }
}

Et dans BSON, ce serait :

Document query = new Document(
  "skills",
  new Document(
    "$elemMatch",
    new Document("$eq", "spring")));
Document update = new Document(
  "$push",
  new Document("skills", "security"));
collection.updateMany(query, update);

3.5. Supprimer

Les requêtes de suppression dans MongoDB utilisent la même syntaxe que les requêtes de recherche. Nous fournissons simplement un document qui spécifie un ou plusieurs critères à respecter.

Par exemple, supposons que nous ayons trouvé un bogue dans notre base de données d'employés et créé accidentellement des employés avec une valeur négative pour les années de service. Pour les trouver tous, nous utiliserions le JSON suivant :

{
  "years_of_service" : { 
    "$lt" : 0
  }
}

Le document BSON équivalent serait :

Document query = new Document(
  "years_of_service", 
  new Document("$lt", 0));
collection.deleteMany(query);