Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exécution d'opérations CRUD dans Amazon DocumentDB avec Java
<a name="java-crud-operations"></a>

Cette section décrit l'exécution de l'opération CRUD (création, lecture, mise à jour, suppression) dans Amazon DocumentDB à l'aide des pilotes Java MongoDB.

**Topics**
+ [Création et insertion de documents dans une collection DocumentDB](#creating-inserting)
+ [Lire et récupérer des données d'une collection DocumentDB](#reading-retrieving)
+ [Mettre à jour des documents existants dans une collection DocumentDB](#updating-documents)
+ [Supprimer des documents d'une collection DocumentDB](#deleting-documents)
+ [Gestion des erreurs avec la logique de nouvelle tentative](#error-handling)

## Création et insertion de documents dans une collection DocumentDB
<a name="creating-inserting"></a>

L'insertion de documents dans Amazon DocumentDB vous permet d'ajouter de nouvelles données à vos collections. Il existe plusieurs méthodes pour effectuer des insertions, en fonction de vos besoins et du volume de données avec lequel vous travaillez. La méthode la plus simple pour insérer un document individuel dans la collection est`insertOne()`. Pour insérer plusieurs documents à la fois, vous pouvez utiliser `insertMany()` cette méthode, qui vous permet d'ajouter un ensemble de documents en une seule opération. Une autre méthode pour insérer de nombreux documents dans une collection DocumentDB est. `bulkWrite()` Dans ce guide, nous abordons toutes ces méthodes de création de documents dans une collection DocumentDB.

**`insertOne()`**

Commençons par examiner comment insérer un document individuel dans une collection Amazon DocumentDBB. L'insertion d'un seul document est réalisée à l'aide du `insertOne()` procédé. Cette méthode prend un [BsonDocument](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/bson/org/bson/BsonDocument.html)for pour l'insertion et renvoie un [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertOneResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertOneResult.html)objet qui peut être utilisé pour obtenir l'identifiant du nouveau document inséré. L'exemple de code ci-dessous montre l'insertion d'un document de restaurant dans la collection :

```
Document article = new Document()
    .append("restaurantId", "REST-21G145")
    .append("name", "Future-proofed Intelligent Bronze Hat")
    .append("cuisine", "International")
    .append("rating", new Document()
        .append("average", 1.8)
        .append("totalReviews", 267))
    .append("features", Arrays.asList("Outdoor Seating", "Live Music"));

try {
    InsertOneResult result = collection.insertOne(article);
    System.out.println("Inserted document with the following id: " + result.getInsertedId());
} catch (MongoWriteException e) {
    // Handle duplicate key or other write errors
    System.err.println("Failed to insert document: " + e.getMessage());
    throw e;
} catch (MongoException e) {
    // Handle other MongoDB errors
    System.err.println("MongoDB error: " + e.getMessage());
    throw e;
}
```

Lors de l'utilisation`insertOne()`, veillez à inclure une gestion des erreurs appropriée. Par exemple, dans le code ci-dessus, « `restaurantId` » possède un index unique et, par conséquent, une nouvelle exécution de ce code générera les éléments suivants `MongoWriteException` :

```
Failed to insert document: Write operation error on server docdbCluster.docdb.amazonaws.com:27017. 
Write error: WriteError{code=11000, message='E11000 duplicate key error collection: Restaurants index: restaurantId_1', details={}}.
```

**Insérer plusieurs ()**

Les principales méthodes utilisées pour insérer de nombreux documents dans une collection sont insertMany () et. `bulkWrite()` 

Il s'agit de la `insertMany()` méthode la plus simple pour insérer plusieurs documents en une seule opération. Il accepte une liste de documents et les insère dans la collection. Cette méthode est idéale lorsque vous insérez un lot de nouveaux documents indépendants les uns des autres et ne nécessitant aucun traitement spécial ni aucune opération mixte. Le code suivant montre la lecture de documents JSON à partir d'un fichier et leur insertion dans la collection. La `insertMany()` fonction renvoie un [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertManyResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/InsertManyResult.html)`InsertManyResult`objet qui peut être utilisé pour obtenir tous IDs les documents insérés.

```
// Read JSON file content
String content = new String(Files.readAllBytes(Paths.get(jsonFileName)));
JSONArray jsonArray = new JSONArray(content);

// Convert JSON articles to Documents
List < Document > restaurants = new ArrayList < > ();
for (int i = 0; i < jsonArray.length(); i++) {
    JSONObject jsonObject = jsonArray.getJSONObject(i);
    Document doc = Document.parse(jsonObject.toString());
    restaurants.add(doc);
}
//insert documents in collection
InsertManyResult result = collection.insertMany(restaurants);

System.out.println("Count of inserted documents: " + result.getInsertedIds().size());
```

**[https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/package-summary.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/package-summary.html)**

La `bulkWrite()` méthode permet d'effectuer plusieurs opérations d'écriture (insertion, mise à jour, suppression) en un seul lot. Vous pouvez l'utiliser `bulkWrite()` lorsque vous devez effectuer différents types d'opérations en un seul lot, comme l'insertion de certains documents tout en mettant à jour d'autres. `bulkWrite()`supporte deux types d'écriture par lots, ordonnée et non ordonnée :
+ *Opérations ordonnées* — (par défaut) Amazon DocumentDB traite les opérations d'écriture de manière séquentielle et s'arrête à la première erreur rencontrée. Cela est utile lorsque l'ordre des opérations est important, par exemple lorsque les opérations ultérieures dépendent des opérations précédentes. Cependant, les opérations ordonnées sont généralement plus lentes que les opérations non ordonnées. Dans le cas des opérations ordonnées, vous devez résoudre le cas où le lot s'arrête à la première erreur, ce qui peut laisser certaines opérations non traitées.
+ *Opérations non ordonnées* — Permet à Amazon DocumentDB de traiter les insertions en une seule exécution dans la base de données. Si une erreur se produit avec un document, l'opération se poursuit avec les autres documents. Cela est particulièrement utile lorsque vous insérez de grandes quantités de données et que vous pouvez tolérer certaines défaillances, par exemple lors de la migration de données ou d'importations en masse, lorsque certains documents peuvent échouer en raison de clés dupliquées. Dans le cas d'opérations non ordonnées, vous devez faire face à des scénarios de réussite partielle dans lesquels certaines opérations réussissent tandis que d'autres échouent.

Lorsque vous travaillez avec la `bulkWrite()` méthode, certaines classes essentielles sont requises. Tout d'abord, la [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/WriteModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/WriteModel.html)classe sert de classe de base pour toutes les opérations d'écriture et avec des implémentations spécifiques telles que [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/InsertOneModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/InsertOneModel.html), [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateOneModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateOneModel.html), [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html), et pour la [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteManyModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/DeleteManyModel.html)gestion de différents types d'opérations.

La [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html)classe est nécessaire pour configurer le comportement des opérations en masse, telles que la définition de ordered/unordered l'exécution ou le contournement de la validation des documents. La [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html)classe fournit des informations détaillées sur les résultats de l'exécution, y compris le nombre de documents insérés, mis à jour et supprimés.

Pour la gestion des erreurs, la [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoBulkWriteException.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoBulkWriteException.html)classe est cruciale car elle contient des informations sur les défaillances survenant lors d'une opération en masse, tandis que la [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteError.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteError.html)classe fournit des détails spécifiques sur les échecs d'opération individuels. Le code suivant montre un exemple d'insertion d'une liste de documents, ainsi que de mise à jour et de suppression d'un seul document, le tout dans le cadre de l'exécution d'un appel de `bulkWrite()` méthode unique. Le code indique également comment utiliser [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/BulkWriteOptions.html)et [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/bulk/BulkWriteResult.html), ainsi que la gestion appropriée des erreurs lors de l'`bulkWrite()`opération. 

```
List < WriteModel < Document >> bulkOperations = new ArrayList < > ();
// get list of 10 documents representing 10 restaurants
List < Document > restaurantsToInsert = getSampleData();

for (Document doc: restaurantsToInsert) {
    bulkOperations.add(new InsertOneModel < > (doc));
}
// Update operation
bulkOperations.add(new UpdateOneModel < > (
    new Document("restaurantId", "REST-Y2E9H5"),
    new Document("", new Document("stats.likes", 20))
    .append("", new Document("rating.average", 4.5))));
// Delete operation
bulkOperations.add(new DeleteOneModel < > (new Document("restaurantId", "REST-D2L431")));

// Perform bulkWrite operation
try {
    BulkWriteOptions options = new BulkWriteOptions()
        .ordered(false); // Allow unordered inserts

    BulkWriteResult result = collection.bulkWrite(bulkOperations, options);

    System.out.println("Inserted: " + result.getInsertedCount());
    System.out.println("Updated: " + result.getModifiedCount());
    System.out.println("Deleted: " + result.getDeletedCount());
} catch (MongoBulkWriteException e) {
    System.err.println("Bulk write error occurred: " + e.getMessage());
    // Log individual write errors
    for (BulkWriteError error: e.getWriteErrors()) {
        System.err.printf("Error at index %d: %s (Code: %d)%n", error.getIndex(), error.getMessage(),
            error.getCode());

        // Log the problematic document
        Document errorDoc = new Document(error.getDetails());
        if (errorDoc != null) {
            System.err.println("Problematic document: " + errorDoc);
        }
    }
} catch (Exception e) {
    System.err.println("Error during bulkWrite: " + e.getMessage());
}
```

**écritures réessayables**

Contrairement à MongoDB, Amazon DocumentDB ne prend pas en charge les écritures réessayables. Par conséquent, vous devez implémenter une logique de nouvelle tentative personnalisée dans leurs applications, en particulier pour gérer les problèmes de réseau ou l'indisponibilité temporaire des services. Une stratégie de nouvelle tentative bien mise en œuvre implique généralement d'augmenter le délai entre les tentatives et de limiter le nombre total de tentatives. [Gestion des erreurs avec la logique de nouvelle tentative](#error-handling)Vous trouverez ci-dessous un exemple de code illustrant la création d'une logique de nouvelle tentative avec gestion des erreurs.

## Lire et récupérer des données d'une collection DocumentDB
<a name="reading-retrieving"></a>

L'interrogation de documents dans Amazon DocumentDB s'articule autour de plusieurs composants clés qui vous permettent de récupérer et de manipuler des données avec précision. La [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCollection.html#find()](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCollection.html#find())méthode est la requête fondamentale APIs dans les pilotes Java MongoDB. Il permet une extraction de données complexe avec de nombreuses options de filtrage, de tri et de projection des résultats. Outre la `find()` méthode, il [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Filters.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Filters.html)existe deux autres composants fondamentaux qui fournissent les éléments de base pour les opérations de requête dans les pilotes Java MongoDB.

La `Filters` classe est une classe utilitaire du pilote Java MongoDB qui fournit une API fluide pour créer des filtres de requêtes. Cette classe propose des méthodes d'usine statiques qui créent des instances d'`Bson`objets représentant diverses conditions de requête. Les méthodes les plus couramment utilisées incluent `eq()` les comparaisons d'égalité`gt()`,`lt()`,`gte()`,, et `lte()` les comparaisons numériques, `and()` la combinaison `or()` de plusieurs conditions, `in()` les tests d'appartenance à des tableaux et la correspondance `regex()` de modèles. `nin()` La classe est conçue pour être sûre et fournit une meilleure vérification au moment de la compilation par rapport aux requêtes basées sur des documents bruts, ce qui en fait l'approche préférée pour créer des requêtes DocumentDB dans les applications Java. La gestion des erreurs est robuste, avec des exceptions claires émises pour les constructions de filtres non valides.

`FindIterable`est une interface spécialisée conçue pour gérer le résultat de la `find()` méthode. Il fournit un ensemble complet de méthodes pour affiner et contrôler l'exécution des requêtes, ainsi qu'une API fluide pour le chaînage des méthodes. L'interface inclut des méthodes essentielles de modification des requêtes, telles que `limit()` la restriction du nombre de documents renvoyés, `skip()` la pagination, le classement `sort()` des résultats, `projection()` la sélection de champs spécifiques et la sélection `hint()` d'index. Les opérations de traitement par lots, de sauts et de limites `FindIterable` sont des outils essentiels de pagination et de gestion des données qui permettent de contrôler la manière dont les documents sont extraits et traités à partir de la base de données.

Batching (`batchSize`) contrôle le nombre de documents que DocumentDB renvoie au client en un seul aller-retour sur le réseau. Lorsque vous définissez une taille de lot, DocumentDB ne renvoie pas tous les documents correspondants en une seule fois, mais les renvoie par groupes de la taille de lot spécifiée. 

Skip vous permet de décaler le point de départ de vos résultats, en demandant essentiellement à DocumentDB de sauter un certain nombre de documents avant de commencer à renvoyer des correspondances. Par exemple, `skip(20)` contournera les 20 premiers documents correspondants. Ceci est couramment utilisé dans les scénarios de pagination dans lesquels vous souhaitez récupérer les pages de résultats suivantes. 

La limite limite le nombre total de documents pouvant être renvoyés par une requête. Lorsque vous le spécifiez`limit(n)`, DocumentDB arrête de renvoyer des documents après avoir renvoyé « n » documents, même s'il existe d'autres correspondances dans la base de données. 

`FindIterable`prend en charge les modèles d'itérateur et de curseur lors de la récupération de documents depuis Amazon DocumentDB. L'avantage de l'utilisation `FindIterable` d'un itérateur est qu'il permet le chargement différé des documents et qu'il ne récupère les documents que lorsque l'application le demande. Un autre avantage de l'utilisation de l'itérateur est que vous n'êtes pas responsable du maintien de la connexion au cluster et qu'aucune fermeture explicite de la connexion n'est donc requise. 

`FindIterable`fournissent également un support [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCursor.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-sync/com/mongodb/client/MongoCursor.html)permettant d'utiliser des modèles de curseur lors de l'utilisation de requêtes Amazon DocumentDB. `MongoCursor`est une implémentation spécifique au pilote Java MongoDB qui permet de contrôler les opérations de base de données et la gestion des ressources. Il implémente l'`AutoCloseable`interface, permettant une gestion explicite des ressources par le biais de try-with-resources blocs, ce qui est crucial pour fermer correctement les connexions aux bases de données et libérer les ressources du serveur. Par défaut, le curseur expire au bout de 10 minutes et DocumentDB ne vous permet pas de modifier ce comportement de temporisation. Lorsque vous travaillez avec des données groupées, assurez-vous de récupérer le lot de données suivant avant que le curseur n'expire. L'une des principales considérations à prendre en compte lors de son utilisation `MongoCursor` est qu'elle nécessite une fermeture explicite pour éviter les fuites de ressources.

Dans cette section, plusieurs exemples sont présentés pour`find()`, `Filters` et`FindIterable`.

L'exemple de code suivant montre comment récupérer un seul document `find()` à l'aide de son champ « RestaurantID » :

```
Document filter = new Document("restaurantId", "REST-21G145");
Document result = collection.find(filter).first();
```

Même si son utilisation `Filters` permet de mieux vérifier les erreurs lors de la compilation, le pilote Java vous permet également de spécifier un `Bson` filtre directement dans la `find()` méthode. L'exemple de code suivant transmet `Bson` le document à `find()` :

```
result = collection.find(new Document("$and", Arrays.asList(
    new Document("rating.totalReviews", new Document("$gt", 1000)),
    new Document("priceRange", "$$"))))
```

L'exemple de code suivant montre plusieurs exemples d'utilisation de la `Filters` classe avec `find()` :

```
FindIterable < Document > results;

// Exact match
results = collection.find(Filters.eq("name", "Thai Curry Palace"));

// Not equal
results = collection.find(Filters.ne("cuisine", "Thai"));

// find an element in an array
results = collection.find(Filters.in("features", Arrays.asList("Private Dining")));

// Greater than
results = collection.find(Filters.gt("rating.average", 3.5));

// Between (inclusive)
results = collection.find(Filters.and(
    Filters.gte("rating.totalReviews", 100),
    Filters.lte("rating.totalReviews", 200)));
// AND
results = collection.find(Filters.and(
    Filters.eq("cuisine", "Thai"),
    Filters.gt("rating.average", 4.5)));

// OR
results = collection.find(Filters.or(
    Filters.eq("cuisine", "Thai"),
    Filters.eq("cuisine", "American")));


// All document where the Field exists
results = collection.find(Filters.exists("michelin"));

// Regex
results = collection.find(Filters.regex("name", Pattern.compile("Curry", Pattern.CASE_INSENSITIVE)));

// Find all document where the array contain the list of value regardless of its order
results = collection.find(Filters.all("features", Arrays.asList("Private Dining", "Parking")));

// Array size
results = collection.find(Filters.size("features", 4));
```

L'exemple suivant montre comment enchaîner les opérations de `sort()``skip()`,`limit()`, et `batchSize()` sur un `FindIterable` objet. L'ordre dans lequel ces opérations sont effectuées influencera les performances de votre requête. À titre de bonne pratique, l'ordre de ces opérations doit être `sort()``projection()`,`skip()`, `limit()` et`batchSize()`.

```
FindIterable < Document > results = collection.find(Filters.gt("rating.totalReviews", 1000))
    // Sorting
    .sort(Sorts.orderBy(
        Sorts.descending("address.city"),
        Sorts.ascending("cuisine")))
    // Field selection
    .projection(Projections.fields(
        Projections.include("name", "cuisine", "priceRange"),
        Projections.excludeId()))

    // Pagination
    .skip(20)
    .limit(10)
    .batchSize(2);
```

L'exemple de code suivant montre la création d'un itérateur sur`FindIterable`. Il utilise la `forEach` construction de Java pour parcourir le jeu de résultats.

```
collection.find(Filters.eq("cuisine", "American")).forEach(doc -> System.out.println(doc.toJson()));
```

Dans le dernier exemple de `find()` code, il montre comment l'utiliser `cursor()` pour récupérer des documents. Il crée le curseur dans le bloc d'essai, ce qui garantit que le curseur se ferme lorsque le code quitte le bloc d'essai.

```
try (MongoCursor < Document > cursor = collection.find(Filters.eq("cuisine", "American"))
    .batchSize(25)
    .cursor()) {
    while (cursor.hasNext()) {
        Document doc = cursor.next();
        System.out.println(doc.toJson());
    }
} // Cursor automatically closed
```

## Mettre à jour des documents existants dans une collection DocumentDB
<a name="updating-documents"></a>

Amazon DocumentDB fournit des mécanismes flexibles et puissants pour modifier des documents existants et en insérer de nouveaux lorsqu'ils n'existent pas. Le pilote Java MongoDB propose plusieurs méthodes de mise à jour : `updateOne()` pour les mises à jour d'un seul document, `updateMany()` pour les mises à jour de plusieurs documents et `replaceOne()` pour le remplacement complet du document. Outre ces trois méthodes, [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Updates.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/Updates.html), et d'autres composants fondamentaux fournissent [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/UpdateResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/UpdateResult.html)les éléments de base pour les opérations de mise à jour dans les pilotes Java MongoDB. 

La `Updates` classe du pilote Java MongoDB est une classe utilitaire qui fournit des méthodes d'usine statiques pour créer des opérateurs de mise à jour. Il sert de générateur principal pour créer des opérations de mise à jour d'une manière sûre et lisible. Des méthodes de base telles que `set()``unset()`, et `inc()` permettent de modifier directement les documents. La puissance de cette classe devient évidente lorsque vous combinez plusieurs opérations à l'aide de la `Updates.combine()` méthode qui permet d'exécuter plusieurs opérations de mise à jour de manière atomique, garantissant ainsi la cohérence des données.

`UpdateOptions`est une puissante classe de configuration du pilote Java de MongoDB qui fournit des fonctionnalités de personnalisation essentielles pour les opérations de mise à jour de documents. Deux aspects importants de cette classe sont la prise en charge des filtres upsert et matriciels pour les opérations de mise à jour. La fonction Upsert, activée via`upsert(true)`, permet de créer de nouveaux documents lorsqu'aucun document correspondant n'est trouvé lors d'une opération de mise à jour. Grâce à cela`arrayFilters()`, l'opération de mise à jour peut mettre à jour avec précision les éléments du tableau qui répondent à des critères spécifiques.

`UpdateResult`dans le pilote Java de MongoDB, fournit le mécanisme de feedback détaillant le résultat d'une opération de mise à jour. Cette classe encapsule trois indicateurs clés : le nombre de documents correspondant aux critères de mise à jour (`matchedCount`), le nombre de documents réellement modifiés (`modifiedCount`) et les informations relatives à tout document modifié (). `upsertedId` Il est essentiel de comprendre ces métriques pour gérer correctement les erreurs, vérifier les opérations de mise à jour et maintenir la cohérence des données dans les applications.

### Mettre à jour et remplacer un seul document
<a name="update-single-doc"></a>

Dans DocumentDB, la mise à jour d'un seul document peut être effectuée à l'aide de la méthode updateOne (). Cette méthode utilise un paramètre de filtre, généralement fourni par la `Filters` classe, pour identifier le document à mettre à jour, un paramètre `Updat` e qui détermine le ou les champs à mettre à jour et un `UpdateOptions` paramètre facultatif pour définir différentes options pour la mise à jour. L'utilisation de `updateOne()` cette méthode ne mettra à jour que le premier document correspondant aux critères de sélection. L'exemple de code suivant met à jour un seul champ d'un document :

```
collection.updateOne(Filters.eq("restaurantId", "REST-Y2E9H5"),
    Updates.set("name", "Amazing Japanese sushi"));
```

Pour mettre à jour plusieurs champs dans un document, utilisez `updateOne()` avec `Update.combine()` comme indiqué dans l'exemple suivant. Cet exemple montre également comment ajouter un élément à un tableau du document.

```
List<Bson> updates = new ArrayList<>();
// Basic field updates
updates.add(Updates.set("name", "Shanghai Best"));
// Array operations
updates.add(Updates.addEachToSet("features", Arrays.asList("Live Music")));
// Counter updates
updates.add(Updates.inc("rating.totalReviews", 10));
// Combine all updates
Bson combinedUpdates = Updates.combine(updates);
// Execute automic update with one call
collection.updateOne(Filters.eq("restaurantId","REST-1J83NH"), combinedUpdates);
```

L'exemple de code suivant montre comment mettre à jour un document dans la base de données. Si le document spécifié n'existe pas, l'opération l'insère automatiquement en tant que nouveau document. Ce code montre également comment utiliser les métriques disponibles via l'`UpdateResult`objet.

```
Bson filter = Filters.eq("restaurantId", "REST-0Y9GL0");
Bson update = Updates.set("cuisine", "Indian");
// Upsert operation
UpdateOptions options = new UpdateOptions().upsert(true);
UpdateResult result = collection.updateOne(filter, update, options);

if (result.getUpsertedId() != null) {
   	System.out.println("Inserted document with _id: " + result.getUpsertedId());
} else {
    	System.out.println("Updated " + result.getModifiedCount() + " document(s)");
}
```

L'exemple de code suivant montre comment remplacer complètement un document existant par un nouveau document à l'aide de `replaceOne()` cette méthode, plutôt que de mettre à jour des champs individuels. La `replaceOne()` méthode remplace l'intégralité du document, en préservant uniquement le `_id` champ de l'original. Si plusieurs documents répondent aux critères du filtre, seul le premier document rencontré est remplacé.

```
Document newDocument = new Document()
                .append("restaurantId", "REST-0Y9GL0")
                .append("name", "Bhiryani Adda")
                .append("cuisine", "Indian")
                .append("rating", new Document()
                        .append("average", 4.8)
                        .append("totalReviews", 267))
                .append("features", Arrays.asList("Outdoor Seating", "Live Music"));

UpdateResult result = collection.replaceOne(
                    Filters.eq("restaurantId", "REST-0Y9GL0"),
                    newDocument);
System.out.printf("Modified %d document%n", result.getModifiedCount());
```

### Mettre à jour plusieurs documents
<a name="update-multiple-docs"></a>

Il existe deux manières de mettre à jour simultanément plusieurs documents d'une collection. Vous pouvez utiliser la `updateMany()` méthode ou utiliser la méthode [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/model/UpdateManyModel.html)avec la `bulkWrite()` méthode. La `updateMany()` méthode utilise un paramètre de filtre pour sélectionner les documents à mettre à jour, le `Update` paramètre pour identifier les champs à mettre à jour et un `UpdateOptions` paramètre facultatif pour spécifier les options de mise à jour.

L'exemple de code suivant illustre l'utilisation de la `updateMany()` méthode :

```
Bson filter = Filters.and(
    Filters.in("features", Arrays.asList("Private Dining")),
    Filters.eq("cuisine", "Thai"));
UpdateResult result1 = collection.updateMany(filter, Updates.set("priceRange", "$$$"));
```

L'exemple de code suivant illustre la `bulkWrite()` méthode utilisant la même mise à jour :

```
BulkWriteOptions options = new BulkWriteOptions().ordered(false);
List < WriteModel < Document >> updates = new ArrayList < > ();
Bson filter = Filters.and(
    Filters.in("features", Arrays.asList("Private Dining")),
    Filters.eq("cuisine", "Indian"));
Bson updateField = Updates.set("priceRange", "$$$");
updates.add(new UpdateManyModel < > (filter, updateField));
BulkWriteResult result = collection.bulkWrite(updates, options);
System.out.printf("Modified %d document%n", result.getModifiedCount());
```

## Supprimer des documents d'une collection DocumentDB
<a name="deleting-documents"></a>

Le pilote Java MongoDB permet `deleteOne()` de supprimer un seul document et `deleteMany()` de supprimer plusieurs documents répondant à des critères spécifiques. Tout comme la mise à jour, l'opération de suppression peut également être utilisée avec la `bulkWrite()` méthode. Les deux `deleteOne()` et `deleteMany()` renvoient un [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/DeleteResult.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/client/result/DeleteResult.html)objet fournissant des informations sur le résultat de l'opération, y compris le nombre de documents supprimés. Voici un exemple d'utilisation `deleteMany()` pour supprimer plusieurs documents :

```
Bson filter = Filters.and(
    Filters.eq("cuisine", "Thai"),
    Filters.lt("rating.totalReviews", 50));
DeleteResult result = collection.deleteMany(filter);
System.out.printf("Deleted %d document%n", result.getDeletedCount());
```

## Gestion des erreurs avec la logique de nouvelle tentative
<a name="error-handling"></a>

Une stratégie robuste de gestion des erreurs pour Amazon DocumentDB doit implémenter la catégorisation des erreurs en erreurs réessayables (comme les délais d'attente réseau, problèmes de connexion) et les erreurs non réessayables (comme les échecs d'authentification, les requêtes non valides). En cas d'échec d'opération dû à des erreurs qui doivent être réessayées, il doit implémenter un délai entre chaque nouvelle tentative ainsi que le nombre maximum de tentatives de tentative. Les opérations CRUD doivent se situer dans un bloc trycatch contenant les captures [https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoException.html](https://mongodb.github.io/mongo-java-driver/5.3/apidocs/mongodb-driver-core/com/mongodb/MongoException.html)et ses sous-classes. En outre, il devrait inclure la surveillance et l'enregistrement des erreurs pour une visibilité opérationnelle. Voici un exemple de code qui montre comment implémenter la gestion des erreurs de nouvelle tentative :

```
int MAX_RETRIES = 3;
int INITIAL_DELAY_MS = 1000;
int retryCount = 0;

while (true) {
    try {
        crud_operation(); //perform crud that will throw MongoException or one of its subclass
        break;
    } catch (MongoException e) {
        if (retryCount < MAX_RETRIES) {
            retryCount++;
            long delayMs = INITIAL_DELAY_MS * (long) Math.pow(2, retryCount - 1);
            try {
                TimeUnit.MILLISECONDS.sleep(delayMs);
            } catch (InterruptedException t) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Retry interrupted", t);
            }
            continue;
        } else
            throw new RuntimeException("Crud operation failed", e);
    }
}
```