Modèle de génération de code pour les composants - 7.3

EnrichVersion
7.3
EnrichProdName
Talend Big Data
Talend Big Data Platform
Talend Data Fabric
Talend Data Integration
Talend Data Management Platform
Talend Data Services Platform
Talend ESB
Talend MDM Platform
Talend Open Studio for Big Data
Talend Open Studio for Data Integration
Talend Open Studio for ESB
Talend Real-Time Big Data Platform
task
Création et développement > Création de composants
EnrichPlatform
Studio Talend

Modèle de génération de code pour les composants

Cette page présente les différents modèles de génération de code pour les composants, disponibles dans le Studio Talend.

Le Studio Talend est un outil de génération de code Java. Le Job est automatiquement traduit en une classe Java. Chaque composant du Job est divisé en trois partie de code Java dans le code généré du Job : début (begin), code principal (main) et fin (end). Les parties de début et de fin sont exécutées une fois par Job, mais la partie principale peut être exécutée autant de fois qu'il y a de lignes traitées dans le composant. Voici quelques exemples de Jobs et leurs connexions.

Ligne

Les liens de type Row comprennent les liens Main, Lookup, Filter, Reject, Uniques et Duplicates et sont les plus fréquemment utilisés dans les Jobs. Ils sont utilisés pour transférer des données d'un composant à un autre, jouant le rôle de pont laissant s'écouler le flux de données à travers le Job.

Voici un exemple simple de Job, comprenant un composant d'entrée, un tMap et un composant de sortie, reliés par des liens Row > Main :

La séquence de génération de code pour ce Job est la suivante :

Cet exemple explique comment les trois parties de ces trois composants sont organisées et comment elles fonctionnent ensemble.

tFOX begin (initializes variables, such as filepath, opens an output stream)
tMap begin (initializes some constants)
tFID begin (opens an input stream, fetches all data from data source and caches them in memory,then starts a loop to deliver the rows line by line)
--------------------
tFID main  (instantiates main row, copies the data from row1 to main)
tMap main  (this is the mapper complex Java generated code)
tFOX main  (writes an XML line, encapsulating each field)
--------------------
tFID end   (stops loop, closes the input stream)
tMap end   (does nothing)
tFOX end   (writes last XML line, closes the output stream)

Pour un lien Row, les règles de génération de code sont :

  • chaque composant génère trois parties de code, le début, la partie principale et la fin.
  • pour la partie de début, les composants génèrent le code correspondant dans l'ordre inverse du Job.
  • pour la partie principale, les composants génèrent le code correspondant dans l'ordre du Job.
  • pour la partie de fin, les composants génèrent le code correspondant dans l'ordre du Job.

Iterate

Il y a deux types de Jobs utilisant les liens Iterate.

Le premier est un Job contenant l'un des composants suivants avec un lien Iterate :

  • tFileList
  • tLoop
  • tForEach
  • tWaitForFile (ou tWaitForSocket, tWaitForSqlData)
  • tMysqlTableList (ou tOracleTableList, tMsSQLTableList, etc.)

Ce Job d'exemple contient un tFileList utilisant un lien Iterate pour itérer sur chaque fichier dans le répertoire sélectionné.

La génération de code des composants pour ce type de Job est la suivante :

tFL  begin (opens a loop to iterate each file)
tFL  main  (does nothing)
--------------------
tFOX begin
tMap begin
tFID begin
--------------------
tFID main
tMap main
tFOX main
--------------------
tFID end
tMap end
tFOX end
--------------------
tFL end (closes the loop)

Comme indiqué ci-dessus, le code de la partie de début du composant ayant un lien Iterate de sortie est générée d'abord et exécutée pour démarrer une boucle itérant sur chaque élément. À la fin du processus, le code de fin du composant est exécuté pour fermer la boucle.

Un autre type de Job utilisant un lien Iterate est un Job contenant un composant tFlowToIterate, comme le Job ci-dessous :

La génération de code des composants pour ce type de Job est la suivante :

MERGE

Un autre type de génération de code existe, lorsque le Job contient au moins deux branches d'entrées fusionnées en un modèle à l'aide d'un composant tUnite, comme dans le Job d'exemple ci-dessous :

La génération de code des composants pour ce type de Job est la suivante :

L'image ci-dessus montre qu'il y a toujours un flux principal de boucle pour chaque branche d'entrée et que la partie principale du composant tUnite est à l'intérieur de chaque boucle des branches d'entrée.