Le traitement par lot vous permet d'exécuter plusieurs opérations en une seule requête au lieu d'envoyer chaque opération individuellement.
Remarque : Pour effectuer des opérations par lot, vous devez utiliser une version récente de votre bibliothèque cliente de l'API Google Data. Les opérations par lot ne sont pas compatibles avec la bibliothèque cliente JavaScript.
Audience
Ce document est destiné aux programmeurs qui souhaitent envoyer plusieurs opérations en une seule requête à l'aide du traitement par lot.
Dans ce document, nous partons du principe que vous maîtrisez la bibliothèque cliente Java GData. Les exemples de ce document montrent comment utiliser la bibliothèque cliente Java pour exécuter des opérations par lot.
Les exemples fournis dans ce document sont spécifiques à l'API de données Google Base. Cependant, d'autres services peuvent également fournir des fonctionnalités de traitement par lot.
Remarque : Le protocole et les procédures générales sont les mêmes pour les autres bibliothèques clientes, mais les méthodes spécifiques d'exécution des requêtes par lot peuvent différer. Veuillez consulter la documentation spécifique à la bibliothèque cliente.
Introduction
Avec un flux par lot GData, vous pouvez collecter plusieurs opérations d'insertion, de mise à jour, de suppression et de requête, puis les envoyer et les exécuter simultanément.
Par exemple, le flux suivant comprend quatre opérations:
<feed>
<entry>
<batch:operation type="insert"/>
... what to insert ...
</entry>
<entry>
<batch:operation type="update"/>
... what to update ...
</entry>
<entry>
<batch:operation type="delete"/>
... what to delete ...
</entry>
<entry>
<batch:operation type="query"/>
... what to query ...
</entry>
</feed>
Le service effectuera autant de modifications demandées que possible et renverra des informations sur l'état permettant d'évaluer le succès ou l'échec de chaque opération.
Le service tente d'exécuter chacune des opérations d'un lot, même si certaines des opérations incluses dans le lot échouent.
Envoyer une requête par lot
Une requête par lot doit être envoyée sous forme de requête HTTP POST à une URL de traitement par lot. Chaque flux accepte des opérations par lot différentes. Les flux en lecture seule ne sont compatibles qu'avec les requêtes.
Pour savoir si un flux donné accepte les opérations par lot, vous pouvez l'interroger. Si le flux contient un lien "lot" au niveau du flux, cela signifie que le flux accepte les opérations par lot.
Une relation de lien "par lot" est un élément <link> avec rel="http://schemas.google.com/g/2005#batch". L'attribut href de la relation "link" définit l'URL de publication des documents du flux pour les opérations par lot.
Par exemple, si vous exécutez GET http://www.google.com/base/feeds/items (le flux d'éléments standard de Google Base), vous pouvez obtenir la réponse suivante :
<feed xmlns=...
<id>http://www.google.com/base/feeds/items</id>
<link rel="http://schemas.google.com/g/2005#feed"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items"/>
<link rel="http://schemas.google.com/g/2005#post"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items"/>
<link rel="http://schemas.google.com/g/2005#batch"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/batch"/>
...
</feed>
Dans cet exemple, l'URL de traitement par lot est http://www.google.com/base/feeds/items/batch.
Écrire un flux d'opérations par lot
Un flux d'opérations contient une liste d'entrées à insérer, mettre à jour, supprimer ou interroger.
Chaque opération est définie par un élément <batch:operation type="insert|update|delete|query"/>.
Cet élément peut être un enfant direct d'un élément <feed>, un enfant direct de n'importe quelle entrée du flux ou les deux. Lorsqu'elle est incluse dans une entrée, elle spécifie l'opération à exécuter pour cette entrée spécifique. Lorsqu'il est inclus dans le flux, cet élément spécifie l'opération par défaut à exécuter sur toutes les entrées qui n'ont pas d'élément <batch:operation/>.
Lorsque ni l'entrée, ni le flux ne spécifient d'opération, l'opération par défaut est insert.
Les applications ne doivent pas appliquer plusieurs opérations à la même entrée dans un même flux par lot. Les résultats sont indéterminés si vous spécifiez plusieurs opérations pour la même entrée.
Pour améliorer les performances, il est possible que les opérations ne soient pas traitées dans l'ordre dans lequel elles ont été demandées. Toutefois, le résultat final est toujours le même que si les entrées ont été traitées dans l'ordre.
Le nombre d'octets XML que vous envoyez au serveur ne doit pas dépasser 1 Mo (1 048 576 octets). En général, le nombre d'opérations que vous pouvez demander est illimité tant que la taille totale en octets ne dépasse pas 1 Mo. Toutefois, certains services peuvent imposer des contraintes supplémentaires.
Pour utiliser les opérations par lot, vous devez ajouter la déclaration de l'espace de noms par lot comme attribut à l'élément <feed>:
<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/" ... xmlns:batch="http://schemas.google.com/gdata/batch">
Opérations d'insertion
Une opération d'insertion est indiquée comme suit:
<batch:operation type="insert">
Une opération d'insertion est équivalente à POSTing de l'entrée. Lorsque l'opération réussit, l'intégralité du contenu de l'entrée est renvoyée, avec un élément <id> du document mis à jour et un élément <batch:status code="201"/>.
Voici un exemple de requête d'insertion ayant abouti:
<entry> <title type="text">...</title> <content type="html">...</content> <batch:id>itemA</batch:id> <batch:operation type="insert"/> <g:item_type>recipes</g:item_type> ... </entry>
Voici un exemple de réponse à une requête d'insertion ayant abouti:
<entry>
<batch:status code="201"/>
<batch:id>itemA</batch:id>
<batch:operation type="insert"/>
<id>http://www.google.com/base/feeds/items/17437536661927313949</id>
<link rel="self" type="application/atom+xml"
href="http://www.google.com/base/feeds/items/17437536661927313949"/>
<title type="text">...</title>
<content type="html">...</content>
<g:item_type>recipes</g:item_type>
...
</entry>
Opérations de mise à jour
<batch:operation type="update">
Une opération de mise à jour équivaut à exécuter une opération PUT sur l'URL référencée par l'élément <id> de l'entrée. Lorsque l'opération aboutit, l'intégralité du contenu de l'entrée est renvoyée avec un élément <batch:status
code="200"/>.
Remarque : Avec certains flux, vous devez également spécifier le lien rel="edit" de l'entrée avec des requêtes de mise à jour par lots. Cela inclut les flux qui sont compatibles avec la simultanéité optimiste de type v1 de Google Data Protocol, ainsi que ceux qui n'ont pas d'ID correspondant à des URL.
Voici un exemple de demande de mise à jour:
<entry> <id>http://www.google.com/base/feeds/items/17437536661927313949</id> <batch:operation type="update"/> ... </entry>
Voici un exemple de réponse réussie:
<entry> <batch:status code="200"/> <id>http://www.google.com/base/feeds/items/17437536661927313949</id> <batch:operation type="update"/> ... </entry>
Remarque : Certains flux utilisent des ETag forts pour vous empêcher de modifier involontairement les modifications d'une autre personne. Lorsque vous effectuez une requête de mise à jour par lot pour une entrée de l'un de ces flux, vous devez fournir la valeur ETag dans l'attribut gd:etag de l'entrée. Exemple : <entry gd:etag="'F08NQAxFdip7IWA6WhVR'">...<batch:operation type="update"/>...
Opérations de mise à jour partielle
Pour les flux compatibles avec les mises à jour partielles, vous pouvez également les utiliser dans les requêtes par lot. Une opération de mise à jour partielle équivaut à exécuter une opération PATCH sur l'URL référencée par l'élément <id> de l'entrée. Lorsque l'opération aboutit, l'intégralité du contenu de l'entrée est renvoyée avec un élément <batch:status
code="200"/>.
Remarque : Avec certains flux, vous devez également spécifier le lien rel="edit" de l'entrée avec des requêtes de mise à jour par lots. Cela inclut les flux qui sont compatibles avec la simultanéité optimiste de type v1 de Google Data Protocol, ainsi que ceux qui n'ont pas d'ID correspondant à des URL.
<batch:operation type="patch"/>
Voici un exemple de requête de mise à jour partielle:
<entry gd:fields="content" gd:etag="FE8LQQJJeSp7IWA6WhVa"> <id>http://www.google.com/calendar/feeds/jo@gmail.com/private/full/entryID</id> <batch:operation type="patch"/> <title>New title</title> </entry>
Voici un exemple de réponse réussie:
<entry gd:etag="FE8LQQJJeSp7IWA6WhVa"> <batch:status code="200"/> <id>http://www.google.com/calendar/feeds/jo@gmail.com/private/full/entryID</id> <batch:operation type="patch"/> <title>New title</title> <content></content> ...rest of the entry... </entry>
Supprimer des opérations
<batch:operation type="delete">
Une opération de suppression équivaut à exécuter une opération DELETE sur l'URL référencée par l'élément <id> de l'entrée. Pour une opération de suppression, il vous suffit d'envoyer un élément <id> pour supprimer l'entrée. Toutes les autres informations que vous fournissez dans des éléments qui ne figurent pas dans l'espace de noms batch: seront ignorées. Lorsque l'opération réussit, une entrée avec le même ID est renvoyée avec un élément <batch:status
code="200"/>.
Remarque:Avec certains flux, vous devez également spécifier le lien rel="edit" de l'entrée avec une requête de suppression groupée. Cela inclut les flux qui sont compatibles avec la simultanéité optimiste de type v1 de Google Data Protocol, ainsi que ceux qui n'ont pas d'ID correspondant à des URL.
Voici un exemple de demande de suppression:
<entry> <batch:operation type="delete"/> <id>http://www.google.com/base/feeds/items/17437536661927313949</id> </entry>
Voici un exemple de réponse réussie:
<entry> <batch:operation type="delete"/> <id>http://www.google.com/base/feeds/items/17437536661927313949</id> <batch:status code="200" reason="Success"/> </entry>
Remarque: Certains flux utilisent des ETag forts pour vous empêcher de modifier involontairement les modifications d'une autre personne. Lorsque vous effectuez une requête de suppression groupée pour une entrée de l'un de ces flux, vous devez fournir la valeur ETag dans l'attribut gd:etag de l'entrée. Exemple : <entry gd:etag="'F08NQAxFdip7IWA6WhVR'">...<batch:operation type="delete"/>...
Opérations de requête
<batch:operation type="query">
Une opération de requête équivaut à exécuter une opération GET sur l'URL référencée par l'élément <id> de l'entrée. Lorsque l'opération réussit, l'intégralité du contenu de l'entrée est renvoyée.
Remarque : Avec certains flux, vous devez également spécifier le lien rel="self" de l'entrée avec des requêtes de requête par lot. Cela inclut les flux dont l'ID n'est pas une URL.
Voici un exemple de requête:
<entry> <id>http://www.google.com/base/feeds/items/1743753666192313949</id> <batch:operation type="query"/> </entry>
Voici un exemple de réponse réussie:
<entry> <id>http://www.google.com/base/feeds/items/1743753666192313949</id> <batch:operation type="query"/> <batch:status code="200" reason="Success"/> ... </entry>
Opérations de suivi
Les résultats des entrées GData ne sont pas nécessairement renvoyés dans le même ordre que la requête. Vous pouvez suivre une opération tout au long de sa durée de vie à l'aide d'un identifiant.
Pour les opérations de mise à jour, de suppression et de requête, vous pouvez utiliser l'ID de l'entrée elle-même pour suivre l'opération.
Étant donné qu'aucun ID n'existe pour les opérations d'insertion, vous pouvez transmettre un identifiant d'opération. Cet identifiant permet d'associer les entrées de résultat aux entrées de requête. L'identifiant d'opération est transmis dans l'élément <batch:id>.
Pour chaque opération, GData renvoie une réponse indiquant si l'opération a réussi ou échoué. Chaque réponse identifie l'entrée associée. En cas de mise à jour, de suppression, de requête ou d'opération d'insertion, l'ID d'entrée est toujours renvoyé. Si vous avez spécifié un ID de lot, il est également renvoyé. Étant donné que les opérations d'insertion ayant échoué n'ont pas d'ID d'entrée associé, seul l'ID de lot est renvoyé.
À l'aide de l'identifiant de chaque opération, vous pouvez relancer uniquement les opérations ayant échoué, au lieu de devoir renvoyer l'ensemble des opérations.
Le contenu de <batch:id> est une valeur de chaîne définie par le client et renvoyée dans l'entrée de réponse correspondante.Vous pouvez spécifier n'importe quelle valeur qui aidera le client à mettre en corrélation la réponse avec l'entrée de la requête d'origine. Cet élément sera reproduit tel quel dans l'entrée correspondante, même si l'opération a échoué. GData ne stocke ni n'interprète jamais le contenu de cet ID de lot.
L'exemple suivant présente un flux d'opérations par lot. Notez que l'élément <batch:id> ajoute le libellé itemB à cette opération.
<entry> <title type="text">...</title> <content type="html">...</content> <batch:id>itemB</batch:id> <batch:operation type="insert"/> <g:item_type>recipes</g:item_type> </entry>
L'exemple suivant montre l'entrée d'état par lot renvoyée en réponse à cette opération.
<entry>
<id>http://www.google.com/base/feeds/items/2173859253842813008</id>
<published>2006-07-11T14:51:43.560Z</published>
<updated>2006-07-11T14:51: 43.560Z</updated>
<title type="text">...</title>
<content type="html">...</content>
<link rel="self"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/2173859253842813008"/>
<link rel="edit"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/2173859253842813008"/>
<g:item_type>recipes</g:item_type>
<batch:operation type="insert"/>
<batch:id>itemB</batch:id>
<batch:status code="201" reason="Created"/>
</entry>
Gérer les codes d'état
Les codes d'état sont exprimés par l'élément suivant:
<batch:status code="200|201|404|500|..." reason="reason" [content-type="type"]/>
Chaque entrée du flux de réponse contient un élément <batch:status>. Cet élément décrit ce qui s'est passé lors de l'exécution de l'opération. Il imite la réponse HTTP qui aurait été envoyée si l'opération avait été envoyée individuellement, plutôt que dans un flux de traitement par lot.
Vous devez vérifier l'élément <batch:status> de chaque entrée de la réponse pour savoir si l'opération associée a bien été traitée. L'attribut code="n" contient un code d'état GData.
Description des états
L'attribut reason="reason" de l'élément <batch:status> contient une explication plus détaillée de l'état de l'opération.
Type de contenu
L'attribut content-type="type" de l'élément <batch:status> contient le type MIME des données contenues dans l'élément <batch:status>. Cela correspond à l'en-tête Content-Type d'une réponse d'état HTTP. Cet attribut est facultatif.
Lorsque le type de contenu est défini, le corps de l'élément <batch:status> décrit le problème rencontré lors du traitement de l'entrée.
Identifier les opérations interrompues
L'élément suivant est inclus dans la réponse à une opération interrompue:
<batch:interrupted reason="reason" success="N" failures="N" parsed="N">
Cet élément signifie que le traitement par lot a été interrompu et que toutes les tentatives de récupération de la cause de l'interruption ont échoué. Certaines entrées ont peut-être déjà été traitées. Toutes les entrées qui n'avaient pas été signalées comme réussies avant ce point ont été abandonnées.
Cet élément est très inhabituel et indique généralement que le flux envoyé dans le corps de la requête n'était pas au bon format XML.
Comme pour l'élément <batch:status>, vous trouverez un court code d'état dans l'attribut reason. Vous pouvez également trouver une réponse plus longue à l'intérieur de l'élément.
Exemples d'opérations par lot et de flux d'état
Voici un flux d'opérations par lot qui pourrait être envoyé au serveur. Ce flux demande au serveur de supprimer deux entrées et d'en ajouter deux nouvelles. Notez que l'élément <feed> doit inclure un espacement d'espaces de noms pour le lot, comme indiqué dans l'exemple ci-dessous.
POST : http://www.google.com/base/feeds/items/batch
<?xml version="1.0" encoding="UTF-8"?>
<feed
xmlns="http://www.w3.org/2005/Atom"
xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
xmlns:g="http://base.google.com/ns/1.0"
xmlns:batch="http://schemas.google.com/gdata/batch">
<title type="text">My Batch Feed</title>
<entry>
<id>http://www.google.com/base/feeds/items/13308004346459454600</id>
<batch:operation type="delete"/>
</entry>
<entry>
<id>http://www.google.com/base/feeds/items/17437536661927313949</id>
<batch:operation type="delete"/>
</entry>
<entry>
<title type="text">...</title>
<content type="html">...</content>
<batch:id>itemA</batch:id>
<batch:operation type="insert"/>
<g:item_type>recipes</g:item_type>
</entry>
<entry>
<title type="text">...</title>
<content type="html">...</content>
<batch:id>itemB</batch:id>
<batch:operation type="insert"/>
<g:item_type>recipes</g:item_type>
</entry>
</feed>
Supposons que les deux insertions aient fonctionné, mais que l'une des deux suppressions ait échoué. Dans ce cas, le flux d'état du lot peut se présenter comme suit. Notez que les entrées ont été réorganisées par rapport au flux d'opérations par lot.
<?xml version="1.0" encoding="UTF-8"?>
<feed
xmlns="http://www.w3.org/2005/Atom"
xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
xmlns:g="http://base.google.com/ns/1.0"
xmlns:batch="http://schemas.google.com/gdata/batch">
<id>http://www.google.com/base/feeds/items</id>
<updated>2006-07-11T14:51:42.894Z</updated>
<title type="text">My Batch</title>
<link rel="http://schemas.google.com/g/2005#feed"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items"/>
<link rel="http://schemas.google.com/g/2005#post"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items"/>
<link rel=" http://schemas.google.com/g/2005#batch"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/batch"/>
<entry>
<id>http://www.google.com/base/feeds/items/2173859253842813008</id>
<published>2006-07-11T14:51:43.560Z</published>
<updated>2006-07-11T14:51: 43.560Z</updated>
<title type="text">...</title>
<content type="html">...</content>
<link rel="self"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/2173859253842813008"/>
<link rel="edit"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/2173859253842813008"/>
<g:item_type>recipes</g:item_type>
<batch:operation type="insert"/>
<batch:id>itemB</batch:id>
<batch:status code="201" reason="Created"/>
</entry>
<entry>
<id>http://www.google.com/base/feeds/items/11974645606383737963</id>
<published>2006-07-11T14:51:43.247Z</published>
<updated>2006-07-11T14:51: 43.247Z</updated>
<title type="text">...</title>
<content type="html">...</content>
<link rel="self"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/11974645606383737963"/>
<link rel="edit"
type="application/atom+xml"
href="http://www.google.com/base/feeds/items/11974645606383737963"/>
<g:item_type>recipes</g:item_type>
<batch:operation type="insert"/>
<batch:id>itemA</batch:id>
<batch:status code="201" reason="Created"/>
</entry>
<entry>
<id>http://www.google.com/base/feeds/items/13308004346459454600</id>
<updated>2006-07-11T14:51:42.894Z</updated>
<title type="text">Error</title>
<content type="text">Bad request</content>
<batch:status code="404"
reason="Bad request"
content-type="application/xml">
<errors>
<error type="request" reason="Cannot find item"/>
</errors>
</batch:status>
</entry>
<entry>
<id>http://www.google.com/base/feeds/items/17437536661927313949</id>
<updated>2006-07-11T14:51:43.246Z</updated>
<content type="text">Deleted</content>
<batch:operation type="delete"/>
<batch:status code="200" reason="Success"/>
</entry>
</feed>
Utiliser la fonctionnalité de traitement par lot de la bibliothèque cliente Java GData
Cette section explique comment utiliser la fonctionnalité de traitement par lot de la bibliothèque cliente Java GData pour envoyer un groupe de requêtes d'insertion, de mise à jour et/ou de suppression.
Les exemples fournis dans cette section utilisent les API Google Base.
Importez d'abord les classes dont vous aurez besoin, en plus des classes GData et Google Base standards:
import com.google.gdata.data.batch.*; import com.google.api.gbase.client.*;
Pour envoyer une requête par lot, vous devez obtenir l'URL du lot à partir d'un flux. L'extrait de code suivant montre comment procéder, en supposant que feed est un objet GoogleBaseFeed contenant des informations sur un flux:
Link batchLink = feed.getLink(Link.Rel.FEED_BATCH, Link.Type.ATOM);
if (batchLink != null) {
URL batchUrl = new URL(batchLink.getHref());
... // batch handling
} else {
// batching is not supported for this feed
}
L'extrait de code suivant prépare un flux qui insère deux entrées en une seule opération:
GoogleBaseEntry entry1 = new GoogleBaseEntry(); ... // initialize entry 1 content BatchUtils.setBatchId(entry1, "A"); // A is the local batch ID for this entry feed.addEntry(entry1); GoogleBaseEntry entry2 = new GoogleBaseEntry(); ... // initialize entry 2 content BatchUtils.setBatchId(entry2, "B"); // B is the local batch ID for this entry feed.addEntry(entry2);
Dans cet exemple, le code n'indique jamais explicitement que l'opération à effectuer pour ces entrées est insert. Vous n'avez pas besoin de le préciser explicitement, car l'insertion est l'opération par défaut.
Pour envoyer le flux de traitement par lot et recevoir les résultats, appelez la méthode Service.batch.
Comme Service.insert, Service.batch renvoie les entrées insérées avec de nouvelles valeurs <atom:id> définies. Les entrées renvoyées sont contenues dans un objet GoogleBaseFeed.
Si vous souhaitez supprimer une troisième entrée (que vous avez déjà récupérée et stockée dans entry3) en même temps que vous insérez les deux autres entrées, vous pouvez utiliser le code suivant:
GoogleBaseEntry toDelete = new GoogleBaseEntry(); toDelete.setId(entry3.getId()); BatchUtils.setBatchOperationType(toDelete, BatchOperationType.DELETE); feed.addEntry(toDelete); GoogleBaseFeed result = service.batch(batchUrl, feed);
Ici, service est une instance de com.google.gdata.client.Service.
Si vous souhaitez mettre à jour une entrée, spécifiez OperationType.UPDATE et initialisez-la avec les modifications souhaitées plutôt que de la laisser vide.
Ces exemples utilisent l'API de données Google Base. Si vous utilisez service.batch avec un autre type de service GData, remplacez les classes GoogleBaseFeed, GoogleBaseEntry et GoogleBaseService par les classes de flux, d'entrée et de service appropriées.
Les résultats d'une opération par lot ne sont pas nécessairement renvoyés dans l'ordre dans lequel ils ont été demandés. Dans l'exemple ci-dessus, le flux de résultats peut très bien contenir entry2, puis entry1. Vous ne devez jamais supposer que les entrées sont renvoyées dans un ordre particulier.
Votre flux d'opérations par lot doit attribuer un ID de lot unique à chaque opération d'insertion, comme expliqué dans la section Suivre les opérations. Dans les exemples ci-dessus, les ID de lot sont A et B. Par conséquent, pour connaître l'état des opérations demandées, vous devez itérer sur les entrées du flux de lots renvoyé et comparer leur ID de lot ou d'entrée comme suit:
for (GoogleBaseEntry entry : result.getEntries()) {
String batchId = BatchUtils.getBatchId(entry);
if (BatchUtils.isSuccess(entry)) {
if ("A".equals(batchId)) {
entry1 = entry; }
else if ("B".equals(batchId)) {
entry2 = entry; }
else if (BatchUtils.getBatchOperationType(entry)
== BatchOperationType.DELETE) {
System.out.println("Entry " + entry.getId() +
" has been deleted successfully.");
}
} else {
BatchStatus status = BatchUtils.getBatchStatus(entry);
System.err.println(batchId + " failed (" +
status.getReason() + ") " + status.getContent());
}
}
Chaque entrée trouvée dans le flux est associée à un objet BatchStatus.
L'objet BatchStatus contient un code de retour HTTP et une réponse qui décrit le problème rencontré lors du traitement de l'entrée. Vous devez vérifier le code de retour HTTP de chaque entrée pour savoir si l'opération a réussi.
Dans l'exemple ci-dessus, la vérification est effectuée par la méthode de commodité BatchUtils.isSuccess.
Dans ce cas, cela équivaut à BatchUtils.getBatchStatus(entry) < 300.
Les codes d'état et les réponses sont décrits plus en détail sur la page Gérer les codes d'état.