---
url: /res/oie/variable-maps.md
description: Variable Maps utilisable sous Mirth Connect et Open Integration Engine
---

# Variable Maps

## Introduction

Tout au long du cycle de traitement des messages, vos canaux et messages ont accès à différentes maps de variables.

Selon leur portée, ces **Maps** peuvent être limitées au **channel** ou connecteur actuel, ou bien disponibles globalement dans l’ensemble de votre système.

Ces **variable maps** vous permettent de stocker une information que vous pourrez réutiliser ultérieurement (dans un channel ou connecteur en aval, ou ailleurs).

Une utilisation courante de ces variables est de faciliter le glisser-déposer des propriétés des connecteurs.

::: tip Exemple
Par exemple, la liste des mappages de destination affichera toutes les **variable maps** disponibles pour les connecteurs ou channels.

Elles servent également à d’autres fins, comme le remplissage des colonnes de métadonnées personnalisées.
:::

## Variables et raccourcis

Voici les différentes cartes (maps) de variables disponibles dans Mirth® Connect et Open Intégration Engine:

| Mapping                                   | Variable Javascript | Raccourci |
| :---------------------------------------: | :-----------------: | :-------: |
| [Response Map](#response-map)             | responseMap         | $r        |
| [Connector Map](#connector-map)           | connectorMap        | $co       |
| [Channel Map](#channel-map)               | channelMap          | $c        |
| [Source Map](#source-map)                 | sourceMap           | $s        |
| [Global Channel Map](#global-channel-map) | globalChannelMap    | $gc       |
| [Global Map](#global-map)                 | globalMap           | $g        |
| [Configuration Map](#configuration-map)   | configurationMap    | $cfg      |

::: info
A l'écriture de cette page ces `Maps` sont disponibles en version `4.5.2` de `Mirth Connect` et `Open Integration Engine`
:::

## Portées des variables

Toutes ces différentes maps ont des portées différentes, ci-dessous un tableau récapitulatif de la portée d'une variable créer à un instant T.

| Type / Map    | Response Map | Connector Map | Channel Map | Source Map | Global channel Map | Global Map | Configuration Map |
| :-----------: | :----------: | :-----------: | :---------: | :--------: | :----------------: | :--------: | :---------------: |
| Instance      |              |               |             |            |                    | ✅         | ✅ (1)            |
| Channels      | ✅           |               |             |            | ❌                 | ✅         | ✅ (1)            |
| Channel       | ✅           |               |             | ❌         | ✅ (2)             | ✅         | ✅ (1)            |
| Message       |              |               | ✅          | ✅         | ✅ (2)             | ✅         | ✅ (1)            |
| Next Message  |              |               | ❌          | ❌         | ✅ (2)             | ✅         | ✅ (1)            |
| Source        | ✅           |               | ✅          | ✅         | ✅ (2)             | ✅         | ✅ (1)            |
| Dest 1        | ✅           | ✅            | ✅          | ✅         | ✅ (2)             | ✅         | ✅ (1)            |
| Dest X        | ✅           | ❌            | ✅          | ✅         | ✅ (2)             | ✅         | ✅ (1)            |
| Deploy        |              |               |             | ❌         | ✅ (2)             | ✅         | ✅ (1)            |
| Undeploy      |              |               |             | ❌         | ✅ (2)             | ✅         | ✅ (1)            |
| Preprocessor  |              |               |             |            | ✅ (2)             | ✅         | ✅ (1)            |
| Postprocessor | ✅           |               |             |            | ✅ (2)             | ✅         | ✅ (1)            |

* (1) le contenu n'est disponible qu'en lecture seule
* (2) si le **clear global channel map on deploy** est coché, toutes les variables de la Map seront reinitilisées au prochain déploiement

## Response Map {#response-map}

Cette map est isolée au message en cours de traitement dans un channel.

Contrairement à la `Channel Map`, celle-ci est spécifiquement destinée au stockage des objets de réponse.

Lorsqu’une destination termine son traitement, sa réponse est automatiquement enregistrée dans la `Response Map`.

Les destinations suivantes ainsi que le script de post-traitement pourront accéder à ces valeurs.

::: info
Le connecteur source peut également utiliser les valeurs stockées dans la **responseMap** pour envoyer des réponses au système d’origine (paramétré dans les réglages de la source (Source Settings)).
:::

En javascript il est possible d'écrire et de lire cette carte (Map), voir les exemple ci-dessous

::: code-group

```js [Lire une valeur]
var valeur = responseMap.get('cle');
var valeur = $r('cle');
```

```js [Ecrire une valeur]
responseMap.put('cle', 'valeur');
$r('cle', 'valeur');
```

:::

## Connector Map {#connector-map}

Cette map est isolée au message en cours ainsi qu’au connecteur actuel par lequel le message est en train de transiter.

::: info
Par exemple,

Si vous stockez une variable dans la **connector map** de la `Destination 1`, vous ne pourrez pas y accéder depuis la Destination 2.
:::

Cette isolation permet d’éviter les conflits entre noms de variables courants et de limiter l’espace de stockage des messages.

::: code-group

```js [Lire une valeur]
var valeur = connectorMap.get('cle');
var valeur = $co('cle');
```

```js [Ecrire une valeur]
connectorMap.put('cle', 'valeur');
$co('cle', 'valeur');
```

:::

## Channel Map {#channel-map}

Cette map est isolée au message en cours de traitement dans un channel.

Si vous stockez une variable dans la **channel map** source, vous pourrez accéder à cette valeur dans toutes les destinations suivantes.

::: warning
Cependant, une fois le traitement du message actuel terminé et le message suivant démarré, ce nouveau message n’aura pas accès à la valeur que vous aviez stockée pour le message précédent.
:::

La **channel map** est particulièrement utile pour partager des informations entre plusieurs destinations, ou entre le connecteur source et l’ensemble des destinations.

Par exemple, vous pourriez avoir une destination de type `HTTP Sender` qui effectue une requête vers un service distant, puis, dans le transformateur de réponse, stocker un en-tête HTTP spécifique de la réponse dans la **channel map**.

Tant que le connecteur de la destination suivante fait partie de la même chaîne, il pourra accéder à cette variable de la **channel map** et l’utiliser, par exemple en l’incluant dans une requête `HTTP` ultérieure.

::: code-group

```js [Lire une valeur]
var valeur = channelMap.get('cle');
var valeur = $c('cle');
```

```js [Ecrire une valeur]
channelMap.put('cle', 'valeur');
$c('cle', 'valeur');
```

:::

## Source Map {#source-map}

Cette map est isolée au message en cours de traitement dans un channel.

::: warning
Contrairement à la channel map, celle-ci est cependant en lecture seule.
:::

Le connecteur source ou un processus en amont peut injecter des variables dans la **source map**.

Par exemple, le connecteur source `File Reader` injectera automatiquement la variable `originalFilename`.

```js
var valeur = sourceMap.get('cle');
var valeur = $s('cle');
```

## Global Channel Map {#global-channel-map}

Cette map est spécifique à un channel donné, mais partagée entre plusieurs messages.

Cela signifie que vous pouvez y stocker une valeur lors du traitement d’un message, et celle-ci restera accessible pendant le cycle de vie du message suivant. Vous avez également la possibilité de définir des variables globales de la channel map dans les scripts du channel.

::: tip Astuces
Il est possible de reinitialiser `Global Channel Map` en éditant le Channel, puis en cochant la case `Clear global channel map on deploy`

![](./images/clear_global_channel_deploy.png)

sauvegarder la modification et redéployer le Channel
:::

Cette map est particulièrement utile pour conserver des objets étatiques et non sérialisables, comme une connexion à une base de données.

Elle est uniquement maintenue en mémoire, ce qui implique que si Mirth Connect® ou Open Integration Engine est redémarré, les entrées de cette map ne sont pas conservées.

::: warning Attention
Il s’agit par ailleurs d’une carte concurrente ([concurrent map en Java](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentMap.html)), ce qui signifie qu’il n’est pas possible d’y stocker des valeurs `null`.
:::

::: code-group

```js [Lire une valeur]
var valeur = globalChannelMap.get('cle');
var valeur = $gc('cle');
```

```js [Ecrire une valeur]
globalChannelMap.put('cle', 'valeur');
$gc('cle', 'valeur');
```

:::

## Global Map {#global-map}

Cette map est disponible à l’échelle de l’ensemble de votre serveur, pour tous les canaux et tous les messages.

Cela signifie que vous pouvez y stocker une valeur lors du traitement d’un message dans un channel, puis réutiliser cette valeur depuis un autre channel, ou encore dans un contexte différent comme une alerte.

Vous avez également la possibilité de définir des variables globales dans les scripts globaux (Deploy, Undeploy, Preprocessor, Postprocessor).

![](./images/global_map_global_screen.png)

À l’instar de la **global channel map**, cette carte est particulièrement adaptée pour conserver des objets étatiques et non sérialisables, tels qu’une connexion à une base de données.

Elle est exclusivement maintenue en mémoire, ce qui implique que si Mirth Connect® ou OIE est redémarré, les entrées de cette map ne sont pas conservées.

::: warning Attention
Il s’agit également d’une carte concurrente ([concurrent map en Java](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentMap.html)), ce qui interdit le stockage de valeurs `null`.
:::

::: code-group

```js [Lire une valeur]
var valeur = globalMap.get('cle');
var valeur = $g('cle');
```

```js [Ecrire une valeur]
globalMap.put('cle', 'valeur');
$g('cle', 'valeur');
```

:::

## Configuration Map {#configuration-map}

Cette map est également disponible sur l’ensemble de votre serveur, pour tous les canaux et tous les messages.

À l’instar de la **Global Map**, cela signifie que vous pouvez utiliser les valeurs de la **configuration map** dans n’importe quel channel, ou encore dans un autre contexte comme une alerte.

Contrairement à la **Global Map**, cependant, cette map n’est modifiable qu’à partir de l’onglet « Paramètres de la **configuration map** » et reste en lecture seule depuis la perspective des canaux ou des messages.

![](./images/configuration_map_settings.png)

Ses valeurs se limitent par ailleurs à des paires clé/valeur de type chaîne de caractères.

Cette map est particulièrement utile pour définir des paramètres globaux et statiques que vous souhaitez conserver après un redémarrage de Mirth Connect.

Par exemple, vous pourriez y stocker une variable telle que `PortClientTcp`, puis utiliser Velocity pour faire référence à cette variable `${PortClientTcp}` dans un service TCP.

Ainsi, vous pourriez exporter un channel depuis une installation de Mirth Connect® our Open Integration Engine, l’importer dans une installation totalement différente, et n’aurez rien à modifier dans les paramètres du channel, à condition que la même **configuration map** soit définie dans la nouvelle instance.

```js
var valeur = configurationMap.get('cle');
var valeur = $cfg('cle');
```