Modèle de génération de code des composants

EnrichVersion
6.4
6.3
6.2
6.1
6.0
5.6
EnrichProdName
Talend Data Fabric
Talend Data Management Platform
Talend Open Studio for Big Data
Talend Big Data
Talend Data Integration
Talend Real-Time Big Data Platform
Talend ESB
Talend Data Services Platform
Talend Open Studio for ESB
Talend MDM Platform
Talend Open Studio for MDM
Talend Big Data Platform
Talend Open Studio for Data Integration
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.

Row

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 (initialise les variables, comme filepath, ouvre un flux de sortie)
tMap begin (initialise des constantes)
tFID begin (ouvre un flux d'entrée, récupère toutes les données de la source et les met en cache dans la mémoire, puis démarre une boucle pour livrer les lignes, ligne par ligne)
--------------------
tFID main  (instancie le flux principal, copie les données du flux row1 au flux main)
tMap main  (code Java complexe généré de mapping)
tFOX main  (écrit une ligne XML, entourant chaque champ)
--------------------
tFID end   (arrête la boucle, ferme le flux d'entrée)
tMap end   (ne fait rien)
tFOX end   (écrit la dernière ligne XML, ferme le flux de sortie)

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 (ouvre une boucle pour itérer sur chaque fichier)
tFL  main  (ne fait rien)
--------------------
tFOX begin
tMap begin
tFID begin
--------------------
tFID main
tMap main
tFOX main
--------------------
tFID end
tMap end
tFOX end
--------------------
tFL end (ferme la boucle)

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 du code pour ces 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 pour ces 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.