ComposantsComponents

ComposantsComponents › Fichier › LectureFile › Input

tFileInputJSON

tFileInputJSON

Fichier › LectureFile › Input Internet

Lit un fichier JSON et en tire des lignes : une requête de boucle désigne les éléments répétés, un par ligne (les objets d'un tableau, le plus souvent), et une requête par colonne lit chaque valeur dans l'élément. Les requêtes s'écrivent en JsonPath ($.customers[*], address.city), ou en XPath sur le JSON converti en XML. Le fichier peut aussi être lu depuis une URL. Reads a JSON file and turns it into rows: a loop query designates the repeated elements, one per row (most often the objects of an array), and one query per column reads each value in the element. Queries are written in JsonPath ($.customers[*], address.city), or in XPath on the JSON converted to XML. The file can also be read from a URL.

EntréeInput

Aucune : il commence son sous-job. Sinon un lien Iterate : un fichier par itération. None: it starts its subjob. Otherwise one Iterate link: one file per iteration.

SortieOutput

Main une ligne par élément de la boucle.one row per loop element.
Reject les lignes dont une valeur ne se convertit pas, avec errorMessage ; absent si Arrêter en cas d'erreur est coché.the rows with a value that does not convert, with errorMessage; absent if Die on error is checked.

Déclencheurs en sortieOutput triggers

On Subjob Ok On Subjob Error On Component Ok On Component Error Run if

UtilisationUsage

Au début d'un fluxAt the start of a flow

row1 (Main) tFileInputJSON_1 tLogRow_1

Le cas courant : chaque objet du tableau désigné par la boucle devient une ligne du flux, transmise au composant suivant (ici un tLogRow, qui l'affiche). The common case: each object of the array designated by the loop becomes a row of the flow, passed to the next component (here a tLogRow, which displays it).

Plusieurs fichiersSeveral files

Iterate row1 (Main) tFileList_1 tFileInputJSON_1 tFileOutputDelimited_1

Le tFileList donne un fichier à chaque itération ; le Nom de fichier le reprend : ((String) globalMap.get("tFileList_1_CURRENT_FILEPATH")). The tFileList gives one file at each iteration; the Filename takes it: ((String) globalMap.get("tFileList_1_CURRENT_FILEPATH")).

  1. Déposez le tFileInputJSON depuis la famille Fichier › Lecture (ou Internet) de la palette. Drop the tFileInputJSON from the File › Input (or Internet) family of the palette.
  2. Indiquez le Nom de fichier, ou cochez Utiliser l'URL et donnez l'adresse. Set the Filename, or check Use Url and give the address.
  3. Décrivez les colonnes dans le Schéma : la table Mapping reçoit une ligne par colonne. Describe the columns in the Schema: the Mapping table gets one row per column.
  4. Laissez Lu par sur JSONPath, écrivez la Requête de boucle Json ("$.customers[*]"), puis la requête de chaque colonne, relative à l'élément de la boucle ("name", "address.city"). Leave Read By on JsonPath, write the Loop Json query ("$.customers[*]"), then the query of each column, relative to the loop element ("name", "address.city").
  5. Vérifiez l'Encodage dans les Paramètres avancés : "UTF-8" par défaut, comme le veut JSON. Check the Encoding in the Advanced settings: "UTF-8" by default, as JSON requires.

Trois modes de lectureThree read modes

Le paramètre Lu par choisit le modèle de code généré ; chaque mode a sa requête de boucle, sa table Mapping et ses bibliothèques. The Read By setting chooses the generated code template; each mode has its own loop query, Mapping table and libraries.

JsonPath (défautdefault)

Bibliothèque Jayway json-path. La boucle donne la liste des éléments ; chaque requête de colonne est lue dans l'élément courant. Les valeurs restent attachées à leur élément : c'est le mode à choisir. Jayway json-path library. The loop gives the list of elements; each column query is read in the current element. Values stay attached to their element: this is the mode to choose.

JsonPath sans boucleJsonPath without loop

Ancien mode, par le moteur JavaScript de Java. Pas de boucle : chaque colonne a une requête sur tout le document ($.customers[*].name), et la ligne n prend la n-ième valeur de chaque liste. Une valeur absente décale les suivantes (voir l'exemple). Old mode, through the Java JavaScript engine. No loop: each column has a query on the whole document ($.customers[*].name), and row n takes the n-th value of each list. A missing value shifts the next ones (see the example).

XPath

Le JSON est converti en XML (bibliothèque staxon), puis lu comme par tFileInputXML : boucle et colonnes en XPath (/customers, address/city), case Obtenir les nœuds pour récupérer un élément entier en JSON (voir l'exemple). The JSON is converted to XML (staxon library), then read as by tFileInputXML: loop and columns in XPath (/customers, address/city), Get Nodes box to get a whole element as JSON (see the example).

Paramètres simplesBasic settings

Les libellés sont ceux de l'onglet Composant ; le nom technique, en gris, est celui du paramètre dans le fichier du job. Noms de fichier, adresses et requêtes sont des expressions Java : "$.customers[*]", context.folder + "/in.json". Labels are those of the Component tab; the technical name, in grey, is the parameter name in the job file. File names, addresses and queries are Java expressions: "$.customers[*]", context.folder + "/in.json".

ParamètreSetting DéfautDefault VisibleShown Description
Type de propriétéProperty TypePROPERTY Built-inBuilt-In ToujoursAlways Built-in : les réglages sont saisis dans le composant. Référentiel : le fichier, le mode de lecture, la boucle, les requêtes et l'encodage viennent d'une métadonnée JSON du Référentiel. Built-In: the settings are typed in the component. Repository: the file, the read mode, the loop, the queries and the encoding come from a JSON metadata of the Repository.
SchémaSchemaSCHEMA — ToujoursAlways Les colonnes produites. Le type de chaque colonne décide de la conversion de sa valeur, et sa valeur par défaut remplace une valeur absente (voir les exemples). The produced columns. The type of each column decides how its value is converted, and its default value replaces a missing value (see the examples).
Lu parRead ByREAD_BY JsonPath ToujoursAlways JSONPath, JSONPath sans boucle ou XPath (voir les modes de lecture). Chacun affiche sa requête de boucle et sa table Mapping. JsonPath, JsonPath without loop or Xpath (see the read modes). Each one shows its own loop query and Mapping table.
Version de l'APIAPI versionJSON_PATH_VERSION 2.1.0 Lu par = JSONPathRead By = JsonPath La version de json-path ajoutée au job : 2.1.0 ou 1.2.0. Le code généré est le même ; avec les données de l'exemple, les deux versions donnent la même sortie. The json-path version added to the job: 2.1.0 or 1.2.0. The generated code is the same; with the data of the example, both versions give the same output.
Utiliser l'URLUse UrlUSEURL NonNo ToujoursAlways Cochée, le document est lu à l'adresse URL au lieu du fichier (voir l'exemple). Checked, the document is read at the URL address instead of the file (see the example).
URLURLPATH "http://localhost:8080/JSON/JSON_file.txt" URL cochéeUse Url checked L'adresse lue, ouverte par java.net.URL : http:, https: ou file:. D'après le modèle, la connexion est ouverte sans délai d'attente, sans en-tête ni authentification. The address read, opened by java.net.URL: http:, https: or file:. Per the template, the connection is opened without timeout, header or authentication.
Nom de fichierFilenameFILENAME chemin par défaut + /JSON_File.txtdefault path + /JSON_File.txt URL décochéeUse Url unchecked Le fichier lu. D'après le modèle, l'expression peut aussi donner un java.io.InputStream, lu à la place du fichier, même avec Utiliser l'URL coché. The file read. Per the template, the expression can also give a java.io.InputStream, read instead of the file, even with Use Url checked.
Requête XPath boucleLoop XPath queryLOOP_QUERY "/bills/bill/line" Lu par = XPathRead By = Xpath Les éléments répétés, en XPath sur le JSON converti. Écrivez-la comme si chaque clé du premier niveau était un élément racine : "/customers" pour le tableau customers. The repeated elements, in XPath on the converted JSON. Write it as if each first-level key were a root element: "/customers" for the customers array.
Requête de boucle JsonLoop Json queryJSON_LOOP_QUERY "$.bills.bill.line[*]" Lu par = JSONPathRead By = JsonPath Les éléments répétés, en JsonPath depuis la racine du document : "$.customers[*]". D'après le modèle, un résultat qui n'est pas un tableau donne une seule ligne. The repeated elements, in JsonPath from the document root: "$.customers[*]". Per the template, a result that is not an array gives a single row.
MappingMAPPING_JSONPATH une ligne par colonneone row per column Lu par = JSONPathRead By = JsonPath Colonne : la colonne du schéma. Requête JSON : le chemin de sa valeur, relatif à l'élément de la boucle ("name", "address.city", "tags[0]"). Un objet ou un tableau donne son texte JSON. Un chemin commençant par $ part de la racine du document si Utiliser le nœud de boucle comme racine est décoché (voir les exemples). Column: the schema column. Json query: the path of its value, relative to the loop element ("name", "address.city", "tags[0]"). An object or an array gives its JSON text. A path starting with $ starts from the document root if Use the loop node as root is unchecked (see the examples).
MappingMAPPING une ligne par colonneone row per column Lu par = JSONPath sans boucleRead By = JsonPath without loop Requête JSONPath : un chemin sur tout le document, qui donne la liste des valeurs de la colonne ("$.customers[*].name"). Les listes sont lues côte à côte, rang par rang. JSONPath query: a path on the whole document, giving the list of values of the column ("$.customers[*].name"). The lists are read side by side, position by position.
MappingMAPPINGXPATH une ligne par colonneone row per column Lu par = XPathRead By = Xpath Requête XPath : relative à l'élément de la boucle ("name", "address/city"). Plusieurs nœuds trouvés : le premier est pris. Obtenir les nœuds : la colonne reçoit l'élément trouvé en JSON, sous son nom, au lieu de son texte. XPath query: relative to the loop element ("name", "address/city"). Several nodes found: the first one is taken. Get Nodes: the column gets the element found as JSON, under its name, instead of its text.
Arrêter en cas d'erreurDie on errorDIE_ON_ERROR NonNo ToujoursAlways Cochée, la première erreur (fichier, JSON mal formé, valeur) arrête le job. Décochée, une ligne en erreur est écartée, ou envoyée au lien Reject, et la lecture continue ; un fichier illisible ne donne aucune ligne (voir les erreurs). Checked, the first error (file, malformed JSON, value) stops the job. Unchecked, a row in error is dropped, or sent to the Reject link, and reading goes on; an unreadable file gives no row (see the errors).

Paramètres avancésAdvanced settings

ParamètreSetting DéfautDefault VisibleShown Description
Version JDKJDK versionJDK_VERSION JDK 8 à 11JDK 8 to 11 Lu par = JSONPath sans boucleRead By = JsonPath without loop Le moteur JavaScript du mode sans boucle. JDK 11 et supérieures ajoute au job la bibliothèque Nashorn (nashorn-core-15.4), qui n'est plus dans Java depuis la version 15. Avec Java 15 ou plus, choisissez cette valeur : la valeur par défaut ne lit rien (voir les erreurs). The JavaScript engine of the mode without loop. JDK11 and above adds the Nashorn library (nashorn-core-15.4) to the job, no longer part of Java since version 15. With Java 15 or later, choose this value: the default value reads nothing (see the errors).
Séparateur avancé (pour les nombres)Advanced separator (for numbers)ADVANCED_SEPARATOR NonNo ToujoursAlways Lit les colonnes numériques avec un séparateur de milliers et un séparateur décimal choisis : utile pour des nombres écrits en texte, comme "1.234,50". Le séparateur de milliers est retiré, le séparateur décimal devient un point. Reads the number columns with a chosen thousands separator and decimal separator: useful for numbers written as text, like "1.234,50". The thousands separator is removed, the decimal separator becomes a dot.
Séparateur de milliersThousands separatorTHOUSANDS_SEPARATOR "," Séparateur avancé cochéAdvanced separator checked Un caractère, entre guillemets.One character, in quotes.
Séparateur décimalDecimal separatorDECIMAL_SEPARATOR "." Séparateur avancé cochéAdvanced separator checked Un caractère, entre guillemets.One character, in quotes.
Valider la dateValidate dateCHECK_DATE NonNo Lu par = XPathRead By = Xpath Lecture stricte des dates : une date impossible (2024-02-30) est une erreur au lieu de devenir le 1er mars. D'après le modèle, même comportement que dans tFileInputXML. Strict date reading: an impossible date (2024-02-30) is an error instead of becoming March 1st. Per the template, same behavior as in tFileInputXML.
Utiliser le nœud de boucle comme racineUse the loop node as rootUSE_LOOP_AS_ROOT OuiYes Lu par = JSONPathRead By = JsonPath Cochée, toutes les requêtes des colonnes sont lues dans l'élément de la boucle, même celles qui commencent par $. Décochée, une requête commençant par $ est lue depuis la racine du document : c'est le moyen de lire une valeur hors de la boucle (voir l'exemple). Checked, all the column queries are read in the loop element, even those starting with $. Unchecked, a query starting with $ is read from the document root: this is the way to read a value outside the loop (see the example).
EncodageEncodingENCODING "UTF-8" ToujoursAlways L'encodage du fichier ou de la réponse de l'URL. Un fichier écrit dans un autre encodage donne des caractères de remplacement (voir l'exemple). The encoding of the file or of the URL response. A file written in another encoding gives replacement characters (see the example).

Variables globalesGlobal variables

NB_LINE (Integer, disponible après l'exécution du composant) : nombre d'éléments lus, y compris les lignes écartées ou envoyées au lien Reject (3 pour 2 lignes valides dans l'exemple des erreurs). NB_LINE (Integer, available after the component has run): number of elements read, including the rows dropped or sent to the Reject link (3 for 2 valid rows in the errors example).

((Integer) globalMap.get("tFileInputJSON_1_NB_LINE"))

ERROR_MESSAGE (String) : le message de la dernière erreur rencontrée, fichier ou valeur ; null sans erreur. ERROR_MESSAGE (String): the message of the last error met, file or value; null without error.

((String) globalMap.get("tFileInputJSON_1_ERROR_MESSAGE"))

ExemplesExamples

Chaque job lit un fichier écrit dans le dossier de la variable de contexte folder et envoie ses lignes à un tLogRow en mode tableau ; un tJava relié par On Subjob Ok affiche ensuite NB_LINE. Les sorties sont celles de la console, copiées depuis une exécution du job. Each job reads a file written in the folder of the folder context variable and sends its rows to a tLogRow in table mode; a tJava connected with On Subjob Ok then prints NB_LINE. The outputs are the console ones, copied from a run of the job.

Lecture d'un tableau d'objetsReading an array of objects

row1 (Main) OnSubjobOk tFileInputJSON_1 tLogRow_1 tJava_1

Fichier customers.json :customers.json file:

{
  "shop": "Paris",
  "customers": [
    {"id": 1, "name": "Ada", "address": {"city": "London"}, "tags": ["vip", "early"],
     "balance": 12.50, "since": "2024-01-15", "active": true, "visits": 4},
    {"id": 2, "name": "Grace", "address": {"city": "New York"}, "tags": [],
     "balance": 0, "since": "2023-11-02", "active": false, "visits": 0},
    {"id": 3, "name": "Alan", "address": null, "balance": null, "since": "", "note": "call back"}
  ]
}

Nom de fichier context.folder + "/customers.json", Requête de boucle Json "$.customers[*]", autres réglages par défaut. Table Mapping : Filename context.folder + "/customers.json", Loop Json query "$.customers[*]", other settings by default. Mapping table:

ColonneColumn Type Requête JSONJson query
idInteger"id"
nameString"name"
cityString"address.city"
tagsString"tags"
.--+-----+--------+---------------.
|            tLogRow_1            |
|=-+-----+--------+--------------=|
|id|name |city    |tags           |
|=-+-----+--------+--------------=|
|1 |Ada  |London  |["vip","early"]|
|2 |Grace|New York|[]             |
|3 |Alan |null    |null           |
'--+-----+--------+---------------'

NB_LINE: 3

Un objet par ligne. Le tableau tags arrive en texte JSON, sans espaces. address vaut null chez Alan et tags est absent : les deux colonnes valent null, sans erreur. La clé shop, hors de la boucle, n'est pas lue (voir l'exemple suivant). One object per row. The tags array comes as JSON text, without spaces. address is null for Alan and tags is missing: both columns are null, without error. The shop key, outside the loop, is not read (see the next example).

Valeurs hors de la boucleValues outside the loop

Même fichier et même boucle. Colonnes name : "name", shop : "$.shop", first : "$.customers[0].name". Avec Utiliser le nœud de boucle comme racine coché (défaut) : Same file and same loop. Columns name: "name", shop: "$.shop", first: "$.customers[0].name". With Use the loop node as root checked (default):

.-----+----+-----.
|   tLogRow_1    |
|=----+----+----=|
|name |shop|first|
|=----+----+----=|
|Ada  |null|null |
|Grace|null|null |
|Alan |null|null |
'-----+----+-----'

Le $ désigne l'élément de la boucle : il n'a ni shop ni customers. Case décochée : The $ designates the loop element: it has neither shop nor customers. Box unchecked:

.-----+-----+-----.
|    tLogRow_1    |
|=----+-----+----=|
|name |shop |first|
|=----+-----+----=|
|Ada  |Paris|Ada  |
|Grace|Paris|Ada  |
|Alan |Paris|Ada  |
'-----+-----+-----'

Les chemins en $ partent de la racine du document ; "name", sans $, reste lu dans l'élément. Paths with $ start from the document root; "name", without $, is still read in the element.

Types et valeurs absentesTypes and missing values

Même fichier et même boucle ; chaque colonne a pour requête son nom. Same file and same loop; each column has its own name as query.

ColonneColumn Type
idInteger
balanceBigDecimal
sinceDate, modèle "yyyy-MM-dd"Date, pattern "yyyy-MM-dd"
activeBoolean
visitsInteger, non nullableInteger, not nullable
noteString, défaut "none"String, default "none"
.--+-------+----------+------+------+---------.
|                  tLogRow_1                  |
|=-+-------+----------+------+------+--------=|
|id|balance|since     |active|visits|note     |
|=-+-------+----------+------+------+--------=|
|1 |12.5   |2024-01-15|true  |4     |none     |
|2 |0      |2023-11-02|false |0     |none     |
|3 |null   |null      |null  |0     |call back|
'--+-------+----------+------+------+---------'
  • Absente, null ou vide ("since": ""), une valeur prend la valeur par défaut de la colonne : null si elle est nullable, 0 pour un Integer non nullable, sinon la valeur donnée dans le schéma (none). Missing, null or empty ("since": ""), a value takes the default value of the column: null if it is nullable, 0 for a non-nullable Integer, otherwise the value given in the schema (none).
  • 12.50 devient 12.5 : la bibliothèque JSON lit le nombre avant le composant, et ses zéros de fin sont perdus (voir les conseils). 12.50 becomes 12.5: the JSON library reads the number before the component, and its trailing zeros are lost (see the tips).
  • La date est lue avec le modèle de la colonne. Sans modèle, d'après le modèle de code, c'est dd-MM-yyyy. The date is read with the column pattern. Without a pattern, per the code template, it is dd-MM-yyyy.

Tableaux imbriquésNested arrays

Fichier orders.json :orders.json file:

{"orders": [
  {"id": 101, "lines": [{"product": "pen", "qty": 2}, {"product": "ink", "qty": 1}]},
  {"id": 102, "lines": [{"product": "paper", "qty": 5}]}
]}

Une ligne par commande : boucle "$.orders[*]" ; colonnes id : "id", lines : "lines", products : "lines[*].product", nb (Integer) : "lines.length()". One row per order: loop "$.orders[*]"; columns id: "id", lines: "lines", products: "lines[*].product", nb (Integer): "lines.length()".

.---+-----------------------------------------------------+-------------+--.
|                                tLogRow_1                                 |
|=--+-----------------------------------------------------+-------------+-=|
|id |lines                                                |products     |nb|
|=--+-----------------------------------------------------+-------------+-=|
|101|[{"product":"pen","qty":2},{"product":"ink","qty":1}]|["pen","ink"]|2 |
|102|[{"product":"paper","qty":5}]                        |["paper"]    |1 |
'---+-----------------------------------------------------+-------------+--'

NB_LINE: 2

Un tableau imbriqué arrive en texte JSON ; un chemin avec [*] donne la liste de ses valeurs ; les fonctions de JsonPath, comme length(), sont acceptées. A nested array comes as JSON text; a path with [*] gives the list of its values; JsonPath functions, like length(), are accepted.

Une ligne par article : boucle "$.orders[*].lines[*]", Utiliser le nœud de boucle comme racine décoché ; colonnes product, qty, et order : "$.orders[*].id". One row per line item: loop "$.orders[*].lines[*]", Use the loop node as root unchecked; columns product, qty, and order: "$.orders[*].id".

.-------+---+---------.
|      tLogRow_1      |
|=------+---+--------=|
|product|qty|order    |
|=------+---+--------=|
|pen    |2  |[101,102]|
|ink    |1  |[101,102]|
|paper  |5  |[101,102]|
'-------+---+---------'

NB_LINE: 3

JsonPath n'a pas d'accès au parent : la commande d'un article ne peut pas être lue depuis l'article, et le chemin absolu donne toutes les commandes. Pour garder le lien, lisez les commandes avec leurs lines en texte, puis découpez ce texte dans un second temps. JsonPath has no access to the parent: the order of a line item cannot be read from the item, and the absolute path gives all the orders. To keep the link, read the orders with their lines as text, then split that text in a second step.

Lu par XPathRead by XPath

Fichier customers.json, Lu par XPath, Requête XPath boucle "/customers". Requêtes : id : "id", name : "name", city : "address/city", tag : "tags", address : "address" avec Obtenir les nœuds coché. customers.json file, Read By Xpath, Loop XPath query "/customers". Queries: id: "id", name: "name", city: "address/city", tag: "tags", address: "address" with Get Nodes checked.

.--+-----+--------+---+-------------------------------.
|                      tLogRow_1                      |
|=-+-----+--------+---+------------------------------=|
|id|name |city    |tag|address                        |
|=-+-----+--------+---+------------------------------=|
|1 |Ada  |London  |vip|{"address":{"city":"London"}}  |
|2 |Grace|New York|null|{"address":{"city":"New York"}}|
|3 |Alan |null    |null|{"address":null}               |
'--+-----+--------+---+-------------------------------'

NB_LINE: 3

Chaque objet du tableau devient un élément customers ; un tableau de valeurs devient des éléments répétés, et la requête prend le premier (vip). Avec Obtenir les nœuds, l'élément revient en JSON sous son nom. Le décalage des lignes 2 et 3 vient du tLogRow : il calcule la largeur d'une colonne sans compter les null, et une colonne de moins de quatre caractères déborde. Each object of the array becomes a customers element; an array of values becomes repeated elements, and the query takes the first one (vip). With Get Nodes, the element comes back as JSON under its name. The misalignment of rows 2 and 3 comes from the tLogRow: it computes the width of a column without counting the null values, and a column narrower than four characters overflows.

JsonPath sans boucleJsonPath without loop

Fichier shift.json, où le client 2 n'a pas de ville :shift.json file, where customer 2 has no city:

{"customers": [
  {"id": 1, "city": "London"},
  {"id": 2},
  {"id": 3, "city": "Paris"}
]}

Lu par JSONPath sans boucle, Version JDK « JDK 11 et supérieures » (job lancé avec Java 21). Requêtes "$.customers[*].id" et "$.customers[*].city" : Read By JsonPath without loop, JDK version “JDK11 and above” (job run with Java 21). Queries "$.customers[*].id" and "$.customers[*].city":

The Json resource datas maybe have some problems, please make sure the data structure with the same fields.
.--+------.
|tLogRow_1|
|=-+-----=|
|id|city  |
|=-+-----=|
|1 |London|
|2 |Paris |
|3 |null  |
'--+------'

La liste des villes n'a que deux valeurs : Paris passe au client 2. Le message, sur la sortie d'erreur, prévient sans arrêter le job. Le même fichier en mode JSONPath, boucle "$.customers[*]" et requêtes "id", "city" : The list of cities has only two values: Paris goes to customer 2. The message, on the error output, warns without stopping the job. The same file in JsonPath mode, loop "$.customers[*]" and queries "id", "city":

.--+------.
|tLogRow_1|
|=-+-----=|
|id|city  |
|=-+-----=|
|1 |London|
|2 |null  |
|3 |Paris |
'--+------'

Lecture par une URLReading through a URL

Réglages de l'exemple de base, avec Utiliser l'URL coché et l'URL "file:///" + context.folder + "/customers.json" : l'adresse désigne ici le fichier local, pour l'exemple. La sortie est la même : Settings of the basic example, with Use Url checked and the URL "file:///" + context.folder + "/customers.json": the address designates the local file here, for the example. The output is the same:

.--+-----+--------+---------------.
|            tLogRow_1            |
|=-+-----+--------+--------------=|
|id|name |city    |tags           |
|=-+-----+--------+--------------=|
|1 |Ada  |London  |["vip","early"]|
|2 |Grace|New York|[]             |
|3 |Alan |null    |null           |
'--+-----+--------+---------------'

NB_LINE: 3

Une adresse http:// ou https:// se lit par le même code ; pour un service qui demande une méthode, des en-têtes ou une authentification, appelez-le avec un composant REST et lisez sa réponse. An http:// or https:// address is read by the same code; for a service that requires a method, headers or authentication, call it with a REST component and read its response.

EncodageEncoding

Fichier latin1.json, écrit en ISO-8859-1 : {"people": [{"name": "Éloïse", "city": "Montréal"}]}. Boucle "$.people[*]", encodage par défaut ("UTF-8") : latin1.json file, written in ISO-8859-1: {"people": [{"name": "Éloïse", "city": "Montréal"}]}. Loop "$.people[*]", default encoding ("UTF-8"):

.------+--------.
|   tLogRow_1   |
|=-----+-------=|
|name  |city    |
|=-----+-------=|
|�lo�se|Montr�al|
'------+--------'

Les octets qui ne sont pas de l'UTF-8 deviennent des caractères de remplacement, sans erreur. Avec l'encodage "ISO-8859-1" : Bytes that are not UTF-8 become replacement characters, without error. With the "ISO-8859-1" encoding:

.------+--------.
|   tLogRow_1   |
|=-----+-------=|
|name  |city    |
|=-----+-------=|
|Éloïse|Montréal|
'------+--------'

Erreurs et piègesErrors and pitfalls

Le nom du job est remplacé par MyJob, le dossier des fichiers par C:\data ; les traces d'exception sont abrégées. La fin des messages de fichier vient de Windows, dans sa langue. Les jobs affichent aussi NB_LINE et ERROR_MESSAGE par un tJava. The job name is replaced with MyJob, the files folder with C:\data; exception traces are shortened. The end of the file messages comes from Windows, in its language. The jobs also print NB_LINE and ERROR_MESSAGE with a tJava.

Valeur qui ne se convertit pasValue that does not convert

Fichier bad_values.json, colonne qty de type Integer :bad_values.json file, qty column of type Integer:

{"items": [
  {"code": "A", "qty": "2"},
  {"code": "B", "qty": "two"},
  {"code": "C", "qty": "5"}
]}

Sans lien Reject, la ligne B est écartée et son message va sur la sortie d'erreur :Without a Reject link, row B is dropped and its message goes to the error output:

For input string: "two"
.----+---.
|tLogRow_1|
|=---+--=|
|code|qty|
|=---+--=|
|A   |2  |
|C   |5  |
'----+---'

NB_LINE: 3
ERROR_MESSAGE: For input string: "two"

Avec un lien Reject vers un second tLogRow, elle y part avec son message :With a Reject link to a second tLogRow, it goes there with its message:

.----+---+---------+---------------------------------.
|                     tLogRow_2                      |
|=---+---+---------+--------------------------------=|
|code|qty|errorCode|errorMessage                     |
|=---+---+---------+--------------------------------=|
|B   |null|null     |For input string: "two" - Line: 1|
'----+---+---------+---------------------------------'

La ligne rejetée garde les colonnes lues avant l'erreur ; la colonne fautive vaut null. errorCode n'est jamais rempli, et Line est le nombre de lignes traitées avant celle-ci, pas une ligne du fichier. Avec Arrêter en cas d'erreur coché, le job s'arrête (code 1) : The rejected row keeps the columns read before the error; the faulty column is null. errorCode is never filled, and Line is the number of rows processed before this one, not a line of the file. With Die on error checked, the job stops (exit code 1):

Exception in component tFileInputJSON_1 (MyJob)
java.lang.NumberFormatException: For input string: "two"
	at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:67)
	…
	at routines.system.ParserUtils.parseTo_Integer(ParserUtils.java:137)
	…

Défaut du modèle de Talaxie (jsonpath.javajet, xpath.javajet, jsonpath_javascript_api.javajet) : la colonne errorCode du schéma Reject n'est remplie par aucun mode. Defect of the Talaxie template (jsonpath.javajet, xpath.javajet, jsonpath_javascript_api.javajet): the errorCode column of the Reject schema is filled by no mode.

Fichier absentMissing file

Nom de fichier context.folder + "/missing.json", Arrêter en cas d'erreur décoché : le message va sur la sortie d'erreur, le composant ne donne aucune ligne et le job continue (code 0). Filename context.folder + "/missing.json", Die on error unchecked: the message goes to the error output, the component gives no row and the job goes on (exit code 0).

C:\data\missing.json (Le fichier spécifié est introuvable)
.--+----+----+----.
|    tLogRow_1    |
|=-+----+----+---=|
|id|name|city|tags|
|=-+----+----+---=|
'--+----+----+----'

NB_LINE: 0
ERROR_MESSAGE: C:\data\missing.json (Le fichier spécifié est introuvable)

JSON mal forméMalformed JSON

Fichier broken.json, coupé avant la fin : {"customers": [{"id": 1, "name": "Ada"},. Même effet : un message, aucune ligne. broken.json file, cut before the end: {"customers": [{"id": 1, "name": "Ada"},. Same effect: a message, no row.

net.minidev.json.parser.ParseException: Unexpected End Of File position 37: EOF
…
NB_LINE: 0

Sans boucle, aucune ligneWithout loop, no row

Mode JSONPath sans boucle, Version JDK laissée à « JDK 8 à 11 », job lancé avec Java 21 : Java n'a plus de moteur JavaScript. JsonPath without loop mode, JDK version left on “JDK 8 to 11”, job run with Java 21: Java no longer has a JavaScript engine.

No script engine found for JavaScript
…
NB_LINE: 0

Le job finit sans erreur (code 0), sans aucune ligne. Choisissez « JDK 11 et supérieures », ou mieux le mode JSONPath. Ce mode a aussi besoin de jsonpath.jar (org.talend.libraries:jsonpath:6.0.0), livré dans le plugin org.talend.libraries.jackson du Studio et absent des dépôts Maven publics. The job ends without error (exit code 0), with no row. Choose “JDK11 and above”, or better the JsonPath mode. This mode also needs jsonpath.jar (org.talend.libraries:jsonpath:6.0.0), shipped in the org.talend.libraries.jackson plugin of the Studio and missing from the public Maven repositories.

Conseils et limitesTips and limits

Bouclez au niveau le plus finLoop at the finest level

La boucle désigne ce qui fait une ligne. Une valeur d'un niveau plus haut ne se lit que par un chemin absolu, case Utiliser le nœud de boucle comme racine décochée, et seulement si elle est unique dans le document ($.shop) : JsonPath ne remonte pas au parent. The loop designates what makes a row. A value from a higher level can only be read through an absolute path, with Use the loop node as root unchecked, and only if it is unique in the document ($.shop): JsonPath does not go up to the parent.

Montants décimauxDecimal amounts

Dans nos essais, 12.50 donne 12.5, mais 1234567890.123456789 et 12345678901234567890 gardent tous leurs chiffres dans une colonne BigDecimal. Si le nombre de décimales compte, fixez-le ensuite (setScale) ou faites écrire le montant entre guillemets : une chaîne est lue telle quelle. In our tests, 12.50 gives 12.5, but 1234567890.123456789 and 12345678901234567890 keep all their digits in a BigDecimal column. If the number of decimals matters, set it afterwards (setScale) or have the amount written in quotes: a string is read as it is.

Tout le fichier en mémoireThe whole file in memory

D'après les modèles, le document entier est lu avant la première ligne, et le mode XPath en garde en plus une copie convertie en XML. Pour un très gros fichier, prévoyez la mémoire de la JVM, ou découpez le fichier en amont. Per the templates, the whole document is read before the first row, and the XPath mode also keeps a copy converted to XML. For a very large file, plan the JVM memory, or split the file beforehand.

Un texte JSON à découperA JSON text to split

Une colonne String reçoit un objet ou un tableau en texte JSON compact (["vip","early"]). Ce texte peut être écrit tel quel, ou relu dans un second temps par un autre composant JSON. A String column gets an object or an array as compact JSON text (["vip","early"]). This text can be written as it is, or read again in a second step by another JSON component.

Voir aussiSee also