Générer, créer, exécuter du code
Ce chapitre décrit comment générer du code depuis un mappage et un projet, créer le code généré et l’exécuter. Il existe des situations pour lesquelles vous allez devoir modifier votre code C#/C++/Java généré pour l’intégrer dans votre code personnalisé. Pour les détails, voir Intégrer le code généré.
Générer du code depuis un mappage
Pour générer le code depuis un design de mappage (.mfd), suivez les instructions ci-dessous.
1.Sélectionnez les options de génération du code dans la section Génération du dialogue Options (applicable à C# et C++) dans le dialogue Paramètres de mappage. Pour les détails sur les paramètres de génération de code dans le dialogue Options, voir Génération.
2.Cliquez sur Fichier | Générer code dans et sélectionnez le langage de transformation pertinent. En alternative, vous pouvez sélectionner Fichier | Générer le code dans le langage sélectionné. Dans ce cas, le code sera généré dans le langage sélectionné dans la barre d’outils.
3.Sélectionnez un répertoire de destination pour les fichiers générés, puis cliquez sur OK pour confirmer. MapForce génère le code et affiche le résultat de l’opération dans la fenêtre Messages.
Le code généré d’un projet (éditions Professional et Enterprise)
Vous pouvez générer le code du projet de mappage (.mfp) qui consiste en de multiples fichiers de design de mappage (.mfd). Notez que les fichiers de design de mappage dans le projet doivent être qualifiés pour la génération, ce qui signifie que tous leurs composants doivent être pris en charge dans le langage de transformation sélectionné (voir Fonctions prises en charge dans le code généré).
Pour générer le code depuis un projet de mappage, suivez les instructions ci-dessous.
1.Ouvrir le projet de mappage pertinent pour lequel vous souhaitez générer le code.
2.Cliquer avec la touche de droite sur le nom du projet dans la fenêtre Projet et sélectionnez les Propriétés à partir du menu contextuel. En alternative, cliquez sur le nom du projet et sélectionnez l’item de menu Projet | Propriétés.
3.Revoir et changer les paramètres de projet, si requis. En particulier, assurez-vous que le langage cible et le répertoire de sortie sont définis correctement. Ensuite, cliquez sur OK.
4.Cliquez sur Générer code pour tout le Projet dans le menu Projet.
Indépendamment du langage sélectionné dans le dialogue Propriétés de projet, vous pouvez toujours choisir de générer le code de projet dans un langage différent, en sélectionnant la commande du menu Projet | Générer code dans | <language>.
Le progrès et le résultat du processus de la génération de code est affiché dans la fenêtre Messages Par défaut, le nom de l’application générée est le même que le nom du projet. Si le nom du projet contient des espaces, elles sont converties en traits de soulignement dans le code généré. Par défaut, le code est généré dans le même répertoire que le projet MapForce, dans le sous-répertoire sortie.
Vous pouvez changer le répertoire de sortie et/ou le nom du projet dans le dialogue Propriétés de projet. Si votre projet MapForce contient des dossiers, vous pouvez configurer les paramètres de génération de code pour chaque dossier individuel : Cliquez avec la touche de droite sur un dossier d’intérêt et sélectionnez Propriétés depuis le menu contextuel. Autrement, tous les dossiers de projet héritent des paramètres définis au niveau supérieur. Pour plus d’information sur les projets et paramètres liés au projet ainsi que les procédures, voir Projets.
Information spécifique au langage
Cette sous-section décrit les particularités de générer du code dans différents langages de transformation. Cette sous-section explique comment créer le code C++, C# et Java généré et exécuter l’application. Vous pouvez aussi générer du code dans XSLT 1-3 et XQuery. Pour les détails, voir Génération de code.
code C++ et C#
Générer, créer et exécuter le code C++ et C# suivent la même logique. Les procédures générales sont décrites dans les sous-sections ci-dessous.
Une fois que vous avez généré le code C++ or C# code, la solution inclura les composants suivants :
•Les fichiers Solution (.sln) et Project (.vcxproj pour C++ et .csproj for C#) peuvent être ouverts dans Visual Studio
•Plusieurs bibliothèques signées Altova requises par le mappage (toutes préfixées avec Altova)
•Le projet de mappage principal (appelé Mappage par défaut), qui comprend l’application de mappage et des fichiers dépendants.
Notez que vous pouvez changer le nom par défaut du projet de mappage principal dans la boîte de dialogue Paramètres de mappage.
Une fois que vous avez généré le code C++/C#, les prochaines étapes seraient de créer le code et d’exécuter l’application. Il existe deux approches majeures pour créer le code généré : (i) dans Visual Studio et (ii) à la ligne de commande (voir les détails ci-dessous). Notez que, pour créer le code C#, vous devez avoir installé le SDK pertinent et une version de Visual Studio compatible. Pour le pack de téléchargement pour votre système d’exploitation et plateforme référez-vous au site web de Microsoft.
Construire le code généré dans Visual Studio
Pour créer le code généré C++/C#, suivez les instructions ci-dessous :
1.Ouvrir le fichier de solution généré (.sln) dans Visual Studio. Par défaut, le nom du fichier de solution est Mapping.sln, et est situé dans le sous-répertoire Mappage relatif au répertoire avec le code généré.
2.Choisir la configuration de build requise (par ex., Déboguer). Veuillez noter pour le code C++ : les builds Unicode soutiennent l’ensemble des caractères Unicode dans XML et d’autres fichiers. Les builds non-Unicode fonctionnent avec la page de code locale de votre installation Windows.
3.Cliquez sur Créer Solution dans le menu Build.
En conséquence, une fois le code créé, l’application command-line appelée Mapping.exe et ses fichiers y associés seront créés. L’application du mappage est située dans l’un des sous-répertoires relatifs au fichier .sln. Le nom du sous-répertoire dépend de la configuration créée sélectionnée : par ex., Debug (C++), bin\Debug (C#).
Construire le code généré à la ligne commande
Pour construire le code généré à la ligne de commande, basculez vers le répertoire avec le code généré et exécutez la commande suivante :
devenv Mapping.sln /Build "Debug|AnyCPU" /Project Mapping
La commande appelle Visual Studio et précise le nom du fichier de la solution à créer (Mapping.sln dans notre cas), le configuration désirée (Debug et tout CPU dans notre cas), et le nom du projet auquel appartient le fichier de la solution (Mapping). En conséquence, une fois le code créé, l’application command-line appelée Mapping.exe et ses fichiers y associés seront créés. L’application du mappage est située dans l’un des sous-répertoires relatifs au fichier .sln. Le nom du sous-répertoire dépend de la configuration créée sélectionnée : par ex., Debug (C++), bin\Debug (C#).
Notes relatives à la construction du code C#
Vous pouvez non seulement appeler Visual Studio, vous pouvez aussi appeler .NET pour construire le C# code généré. Suivez les instructions ci-dessous :
1.Assurez-vous de sélectionner la plate-forme correcte à cibler dans la section Génération du dialogue des Options (menu Outils). Pour les détails, voir Génération.
2.Si vous ciblez .NET/.NET Core, configurez les variables d’environnement PATH et DOTNET_ROOT pour qu’elles pointent vers l’emplacement où .NET/.NET Core est installé. Ceci empêchera de possibles problèmes avec les commandes CLI.
3.Ouvrez une invite de commande et basculez vers le répertoire avec le code généré.
4.Exécuter la commande suivante :
dotnet build Mapping\Mapping.sln --configuration Release
Cette commande appelle .NET pour créer un fichier de solution appelé Mapping.sln avec la configuration Release et crée un programme d’exécution appelé Mapping.exe et ses fichiers associés dans le dossier de destination. Le nom du dossier de destination dépend de la configuration sélectionnée et la version .NET utilisée. Dans notre exemple, le programme d’exécution sera enregistré dans le dossier bin\Release\net8.0.
Exécuter application
Après avoir créé le code dans Visual Studio directement ou dans la ligne de commande, vous pouvez procéder à l’exécution de l’application. Pour exécuter l’application, double-cliquez sur Mapping.exe ou appelez le programme d’exécution depuis la ligne de commande. Une fois que vous avez exécuté le programme d’exécution, le résultat de la transformation du mappage sera la sortie du dossier de destination (par défaut, ceci est le dossier où l’exécutable est stocké).
Si vous construisez le code généré sur Linux, le programme d’exécution généré sera appelé Mappage, sans extension. Pour exécuter le programme d’exécution, vous aurez besoin de la commande suivante :
./Mappage
Générer du code Java
Lorsque vous générez un code Java, le projet Java inclura les composants suivants :
•Plusieurs packs Altova signés requis par le mappage (tous les préfixes avec com.altova)
•Le pack com.mapforce comprenant l’application de mappage et les fichiers dépendants, parmi lesquels les deux fichiers les plus importants qui précisent les points d’entrée de l’application sont les suivants :
oL’application de mappage Java comme l’application du dialogue (MappingApplication.java)
oL’application de mappage Java en tant qu’application de console (MappingConsole.java)
•Le fichier build.xml que vous pouvez exécuter avec Apache Ant pour compiler le projet et générer les fichiers JAR
Les noms par défaut de l’application de mappage et ses fichiers dépendants dans le pack com.mapforce sont préfixés avec Mappage. Vous pouvez changer ceci et d’autres paramètres dans la boîte de dialogue Paramètres de mappage.
Une fois que vous avez généré le code Java, les prochaines étapes seraient de créer et d’exécuter le code. Il existe deux approches majeures pour créer le code généré et exécuter l’application : (i) dans Eclipse et (ii) à la ligne de commande, utilisez Apache Ant. Les procédures générales sont décrites dans les sous-sections ci-dessous.
Construire le code généré et exécuter l’application dans Eclipse
Cette approche utilise le flux de travail d’Eclipse. Notez les exigences préalables suivantes :
•Installer le Java Development Kit (JDK) , Eclipse, et Apache Ant doit être installé sur votre système. Eclipse contient généralement une version bundled d'Ant, mais vous pouvez aussi installer Ant séparément.
•Pour exécuter Eclipse avec OpenJDK, la variable d'environnement PATH exige généralement l'inclusion du chemin dans le répertoire bin JDK bin (par exemple C:\Java\jdk-11.0.1\bin).
•La variable d'environnement JAVA_HOME doit pointer vers le répertoire d'installation JDK.
•La variable d'environnement ANT_HOME doit pointer vers l’emplacement d’Apache Ant.
Une fois que vous avez généré du code Java, la prochaine étape est d’importer le code Java généré dans Eclipse. Suivez les étape ci-dessous :
1.Dans le menu File, cliquez avant sur Import et sélectionnez General | Existing Projects into Workspace.
2.Cliquez sur Suivant.
3.Fournissez le chemin au code généré et cliquez sur Finish. Le projet Java créé par MapForce est maintenant disponible dans le mode Package Explorer. Si vous ne pouvez pas voir le mode Package Explorer, utilisez la commande de menu Window | Show View | Package Explorer.
Notez que, par défaut, le code est créé automatiquement à chaque fois qu’un changement est détecté. Vous pouvez aussi désactiver la fonction et créer un code, le cas échéant (voir la documentation Eclipse pour les détails).
Une fois que vous avez importé et créé votre code, la prochaine étape est d’exécuter l’application. Ce chapitre discute certaines des approches possibles pour exécuter l’application.
Approche 1 : Exécuter le projet en tant qu'application
Cette méthode vous permet d’exécuter votre projet Java comme une application GUI. Suivez les étapes ci-dessous :
1.Dans le mode Package Explorer d’Eclipse, cliquez avec la touche de droite sur le fichier MappingApplication.java dans le package com.mapforce.
2.Sélectionnez Run As | Java application depuis le menu contextuel.
3.Dans la fenêtre d’application MapForce qui apparaît, cliquer sur Start pour exécuter le mappage.
Approche 2 : Exécuter un projet en tant qu'application de console
Cette méthode vous permet d’exécuter votre projet Java comme une application (command-line) de console. Suivez les étapes ci-dessous :
1.Dans le mode Package Explorer d’Eclipse, cliquez avec la touche de droite sur le fichier MappingConsole.java dans le package com.mapforce.
2.Sélectionnez Run As | Java application depuis le menu contextuel.
En conséquence, après avoir exécuté l’application, l’application Java exécutera la transformation du mappage et générera un/des fichier/s de sortie dans le dossier de destination.
Construire le code généré et exécuter l’application à la ligne de commande
Pour pouvoir créer et exécuter le code généré à la ligne de commande, vous devez avoir les composants suivants installés et définir les variables d’environnement :
•Installer le Java Development Kit (JDK) et Apache Ant sur votre système.
•L’emplacement du répertoire Ant bin (par ex., C:\apache-ant-1.10.5\bin) devrait être ajouté à la variable d’environnement PATH. Ceci permettra d’exécuter Ant de manière pratique sans avoir à taper tout le chemin dans le programme d’exécution dans la ligne de commande.
•La variable d'environnement JAVA_HOME doit pointer vers l’emplacement de JDK.
•La variable d'environnement ANT_HOME doit pointer vers l’emplacement d’Apache Ant.
Pour construire le code généré avec Apache Ant, suivez les instructions suivantes :
1.Ouvrez une invite de commande et basculez vers le répertoire où le code généré, y compris le fichier build (build.xml), est stocké.
2.Exécuter la commande suivante :
ant jar
Cette commande créera le code généré et crée un fichier JAR (appelé Mapping.jar par défaut). L’objet du fichier JAR est de packager les fichiers Java .class et leurs métadonnées et ressources. Dans notre cas, l’archive JAR est prévue être utilisée comme programme Java exécutable ; pour cette raison, le fichier manifeste de l’archive inclut le point d’entrée de l’application (par par défaut, com.mapforce.MappingConsole).
Pour exécuter l’application Java, exécutez la commande suivante dans le répertoire où l’archive JAR est située :
java com.mapforce.MappingConsole Mapping.jar
Cette commande lance Java Virtual Machine, lance la classe principale appelée com.mapforce.MappingConsole, qui se réfère au point d’entrée de l’application Java, et exécute le programme contenu dans le fichier JAR appelé Mapping.jar. En conséquence, l’application Java exécutera la transformation du mappage et générera un/des fichier/s de sortie dans le dossier de destination. Si vous voulez lancer l’application comme application GUI, passez la valeur suivante pour l’argument de classe principal : com.mapforce.MappingApplication. Ceci ouvrira une fenêtre pop-up dans laquelle vous pourrez démarrer la transformation du mappage.
Éviter certains problèmes possibles « out-of-memory »
Les mappages complexes avec des schémas larges peuvent produire une grande quantité de code, qui peut entraîner une exception java.lang.OutofMemory pendant la compilation dans Ant. Éviter certains problèmes possibles « out-of-memory », suivez les étapes ci-dessous :
1.Ajouter la variable la variable d’environnement ANT_OPTS, qui définit des options Ant spécifiques comme la mémoire à attribuer à l’ordinateur, et configurer sa valeur comme suit : -server -Xmx512m -Xms512m.
2.Pour vous assurer que le compileur et le code généré soient exécutés dans le même processus qu’Ant, changer l’attribut fork dans build.xml en false.
Vous devrez éventuellement personnaliser les valeurs selon la quantité de mémoire disponible dans votre appareil et la taille du projet sur lequel vous travaillez. Pour plus de détails, voir votre documentation Java VM.
Lorsque vous exécutez la commande ant jar, vous recevrez éventuellement un message d’erreur de type "[...] archive contains more than 65535 entities". Afin d’éviter cela, il est recommandé d’utiliser Ant 1.9 ou plus et d’ajouter zip64mode="as-needed" dans l’élément <jar> dans build.xml.
Prévenir des problèmes possibles avec les connexions JDBC
Si vous avez généré le code Java depuis un mappage qui se connecte à une base de données par le biais de JDBC, vous allez avoir besoin d’ajouter le pilote JDBC comme entrée classpath à la configuration actuelle. Autrement, exécuter l’application pourrait engendrer une erreur. Pour les détails, voir Bases de données.