Altova MapForce Server 2024 Advanced Edition

Exemple : Exécuter un mappage avec des paramètres

Cet exemple vous montre comment compiler un mappage MapForce vers un fichier d'exécution MapForce Server (.mfx) et l'exécuter depuis l'API MapForce. L'exemple illustre spécifiquement le scénario selon lequel le mappage prend le nom de fichier d'entrée en tant que paramètre. Voir aussi un des exemples C#, C++, VB.NET, VBScript ou Java précédents.

Dans cet exemple, MapForce est utilisé de manière à ce que vous pouvez consulter et comprendre le design de mappage d'origine. MapForce est aussi utilisé pour compiler le mappage dans un fichier d'exécution MapForce Server (.mfx) et de configurer les paramètres tels que des chemins relatifs par rapport à des chemins absolus.

La plateforme de serveur utilisée dans l'exemple est Windows. Elle peut se trouver soit sur le même appareil sur lequel MapForce est installé, soit un autre appareil. Vous pouvez aussi exécuter cet exemple sur un appareil Linux ou Mac (dans Java), à condition que vous ajustiez les chemins de style Windows pour qu'ils soient applicables à votre plateforme.

Exigences préalables

L'exécution de ce mappage nécessite les mêmes exigences préalables que celles décrites dans les exemples C#, C++, VB.NET, VBScript ou Java précédents.

Préparer le mappage pour l'exécution de serveur

Une fois avoir installé MapForce et avoir exécuté MapForce pour la première fois, plusieurs fichiers de design de mappage de démonstration sont disponibles sous :

C:\Users\<username>\Documents\Altova\MapForce2024\MapForceExamples

Assurez-vous de modifier le chemin ci-dessus si vous avez une version différente de MapForce.

Le design de mappage utilisé dans cet exemple est appelé FileNamesAsParameters.mfd. Comme vous pouvez le constater ci-dessous, il s'agit d'un mappage classique qui copie des données provenant d'une source vers un fichier XML cible, presque sans modifications. Seuls les champs PrimaryKey et Name du fichier XML cible sont remplis avec des constantes provenant du mappage.

mfs_example_design

FileNamesAsParameters.mfd

Le mappage a deux paramètres d'entrée : InputFileName et OutputFileName, respectivement. Afin de pouvoir consulter le mappage dans MapForce, les valeurs de paramètre sont fournies par deux constantes. Comme vous le verrez par la suite, vous pourrez remplacer les valeurs de paramètre avec vos valeurs lorsque le mappage est exécuté avec MapForce Server.

Veuillez noter que les composants de mappage source et cible sont configurés pour recevoir le nom de fichier dynamiquement depuis le mappage. Concrètement, un connecteur d'entrée File: <dynamic> est disponible tout en haut du composant et il lit des données depuis les paramètres de mappage respectifs (InputFileName ou OutputFileName). Dans MapForce, vous pouvez définir ou modifier cette option en cliquant sur la touche Fichier/String dans le coin situé en haut à droite du composant. Veuillez noter que le nom de fichier d'entrée fourni en tant que paramètre doit être une référence à un fichier XML physique qui apporte des données d'entrée dans le mappage (dans cet exemple, Altova_Hierarchical.xml provenant du même dossier que le fichier de design de mappage). Le nom de fichier de sortie peut être n'importe quel nom valide, par exemple Output.xml.

Avant de compiler le mappage dans un fichier d'exécution de MapForce Server (.mfx), vous devrez revoir les paramètres de mappage. Cliquer avec la touche de droite sur une zone vide dans le mappage et sélectionner Paramètres de mappage dans le menu contextuel.

mfs_example_mapping_settings

Modifiez les paramètres tels qu'indiqués ci-dessus. Lorsque vous décochez la case Rendre les chemins absolus dans le code généré, tous les chemins absolus vers les fichiers d'entrée et de sortie utilisés par le mappage sont résolus en tant que relatifs par rapport au fichier de design de mappage (.mfd). Lors de l'exécution du mappage, MapForce Server cherchera ces chemins dans le répertoire de travail du programme. Le répertoire de travail par défaut dépend de la plateforme que vous utilisez pour accéder au API de MapForce Server. Par exemple, dans le cas d'une application C#, il s'agit du même répertoire que le programme d'exécution. De plus, comme vous le verrez ci-dessous, vous pouvez modifier le répertoire de travail avec l'aide d'une propriété d'API appelée WorkingDirectory (ou méthode Java setWorkingDirectory, le cas échéant).

Notes:

•Dans le dialogue Paramètres de mappage, les seuls paramètres qui affectent directement la compilation du fichier .mfx sont Rendre les chemins absolus dans le code généré et Terminaisons de ligne.

•Dan ce mappage, il n'était pas nécessaire d'éditer chaque composant de mappage dans MapForce afin de modifier des chemins absolus en chemins relatifs parce que tous les chemins étaient déjà relatifs. Sinon, vous devriez effectuer cette étape supplémentaire également, voir Préparer des mappages pour l'exécution de serveur.

Dans cet exemple, nous allons utiliser C:\MappingExample en tant que répertoire de travail. Copier le fichier d'entrée Altova_Hierarchical.xml référencé par le mappage depuis C:\Users\<username>\Documents\Altova\MapForce2024\MapForceExamples vers le répertoire de travail.

Dans cet exemple, la source et la cible sont des fichiers XML, et il n'est pas nécessaire de copier le fichier de schéma XML vers le serveur car l'information qui en découle est intégrée dans le fichier .mfx pendant la compilation. Si votre mappage utilise d'autres types de composants (par exemple, des bases de données), il se peut que vous nécessitiez d'autres exigences préalables, comme décrit dans Préparer des mappages pour l'exécution de serveur.

Enfin, pour compiler le mappage dans un fichier d'exécution de serveur, procéder comme suit :

•Dans le menu Fichier, cliquer sur Compiler vers le fichier d'exécution MapForce Server et choisir un répertoire de cible. Dans cet exemple, le répertoire de cible est le même que le répertoire de travail, C:\MappingExample.

Les listes de code suivantes illustrent comment exécuter le mappage depuis des environnements variés, en utilisant l'API MapForce Server. Dans les extraits de code ci-dessous, veuillez noter que les deux paramètres sont référencés par le même nom que celui contenu dans le design de mappage. De plus, les valeurs de paramètre sont le même type de données que celui défini dans le mappage (dans ce cas, string).

Exécuter le mappage depuis C++

Vous pouvez maintenant exécuter le fichier .mfx en utilisant le code C++ comme celui ci-dessous. Pour pouvoir exécuter cet extrait de code, assurez-vous que MapForce Server ait une licence valide, voir aussi la commande CLI verifylicense.

C++

#include <iostream>
#include "atlbase.h"

// 32-bit MapForce Server
#import "progid:MapForce.Server"

int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize( NULL );

try
{
//Create a MapForce Server object
MapForceServerLib::IServerPtr pMFS;
CoCreateInstance( __uuidof( MapForceServerLib::Server ), NULL, CLSCTX_ALL, __uuidof( MapForceServerLib::IServer ), reinterpret_cast< void** >( &pMFS ) );

//Set a working directory - used as a base for relative paths
pMFS->WorkingDirectory = "C:\\MappingExample";

//Prepare the parameters
pMFS->AddParameter("InputFileName", "Altova_Hierarchical.xml");
pMFS->AddParameter("OutputFileName", "Output.xml");

//Run the mapping
if (pMFS->Run("FileNamesAsParameters.mfx"))
std::cout << "Success - finished execution" << std::endl;
else
std::cout << pMFS->LastExecutionMessage << std::endl;

}
catch (_com_error& err )
{
BSTR bstrMessage;
(err).ErrorInfo()->GetDescription( &bstrMessage );
std::cout << "Exception occurred: " << _com_util::ConvertBSTRToString( bstrMessage ) << std::endl;

}

CoUninitialize();
return 0;

}

Exécuter le mappage depuis C#

Vous pouvez maintenant exécuter le fichier .mfx en utilisant le code C# comme celui ci-dessous. Pour pouvoir exécuter cet extrait de code, il faut tout d'abord ajouter une référence au MapForce Server DLL dans Visual Studio, comme décrit dans .NET Interface, et s'assurer que MapForce Server a une licence valide, voir aussi la commande CLI verifylicense.

static void Main(string[] args)
{
try
{
// Create a MapForce Server object
Altova.MapForceServer.Server objMFS = new Altova.MapForceServer.Server();

// Set the working directory - all relative paths will be resolved against it
objMFS.WorkingDirectory = "C:\\MappingExample";

//Prepare the parameters
objMFS.AddParameter("InputFileName", "Altova_Hierarchical.xml");
objMFS.AddParameter("OutputFileName", "Output.xml");

//Run the mapping
if (objMFS.Run("FileNamesAsParameters.mfx"))
System.Console.WriteLine("Success - finished execution");
else
System.Console.WriteLine(objMFS.LastExecutionMessage);
}
catch(System.Runtime.InteropServices.COMException ex)
{
System.Console.WriteLine("Internal Error: " + ex.Message);
}
}

Exécuter le mappage depuis Java

Vous pouvez maintenant exécuter le fichier .mfx en utilisant le code Java comme celui ci-dessous. Pour pouvoir exécuter cet extrait de code, il faut tout d'abord que :

•la variable d'environnement Java CLASSPATH inclue une référence à la bibliothèque MapForceServer.jar, comme décrit dans A propos de l'interface Java

•MapForce Server ait une licence valide, voir aussi la commande CLI verifylicense.

Java

public static void main(String[] args) {
try {
// Create a MapForce Server object
com.altova.mapforceserver.MapForceServer objMFS = new com.altova.mapforceserver.MapForceServer();

// Set the working directory - all relative paths will be resolved against it
// objMFS.setWorkingDirectory("/home/ubuntu/Downloads/MappingExample");
objMFS.setWorkingDirectory("C:\\MappingExample");

// Add the mapping parameters
objMFS.addParameter("InputFileName", "Altova_Hierarchical.xml");
objMFS.addParameter("OutputFileName", "Output.xml");

// Run the mapping
if ( objMFS.run( "FileNamesAsParameters.mfx" ) )
System.out.println( "Success - finished execution" );
else
System.out.println( objMFS.getLastExecutionMessage() );

} catch (Exception e) {
e.printStackTrace();
}

System.out.println("Finished execution");
}