MQ-Anforderungsnachricht empfangen, an MQ übergeben und anschließend die Antwort von MQ an den Anforderungsclient zurückgeben

Empfange eine „ IBM® MQ “-Anforderungsnachricht, leite die Nachricht an „ IBM MQ “ weiter und sende anschließend die „ IBM MQ “-Antwort an den anfragenden Client.

Vorbereitungen

In diesem Szenario werden auf den Knoten „ MQ “ Server-Bindungen verwendet, um eine Verbindung zu „ IBM MQ “ herzustellen. IBM MQ muss daher auf demselben Computer wie der Integrationsknoten installiert werden. Alternativ dazu können Sie die MQ-Knoten für Fernverbindungen konfigurieren. Diese Schritte sind in diesem Szenario jedoch nicht beschrieben. Weitere Informationen finden Sie unter „Konfigurieren von Verbindungen zu IBM MQ “.

Informationen zu dieser Task

Bei einem Anforderung/Antwort-Nachrichtenfluss handelt es sich um eine spezielle Form einer Punkt-zu-Punkt-Anwendung. Eine allgemeine Beschreibung dieser Anwendungen finden Sie unter Knoten für Konnektivität.

Dieses Szenario wird zum Verbinden von Clientanwendungen verwendet.

Szenario:

Zwei Anwendungen mit unterschiedlichen Nachrichtenformaten kommunizieren miteinander, indem sie in einer Lösung zur Verarbeitung von Anfrage-Antwort-Nachrichten die „ IBM MQ “ nutzen. Damit die Anwendungen erfolgreich kommunizieren können, müssen die Nachrichtenformate in „ IBM App Connect Enterprise “ sowohl bei den Anfrage- als auch bei den Antwortnachrichten umgewandelt werden. Die Back-End-Anwendung wird in diesem Szenario durch einen dritten Nachrichtenfluss dargestellt, um die erfolgreiche Verarbeitung der Nachricht zu veranschaulichen.

Für das Anfrage-Antwort-Verfahren sind zwei Nachrichtenflüsse erforderlich, da „ IBM MQ “ Nachrichten asynchron verarbeitet. Nachrichten, die in „ IBM App Connect Enterprise “ asynchron verarbeitet werden, warten nicht auf eine Antwort, und „ IBM MQ “ sendet keine Antwortnachricht. Beim Verarbeiten einer Antwort verwendet die Speicherwarteschlange die Eigenschaft ReplyToQ (Antwortwarteschlange) der ursprünglichen Nachricht, sodass ein zweiter Nachrichtenfluss eine Antwort von einer Anwendung verarbeiten kann.

Dieses Szenario veranschaulicht, wie Anforderungs- und Antwortnachrichtenflüsse erstellt werden und wie Nachrichtenstatusinformationen in einer Speicherwarteschlange gespeichert werden. Der Nachrichtenfluss, der die Back-End-Anwendung darstellt, ändert den Wert der "Fertigstellungszeit" in der Nachricht.

Anleitungen:

Die folgenden Schritte zeigen, wie Sie die Nachrichtenflüsse und eine Warteschlange für den Speicherstatus einrichten, damit eine Antwortnachricht von IBM MQ verarbeitet werden kann.

Vorgehensweise

Erstellen Sie einen Nachrichtenfluss mit dem Namen MQ_Task2_Request mit den folgenden Knoten und benennen Sie sie in der Eigenschaft Knotenname der Registerkarte Beschreibung :
- Einen MQInput -Knoten mit dem Namen Receive Message
- Vier Rechenknoten namens Transform Request Message, Save MQMD Headers to LocalEnvironment, Set New ReplyToQund Build State Message.
- Zwei MQOutput -Knoten mit den Namen Output Request Message und Store State Message.
Weitere Informationen finden Sie im Artikel Nachrichtenfluss erstellen.
Verbinden Sie das Ausgangsterminal des Receive Message MQInput -Knotens mit dem Eingangsterminal des Transform Request Message Compute -Knotens.
Verbinden Sie das Ausgangsterminal des Transform Request Message -Rechenknotens mit dem Eingangsterminal des Save MQMD Headers to LocalEnvironment -Rechenknotens .

Hinweis: Für die Nachrichtenverarbeitung, die Sie zwischen dem Receive Message MQInput -Knoten und dem Save MQMD Headers to LocalEnvironment Compute -Knoten benötigen, können Sie einen eigenen Transformationsknoten oder einen untergeordneten Nachrichtenfluss hinzufügen. Der Transform Request Message Compute -Knoten ist in diesem Szenario ein Platzhalter, der die Nachricht nicht transformiert.
Verbinden Sie das Ausgangsterminal des Save MQMD Headers to LocalEnvironment -Rechenknotens mit dem Eingangsterminal des Set New ReplyToQ -Rechenknotens .
Verbinden Sie das Ausgangsterminal des Set New ReplyToQ Compute -Knotens mit dem Eingangsterminal des Output Request Message MQOutput -Knotens.
Verbinden Sie das Ausgangsterminal des Output Request Message MQOutput -Knotens mit dem Eingangsterminal des Build State Message Compute -Knotens.
Verbinden Sie das Ausgangsterminal des Build State Message Compute -Knotens mit dem Eingangsterminal des Store State Message MQOutput -Knotens.

Jetzt müssen Sie die Nachrichtenflussknoten für das Anforderungsverhalten des Nachrichtenflusses konfigurieren.

Legen Sie die folgenden Eigenschaften des Receive Message MQInput -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.IN1.
2. Setzen Sie auf der Registerkarte MQ -Verbindung die Eigenschaft Verbindung auf Lokaler Warteschlangenmanagerund anschließend die Eigenschaft Zielwarteschlangenmanager auf TASK2_QUEUE_MANAGER.
3. Setzen Sie auf der Registerkarte Parsing der Eingabenachricht die Eigenschaft Nachrichtendomäne auf XMLNSC.
Legen Sie die folgenden Eigenschaften des Transform Request Message Compute -Knotens fest:
1. Das ESQL-Modul MQ_Task2_Request_Transform_Reply_Messagewird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Request_Transform_Reply_Message .
2. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Request_Transform_Reply_Message
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputRoot = InputRoot;
		RETURN TRUE;
	END;
END MODULE;
```
  Transform Request Message Compute wandelt die Nachricht nicht um und fungiert als Platzhalter für dieses Szenario.
Legen Sie die folgenden Eigenschaften des Save MQMD Headers to LocalEnvironment Compute -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Berechnungsmodus auf LocalEnvironment.
2. Das ESQL-Modul MQ_Task2_Request_Save_MQMD_Headers_to_LocalEnvironmentwird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Request_Save_MQMD_Headers_to_LocalEnvironment .
3. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Request_Save_MQMD_Headers_to_LocalEnvironment
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputLocalEnvironment.Variables.OriginalMQMD = InputRoot.MQMD;
		RETURN TRUE;
	END;
END MODULE;
```
  Der Save MQMD Headers to LocalEnvironment Compute -Knoten speichert den MQMD der ursprünglichen Nachricht in einer lokalen Umgebungsvariablen, die später vom Build State Message Compute -Knoten im Nachrichtenfluss abgerufen wird.
Legen Sie die folgenden Eigenschaften des Set New ReplyToQ Compute -Knotens fest:
1. Das ESQL-Modul MQ_Task2_Request_Set_New_ReplyToQwird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Request_Set_New_ReplyToQ .
2. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Request_Set_New_ReplyToQ
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputRoot = InputRoot;
		SET OutputRoot.MQMD.ReplyToQ = 'MQ.TASK2.BACKEND.RESP1';
		SET OutputRoot.MQMD.ReplyToQMgr = 'TASK2_QUEUE_MANAGER';
		RETURN TRUE;
	END;
END MODULE;
```
  Der Set New ReplyToQ Compute -Knoten legt einen neuen Wert für ReplytoQ fest, sodass die Antwortnachrichtenflusswarteschlange verwendet wird.
Legen Sie die folgenden Eigenschaften des Output Request Message MQOutput -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.BACKEND.REQ1.
2. Wählen Sie auf der Registerkarte Erweitert die Eigenschaft Neue Nachrichten-ID aus.
Legen Sie die folgenden Eigenschaften des Build State Message Compute -Knotens fest:
1. Das ESQL-Modul MQ_Task2_Request_Build_State_Messagewird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Request_Build_State_Message .
2. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Request_Build_State_Message
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		CALL CopyMessageHeaders();
		SET OutputRoot.MQMD.CorrelId = InputLocalEnvironment.WrittenDestination.MQ.DestinationData.msgId;
		SET OutputRoot.MQMD.ReplyToQ = InputLocalEnvironment.Variables.OriginalMQMD.ReplyToQ;
		SET OutputRoot.MQMD.ReplyToQMgr = InputLocalEnvironment.Variables.OriginalMQMD.ReplyToQMgr;
		SET OutputRoot.BLOB.BLOB = InputLocalEnvironment.Variables.OriginalMQMD.MsgId;
		RETURN TRUE;
	END;
	
	CREATE PROCEDURE CopyMessageHeaders() BEGIN
		DECLARE I INTEGER 1;
		DECLARE J INTEGER;
		SET J = CARDINALITY(InputRoot.*[]);
		WHILE I < J DO
			SET OutputRoot.*[I] = InputRoot.*[I];
			SET I = I + 1;
		END WHILE;
	END;
END MODULE;
```
  Der Build State Message Compute -Knoten:
  1. Er extrahiert die Nachrichten-ID der in MQ.TASK2.BACKEND.REQ1 geschriebenen Nachricht.
  2. Er extrahiert die ursprünglichen Werte für Warteschlange für Antwortnachrichten (ReplyToQ) und Warteschlangenmanager für zu beantwortende Nachrichten (ReplyToQMgr) aus der lokalen Umgebung. Diese Werte werden im MQMD der Statusnachricht gespeichert.
  3. Er extrahiert den ursprünglichen Wert für Nachrichten-ID (MessageId) aus der lokalen Umgebung (LocalEnvironment) und speichert diesen Wert im Hauptteil der Statusnachricht.
  4. Er verwendet den BLOB-Parser, um den Hauptteil der Statusnachricht zu lesen und zu schreiben, weil die Nachrichten-ID aus binären Daten besteht.
Legen Sie die folgenden Eigenschaften des Store State Queue MQOutput -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.STATE1.
2. Wählen Sie auf der Registerkarte Erweitert die Eigenschaft Neue Nachrichten-ID aus.

Sie müssen jetzt den Antwortnachrichtenfluss erstellen.

Erstellen Sie einen Nachrichtenfluss mit dem Namen MQ_Task2_Reply mit den folgenden Knoten und benennen Sie sie in der Eigenschaft Knotenname der Registerkarte Beschreibung :
- Einen MQInput -Knoten mit dem Namen Receive Backend Application Reply
- Einen MQGet -Knoten mit dem Namen Get Original MQMD.
- Ein MQOutput -Knoten mit dem Namen Send Reply.
- Zwei Rechenknoten mit den Namen Transform Reply Message und Set CorrelID And RTQ.
- Zwei Throw -Knoten mit den Namen Handle MQGet Warning und Handle Error No Store Message.
Verbinden Sie das Ausgangsterminal des Receive Backend Application Reply MQInput -Knotens mit dem Eingangsterminal des Transform Reply Message Compute -Knotens.
Verbinden Sie das Ausgangsterminal des Transform Reply Message -Knotens Compute mit dem Eingangsterminal des Get Original MQMD MQGet -Knotens.
Verbinden Sie das Warnterminal des Get Original MQMD MQGet -Knotens mit dem Handle MQGet Warning Throw -Knoten.
Verbinden Sie das Fehlerterminal des Get Original MQMD MQGet -Knotens mit dem Handle Error Not Stored Message Throw -Knoten.
Verbinden Sie das Ausgangsterminal des Get Original MQMD MQGet -Knotens mit dem Set CorrelID And RTQ Compute -Knoten.
Verbinden Sie das Ausgangsterminal des Set CorrelID And RTQ Compute -Knotens mit dem Send Reply MQOutput -Knoten.

Jetzt müssen Sie die Nachrichtenflussknoten für das Antwortverhalten des Nachrichtenflusses konfigurieren.

Legen Sie die folgenden Eigenschaften des Receive Backend Application Reply MQInput -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.BACKEND.RESP1.
2. Setzen Sie auf der Registerkarte Parsing der Eingabenachricht die Eigenschaft Nachrichtendomäne auf XMLNSC.
Legen Sie die folgenden Eigenschaften des Transform Reply Message Compute -Knotens fest:
1. Das ESQL-Modul MQ_Task2_Reply_Transform_Reply_Messagewird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Reply_Transform_Reply_Message .
2. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Reply_Transform_Reply_Message
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputRoot = InputRoot;
		RETURN TRUE;
	END;
END MODULE;
```
  Der Rechenknoten transformiert die Nachricht nicht. Der Rechenknoten ist ein Platzhalter für die Lösungstransformation in diesem Szenario.
Setzen Sie die folgenden Eigenschaften des Get Original MQMD MQGet -Knotens:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.STATE1.
2. Setzen Sie auf der Registerkarte MQ -Verbindung die Eigenschaft Verbindung auf Lokaler Warteschlangenmanagerund anschließend die Eigenschaft Zielwarteschlangenmanager auf TASK2_QUEUE_MANAGER.
3. Setzen Sie auf der Registerkarte Parsing der Eingabenachricht die Eigenschaft Nachrichtendomäne auf BLOB.
4. Auf der Registerkarte Erweitert :
  - Setzen Sie die Eigenschaft Nachricht kopieren auf Gesamte Nachricht kopieren.
  - Setzen Sie die Eigenschaft Lokale Umgebung kopieren auf Gesamte lokale Umgebung kopieren.
5. Auf der Registerkarte Anforderung :
  - Setzen Sie die Eigenschaft MQMD-Position in der Eingabe auf InputRoot.MQMD.
  - Wählen Sie die Eigenschaft Abruf nach Korrelations-ID aus.
6. Auf der Registerkarte Ergebnis (Result) :
  - Setzen Sie die Eigenschaft Position für Ausgabedaten auf OutputLocalEnvironment.ResultRoot.
  - Setzen Sie die Eigenschaft Position der Ergebnisdaten auf ResultRoot.
Legen Sie die folgenden Eigenschaften des Set CorrelId And RTQ Compute -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Rechenmodus auf MQ.TASK2.STATE1.
2. Das ESQL-Modul MQ_Task2_Reply_Set_CorrelId_And_RTQwird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_Reply_Set_CorrelId_And_RTQ .
3. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_Reply_Set_CorrelId_And_RTQ
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputRoot = InputRoot;
		SET OutputRoot.MQMD.CorrelId = InputLocalEnvironment.Variables.ResultRoot.BLOB.BLOB;
		SET OutputLocalEnvironment.Destination.MQ.DestinationData[1].queueName = InputLocalEnvironment.Variables.ResultRoot.MQMD.ReplyToQ;
		SET OutputLocalEnvironment.Destination.MQ.DestinationData[1].queueManagername = InputLocalEnvironment.Variables.REResultRoot.MQMD.ReplyToQMgr;
		RETURN TRUE;
	END;
END MODULE;
```
  Der Set CorrelId And RTQ Compute -Knoten:
  1. Er extrahiert ReplyToQ (Warteschlange für Antwortnachrichten) und ReplyToQMgr (Zielwarteschlangenmanager für Antwortnachrichten) aus dem MQMD der Statusnachricht.
  2. Er legt eine Korrelations-ID (CorrelId) fest, die der Wert der Nachrichten-ID (MessageId) im Hauptteil der ursprünglichen Statusnachricht ist. Die Korrelations-ID (CorrelId) wird für den Antwortnachrichtenfluss verwendet.
Legen Sie die folgenden Eigenschaften des Send Reply MQOutput -Knotens fest:
1. Setzen Sie auf der Registerkarte Erweitert die Eigenschaft Zielmodus auf Zielliste
  
  Wenn Sie den MQOutput -Knoten im Ziellistenmodus festlegen, kann die Ausgabewarteschlange dynamisch festgelegt werden.
Legen Sie die folgenden Eigenschaften des Handle MQGet Warning -Knotens Throw fest:
1. Geben Sie auf der Registerkarte Basis Fehlernachrichtentext in das Feld Nachrichtentext ein.
  "MQGet hat beispielsweise eine Warnung zurückgegeben."
  
  Wenn eine Warnung in der Nachricht vom MQGet -Knoten auftritt, gibt der Handle_MQGet_Warning Throw -Knoten eine Fehlernachricht zu dieser Warnung zurück. Die Nachrichtenbaumstruktur enthält den MQMD und den Nachrichteninhalt, der empfangen wurde.
Legen Sie die folgenden Eigenschaften des Handle Error Not Stored Message -Knotens Throw fest:
1. Geben Sie auf der Registerkarte Basis Fehlernachrichtentext in das Feld Nachrichtentext ein.
  Beispiel: "MQGet -Fehler, keine Speichernachrichtenwarteschlange empfangen."
Wenn ein Fehler auftritt, weil der MQGet-Knoten die Nachricht nicht aus der Speicherwarteschlange abrufen konnte, gibt der Handle_Error_Not_Stored_Message Compute -Knoten eine Fehlernachricht zurück. Die Nachricht wird nicht verarbeitet.

Sie können die Nachricht nicht aus dem Antwortnachrichtenfluss an den Anforderungsnachrichtenfluss zurückgeben. Daher muss die Fehlerbehandlung auf einer höheren Ebene in Ihrer Messaging-Architektur erfolgen als die Fehlerbehandlungsoptionen, die durch die Nachrichtenflussknoten bereitgestellt werden.

Der Nachrichtenfluss kann jetzt mit einer Back-End-Anwendung kommunizieren. Erstellen Sie für dieses Szenario einen dritten Nachrichtenfluss, der diese Anwendung darstellt.

Eine Back-End-Anwendung kopiert standardmäßig die MessageId (Nachrichten-ID) der Nachricht in ihre CorrelId (Korrelations-ID) und dieser Wert wird in der Antwortnachricht gesendet. Da in diesem Szenario jedoch keine reale Anwendung verwendet wird, wurde diese Aktion vom Save MQMD Headers to LocalEnvironment Compute -Knoten in Schritt 10 für den Anforderungsnachrichtenfluss ausgeführt.

Um zu veranschaulichen, dass die Back-End-Anwendung erfolgreich im Antwortnachrichtenfluss verarbeitet wird, ändert ein Rechenknoten den Wert für die Fertigstellungszeit in der Nachricht.

Erstellen Sie einen Nachrichtenfluss mit dem Namen MQ_Task2_BackendApp mit den folgenden Knoten und benennen Sie sie auf der Registerkarte Beschreibung mit der Eigenschaft Knotenname :
- Einen MQInput -Knoten mit dem Namen Get Request Message
- Einen Rechenknoten namens Modify Completion Time.
- Einen MQReply -Knoten namens Put Reply Message.
Verbinden Sie das Ausgangsterminal des Get Request Message MQInput -Knotens mit dem Eingangsterminal des Modify Completion Time Compute -Knotens.
Verbinden Sie das Out-Terminal des Modify Completion Time Compute -Knotens mit dem In-Terminal des Put Reply Message MQReply -Knotens.
Legen Sie die folgenden Eigenschaften des Get Request Message MQInput -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.BACKEND.REQ1.
2. Setzen Sie auf der Registerkarte MQ -Verbindung die Eigenschaft Verbindung auf Lokaler Warteschlangenmanagerund anschließend die Eigenschaft Zielwarteschlangenmanager auf TASK2_QUEUE_MANAGER.
3. Setzen Sie auf der Registerkarte Parsing der Eingabenachricht die Eigenschaft Nachrichtendomäne auf XMLNSC.
Legen Sie die folgenden Eigenschaften des Modify Completion Time Compute -Knotens fest:
1. Das ESQL-Modul MQ_Task2_BackendApp_Modify_Completion_Timewird automatisch erstellt. Öffnen Sie in der Ansicht Anwendungsentwicklung ESQLsund anschließend das Modul MQ_Task2_BackendApp_Modify_Completion_Time .
2. Kopieren Sie folgenden ESQL-Code in das Modul:
```
CREATE COMPUTE MODULE MQ_Task2_BackendApp_Modify_Completion_Time
	CREATE FUNCTION Main() RETURNS BOOLEAN
	BEGIN
		SET OutputRoot = InputRoot;
		SET OutputRoot.XMLNSC.SaleEnvelope.TimeStamp = CURRENT_GMTTIMESTAMP;
		RETURN TRUE;
	END;
END MODULE;
```
  Der Modify Completion Time Compute -Knoten stellt die Lösungstransformation in diesem Szenario dar. Der Rechenknoten fügt der Nachricht einen Zeitmarkenwert hinzu, der die Verarbeitungszeit anzeigt.
Legen Sie die folgenden Eigenschaften des Get Request Message MQReply -Knotens fest:
1. Setzen Sie auf der Registerkarte Basis die Eigenschaft Warteschlangenname auf MQ.TASK2.BACKEND.REQ1.
2. Setzen Sie auf der Registerkarte MQ -Verbindung die Eigenschaft Verbindung auf Lokaler Warteschlangenmanagerund anschließend die Eigenschaft Zielwarteschlangenmanager auf TASK2_QUEUE_MANAGER.
Speichern Sie den Nachrichtenfluss.

Ergebnisse

Wenn der Anforderungsnachrichtenfluss ausgeführt wird, finden die folgenden Aktionen statt:
1. Der MQInput -Knoten liest eine „ IBM MQ “-Anforderungsnachricht.
2. Die ursprüngliche Nachricht wird in ein entsprechendes Format für die Back-End-Anwendung transformiert.
3. Die Angaben ReplyToQ und ReplyToQMgr werden als Eingabenachricht für den Antwortnachrichtenfluss festgelegt.
4. Es wird eine „ IBM MQ “-Nachricht erstellt, die die transformierte Nachricht enthält. Diese Nachricht wird an den Back-End-Nachrichtenfluss gesendet.
5. Die ursprünglichen Angaben zu „MessageId“, „ReplyToQ“ und „ ReplyToQMgr “ werden in einer separaten „ IBM MQ “-Nachricht gespeichert, damit sie später vom „Reply“-Nachrichtenfluss abgerufen werden können.
Wenn der Antwortnachrichtenfluss ausgeführt wird, finden die folgenden Aktionen statt:
1. MQInput liest die Nachricht „ IBM MQ “, die eine Nachricht im Datenformat aus der Backend-Anwendung enthält.
2. Die Nachricht wird in das entsprechende Format für die Anforderungsanwendung transformiert.
3. Der MQGet-Knoten ruft die Angaben zu CorrelId, ReplyToQ und ReplyToQMgr der ursprünglichen Anforderungsnachricht ab, indem er die Nachricht „ IBM MQ “ ausliest, in der diese Informationen im Ablauf der Anforderungsnachricht gespeichert wurden.
4. Es wird eine „ IBM MQ “-Nachricht erstellt, die die transformierte Nachricht sowie die abgerufenen Werte für „CorrelId“, „ReplyToQ“ und „ ReplyToQMgr “ enthält.