Der Beispielcode für den Bindungs-Converter im Projekt BindingConverter ist ein Beispiel für einen benutzerdefinierten Bindungs-Converter für WebSphere ESB-Exporte mit einer MQ-Bindung. Dieser Export verfügt über eine Schnittstelle, die eine Operation des Typs Anfrage/Antwort definiert.
Bei diesem benutzerdefinierten Muster-Converter für Exportbindungen handelt es sich um eine Java-Klasse, mit deren Hilfe das WebSphere ESB-Konvertierungstool einen WebSphere ESB-Export mit einer MQ-Bindung in IBM Integration Bus-Ressourcen konvertieren kann. Mit der Converter-Klasse wird eine MQ-Bindung in einen MQInput-Knoten und einen MQOutput-Knoten konvertiert, die den Transport übernehmen, in einen Zuordnungsknoten und einen RouteToLabel-Knoten, mit denen die Logik des Funktionsselektors implementiert wird, und in einen ResetContentDescriptor-Knoten, mit dem die Logik für die Datenbindung implementiert wird.
In diesem Beispielcode werden die folgenden Nachrichtenflussknoten verwendet:
Im Folgenden wird der Code für den Muster-Converter für Bindungen beschrieben:
import java.io.ByteArrayInputStream; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import javax.wsdl.Operation; import javax.wsdl.PortType; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject;
import com.ibm.broker.config.appdev.MessageMSLMap; import com.ibm.broker.config.appdev.Terminal; import com.ibm.broker.config.appdev.nodes.MQInputNode; import com.ibm.broker.config.appdev.nodes.MQOutputNode; import com.ibm.broker.config.appdev.nodes.MappingMSLNode; import com.ibm.broker.config.appdev.nodes.PassthroughNode; import com.ibm.broker.config.appdev.nodes.ResetContentDescriptorNode; import com.ibm.broker.config.appdev.nodes.RouteToLabelNode;
import com.ibm.etools.mft.conversion.esb.extensionpoint.AbstractBindingConverter; import com.ibm.etools.mft.conversion.esb.extensionpoint.Nodes; import com.ibm.msl.mapping.api.MapGenerator; import com.ibm.wsspi.sca.scdl.mq.MQConnection; import com.ibm.wsspi.sca.scdl.mq.MQExportBinding; import com.ibm.wsspi.sca.scdl.mq.MQExportMethodBinding; import com.ibm.wsspi.sca.scdl.mq.MQReceiveQueue; import com.ibm.wsspi.sca.scdl.mq.MQSendQueue; import com.ibm.wsspi.sca.scdl.mq.RequestType1; import com.ibm.wsspi.sca.scdl.mq.ResponseType1; import com.ibm.wsspi.sca.scdl.mqbase.MQConfiguration;
private static final String EXPORT_REQUEST = "_MQInput";
private static final String EXPORT_RESPONSE = "_MQOutput";
private static final String EXPORT_ROUTE = "_Route";
private static final String EXPORT_FUNCTION_SELECTOR = "_FunctionSelector";
private static final String EXPORT_DATA_HANDLER = "_DataHandler";
private static final String EXPORT_FS_MAPPING = "_FSMapping";
private static final String FS_SINGLE_OPERATION = "com.ibm.wbiserver.functionselector.ConstantFunctionSelector";
private static final String FS_HANDLE_MESSAGE = "com.ibm.websphere.sca.mq.selector.impl.Constant";
private static final String FS_MQ_BODY_FORMAT = "com.ibm.websphere.sca.mq.selector.impl.Format";
private static final String FS_MQ_MESSAGE_TYPE = "com.ibm.websphere.sca.mq.selector.impl.Type";
private static final String FS_TARGET_FUNCTION = "com.ibm.websphere.sca.mq.selector.impl.TargetFunctionNameProperty";
private static final String DH_XML = "{http://www.ibm.com/xmlns/prod/websphere/j2ca/configuration/6.1.0}UTF8XMLDataHandler";
@Override
public String getConvertedTo() {
return "MQImport node";
}
Mit diesem Wert wird die Spalte Konvertieren in
der Tabelle mit den Bindungs-Convertern für Exporte und Importe im Bereich "Globale Konvertierungsoptionen konfigurieren" des WebSphere ESB-Konvertierungstools aufgefüllt.
@Override
public String getType() {
return "com.ibm.wsspi.sca.scdl.mq.impl.MQExportBindingImpl";
}
@Override
public Nodes convert(ConverterContext converterContext) throws Exception {
// Erstellen Sie den Container für die Nachrichtenflussknoten, die zur Neuerstellung der MQ-Exportbindung in IBM Integration Bus erstellt werden.
Nodes nodes = createNodes(converterContext);
// Rufen Sie den Standardnamen für die MQ-Exportbindung ab.
// Dieser Name wird später für die Erstellung eindeutiger Namen für die von Ihnen erstellten Nachrichtenflussknoten verwendet.
String nodeName = getProposedIIBNodeNameFromSourcePrimitive(converterContext);
// Rufen Sie die WebSphere ESB-Objekte für die MQ-Exportbindung ab.
// Hinweis: Für diese Klassen muss das MQ-Plug-in als Abhängigkeit hinzugefügt werden.
// Wählen Sie in der Java-Perspektive das Java-Projekt aus, das den Converter enthält.
// Klicken Sie mit der rechten Maustaste auf 'Eigenschaften' und wählen Sie 'Java Build Path > Libraries > Add External JARS...' (Java-Erstellungspfad - Bibliotheken - Externe JARs hinzufügen) aus.
// Fügen Sie die Datei 'Programme\IBM\SDPShared\plugins\com.ibm.ws.sca.scdl.mq.jar' hinzu.
// Fügen Sie die Datei 'Programme\IBM\SDPShared\plugins\com.ibm.ws.sca.scdl.eis.jar' hinzu.
MQExportBinding mqExportBinding = (MQExportBinding)converterContext.sourceBinding;
RequestType1 mqExportRequest = mqExportBinding.getRequest();
ResponseType1 mqExportResponse = mqExportBinding.getResponse();
// Erstellen Sie einen MQInput-Knoten.
MQInputNode mqInputNode = (MQInputNode)createNode(converterContext.targetFlow,nodeName+EXPORT_REQUEST,ROLE_ENTRY,MQInputNode.class,nodes);
// Die Nachrichtendomäne wird auf 'BLOB' gesetzt, damit die Funktionsselektorzuordnung die lokale Umgebung // aktualisieren kann, ohne dass der Nachrichtentyp bekannt sein muss.
// Der Nachrichtentyp wird anschließend bei der Datenhandlerkonvertierung entsprechend gesetzt.
mqInputNode.setMessageDomainProperty("BLOB");
// Erstellen Sie eine unerledigte Task für den Benutzer, damit eine Fehlerbehebung für die Fehlerterminals der MQInput- und MQOutput-Knoten erfolgt, da sie bei der Konvertierung nicht verbunden werden.
createToDoTask(converterContext.flowFile,"The fail terminals for MQInput and MQOuput nodes resulting from the " +
" conversion of MQ Export binding "+nodeName+" have been left unwired. Determine the necessary " +
" error handling and wire the fail terminals appropriately.");
// Konfigurieren Sie den MQInput-Knoten für den Abruf aus der als Anforderungswarteschlange festgelegten MQ-Warteschlange.
MQReceiveQueue mqReceiveQueue = mqExportRequest.getDestination();
if( mqReceiveQueue != null ) {
String receiveQueue = mqReceiveQueue.getQueue();
if( receiveQueue != null )
mqInputNode.setQueueName(receiveQueue);
else
throw new IllegalArgumentException("For export "+nodeName+": MQ export has no MQ receive queue");
}
// Rufen Sie den Namen des WS-Managers ab, aus dem der Export empfangen soll.
// Handelt es sich nicht um den WS-Manager des Brokers, sind zusätzliche // Migrationsschritte erforderlich.
// Das MQConnection-Objekt enthält weitere Details zur MQ-Verbindung, beispielsweise ob
// XA verwendet wird und ob es sich um eine Verbindung im Client- oder Bindungsmodus handelt.
MQConnection mqConnection = mqExportBinding.getConnection();
if( mqConnection != null ) {
MQConfiguration mqConfiguration = mqConnection.getMqConfiguration();
if( mqConfiguration != null ) {
String receiveQMgr = mqConfiguration.getQueueManager();
if( receiveQMgr != null )
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" specifies a receive queue manager: "+receiveQMgr+". Check this value is correct");
}
}
// Erstellen Sie einen MQOutput-Knoten.
// Hinweis: Dieser Knoten wird benötigt, wenn der MQ-Bindungsexport eine Schnittstelle mit Anfrage/Antwort-Operationen hat.
// Bei einem asynchronen Aufrufstil kann sich der MQOutput-Knoten in demselben Nachrichtenfluss wie der MQInput-Knoten befinden (oder auch nicht).
// Der Beispielcode erstellt den MQOutput-Knoten in demselben Nachrichtenfluss wie den MQInput-Knoten.
MQOutputNode mqOutputNode = (MQOutputNode)createNode(converterContext.targetFlow,nodeName+EXPORT_RESPONSE,ROLE_EXIT,MQOutputNode.class,nodes);
mqOutputNode.setRequest(false);
// Erstellen Sie den MQOutput-Knoten, mit dem in die als Antwortwarteschlange definierte MQ-Warteschlange geschrieben wird.
MQSendQueue mqSendQueue = mqExportResponse.getDestination();
if( mqSendQueue != null ) {
String sendQueue = mqSendQueue.getQueue();
if( sendQueue != null )
mqOutputNode.setQueueName(sendQueue);
else
throw new IllegalArgumentException("For export "+nodeName+": MQ export has no MQ send queue");
// Rufen Sie den Namen des WS-Managers ab, an den der Export senden soll.
// Handelt es sich nicht um den WS-Manager des Brokers, sind zusätzliche
// Migrationsschritte erforderlich.
String sendQMgr = mqSendQueue.getQmgr();
if( sendQMgr != null )
mqOutputNode.setQueueManagerName(sendQMgr);
}
// Bei diesem Converter-Beispielcode werden die Korrelationsmodi nicht berücksichtigt; ebensowenig wird
// es berücksichtigt, wenn die Antwortwarteschlange vom Client im MQ-Header 'ReplyTo' angegeben ist.
// Über die Konfiguration der MQ-Bindung wird festgelegt, wie die Antwortnachrichten gebildet werden
// (beispielsweise wie die Korrelations- und die Nachrichten-ID in Antwortnachrichten festgelegt werden):
// if( mqExportResponse.getCorrelId().equals(ExportCorrelId.FROM_MSG_ID_LITERAL) )
// Rufen Sie die Methodenbindungen ab; fügen Sie sie einer Zuordnung hinzu, wobei die Schlüssel die nativen Methodennamen und die Werte die entsprechenden Methodenbindungen sind.
// Prüfen Sie, ob der Eingabe- oder Ausgabendatenhandler von einer Methodenbindung überschrieben wird.
// Prüfen Sie außerdem, ob es sich bei der Zuordnung von nativem Methodennamen zu Operationsnamen um einen Identitätszuordnung handelt.
List methodBindingList = mqExportBinding.getMethodBinding();
Map<String,MQExportMethodBinding> methodBindings = new HashMap<String,MQExportMethodBinding>();
boolean identityMap = true;
for( Iterator i = methodBindingList.iterator(); i.hasNext(); )
{
MQExportMethodBinding mb = (MQExportMethodBinding)i.next();
String nativeMethod = mb.getNativeMethod();
if( nativeMethod != null ) {
methodBindings.put(nativeMethod,mb);
if( !nativeMethod.equals(mb.getMethod()) )
identityMap = false;
}
if( mb.getInputDataBindingType() != null )
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" operation "+mb.getMethod()+" overrides input data handler with "+mb.getInputDataBindingType());
if( mb.getOutputDataBindingType() != null )
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" operation "+mb.getMethod()+" overrides output data handler with "+mb.getInputDataBindingType());
}
// Konvertieren Sie den Funktionsselektor.
//
// Die Funktionsauswahl erfolgt in zwei Schritten:
// 1) Der Funktionsselektor löst den 'nativen Methodennamen' auf.
// 2) Die Methodenbindung ordnet den 'nativen Methodennamen' einem Operationsnamen zu.
// Ist keine entsprechende Methodenbindung vorhanden, wird der Operationsname als nativer Methodenname interpretiert.
//
// Fünf integrierte Funktionsselektoren sind vorhanden:
// Single Operation: Der native Methodenname ist der Name der einzelnen Operation in der Schnittstelle.
// Handle Message: Der native Methodenname ist 'handleMessage'.
// Target Function: Der native Methodenname ist der Wert des MQ-Nachrichtenheaders 'TargetFunctionName'.
// Body Format: Der native Methodenname ist der Wert der Zeichenfolge mit dem MQ-Nachrichteninhaltsformat.
// Message Type: Der native Methodenname ist der Wert des MQ-Nachrichtentypheaders.
// Rufen Sie zur Vorbereitung der Konvertierung des Funktionsselektors die Liste// mit den Operationen in der Schnittstelle des Exports ab.
// Sie müssen der Datei 'javax.wsdl.jar' eine Projektabhängigkeit hinzufügen. Führen Sie die folgenden Schritte aus:
// Wählen Sie in der Java-Perspektive das Converter-Java-Projekt aus.
// Klicken Sie mit der rechten Maustaste auf 'Eigenschaften' und wählen Sie Java Build Path > Libraries > Add
// External JARS... (Java-Erstellungspfad - Bibliotheken - Externe JARs hinzufügen) aus.
// Fügen Sie javax.wsdl.jar hinzu.
String portTypeName = converterContext.portType.getPortType().toString();
PortType portType = conversionContext.indexer.wsdlPortTypes.get(portTypeName);
if( portType == null )
throw new IllegalArgumentException("For export "+nodeName+": Could not locate WSDL Port Type for "+portTypeName);
List operations = portType.getOperations();
// In diesem Beispielcode wird jeder unterstützte Funktionsselektor durch einen Zuordnungsknoten dargestellt, der mit einem // RouteToLabel-Knoten verbunden ist.
// Erstellen Sie den Zuordnungsknoten.
MappingMSLNode fsMappingNode = (MappingMSLNode)createNode(converterContext.targetFlow,nodeName+EXPORT_FUNCTION_SELECTOR,"FS",MappingMSLNode.class,nodes);
// Verbinden Sie den MQInput-Knoten mit dem Zuordnungsknoten des Funktionsselektors.
converterContext.targetFlow.connect(mqInputNode.OUTPUT_TERMINAL_OUT,fsMappingNode.INPUT_TERMINAL_IN);
// In der Zuordnungsdatei sind die Eingabe- und Ausgabenachrichtenelemente definiert sowie die Aktionen,
// mit denen die Eingabenachricht so aktualisiert wird, dass der RouteToLabel-Knoten die einzelnen Nachrichten
// an die richtigen Kennsätze und von dort an die operationsspezifischen untergeordneten Anfrageflüsse weiterleiten kann.
String mapFileName = nodeName+EXPORT_FS_MAPPING;
String mappingContent = null;
// Diese Zeichenfolge definiert den allgemeinen Beginn der Zuordnungsdatei für alle unterstützten Funktionsselektoren.
String mappingPrefix =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?><mappingRoot domainID=\"com.ibm.msl.mapping.xml\" domainIDExtension=\"mb\" mainMap=\"true\" targetNamespace=\"default\" version=\"8.0.4.0\" xmlns=\"http://www.ibm.com/2008/ccl/Mapping\" xmlns:map=\"default\">" +
"<input path=\"jar:file://!com/ibm/etools/mft/map/xsds/predefined/BlobMessage.xsd\"/>" +
"<output path=\"jar:file://!com/ibm/etools/mft/map/xsds/predefined/BlobMessage.xsd\"/>" +
"<generation engine=\"xquery\"/>" +
// Geben Sie den Namen der .map-Datei an.
"<mappingDeclaration name=\""+mapFileName+"\">" +
// Geben Sie den Umfang der Eingabe für den Zuordnungsknoten an: BLOB mit Nachrichtennutzdaten, Nachrichtenassemblierung, Nachrichteneigenschaften, MQMD und MQRFH2.
// MQMD und MQRFH2 sind möglicherweise für einige Funktionsselektoren die Quelle für den nativen Funktionsnamen.
// 'LocalEnvironment' wird nach dem MQInput-Knoten als leer angesehen und ist daher keine Eingabe für diese Zuordnung.
"<input path=\"mb:msg(BLOB,assembly,BLOB,Properties,MQMD,MQRFH2)\"/>" +
// Geben Sie den Umfang der Ausgabe für die Zuordnung an: BLOB mit Nachrichtennutzdaten, Nachrichteneigenschaften, LocalEnvironment
// 'LocalEnvironment' ist das Ziel für den Namen des Weiterleitungskennsatzes.
"<output path=\"mb:msg(BLOB,assembly,BLOB,LocalEnvironment,Properties)\">" +
// Verschieben Sie die Nachrichtendaten und die Eigenschaften ohne Änderungen.
"<move><input path=\"BLOB\"/><output path=\"BLOB\"/></move>" +
"<move><input path=\"Properties\"/><output path=\"Properties\"/></move>";
// Diese Zeichenfolge definiert das allgemeine Ende der Zuordnungsdatei für alle unterstützten Funktionsselektoren.
String mappingSuffix = "</mappingDeclaration></mappingRoot>";
// Jeder Funktionsselektor gibt den Teil der Zuordnung an, mit dem der Name des// Weiterleitungszielkennsatzes anhand der Eingabenachricht gesetzt wird.
String fsName = mqExportRequest.getFunctionSelector();
if( fsName.equals(FS_SINGLE_OPERATION) ) {
// Legen Sie den Namen der einzelnen Operation als Name des Zielkennsatzes fest.
// Ebenso können Sie den Kennsatz übergehen und den MQInput-Knoten direkt mit dem
// untergeordneten Operationsfluss verbinden.
// Handelt es sich bei dem Funktionsselektor um 'Single Operation' und sind für die Schnittstelle // mehrere Operationen vorhanden, wird ein Fehler ausgegeben.
if( operations.size() > 1 )
throw new IllegalArgumentException("For export "+nodeName+": Single Operation function selector cannot handle portType with > 1 operation ("+operations.size()+")");
// Rufen Sie den Namen der einzelnen Operation ab.
String operationName = ((Operation)operations.get(0)).getName();
// Legen Sie den Namen des Zielkennsatzes in der lokalen Umgebung fest.
mappingContent =
"<assign value=\""+operationName+"\">" +
"<output path=\"LocalEnvironment/Destination/RouterList/DestinationData/labelName\"/>" +
"</assign>";
// Der Funktionsselektor 'handleMessage' ist ähnlich, nur kann die Schnittstelle bei ihm // mehrere Operationen haben; aufgerufen wird die Operation, die eine Methodenbindung mit // dem nativen Methodennamen 'handleMessage' hat.
} else if( fsName.equals(FS_HANDLE_MESSAGE) ) {
// Rufen Sie den Namen der Operation für den nativen Methodennamen 'handleMessage' ab.
MQExportMethodBinding mb = methodBindings.get("handleMessage");
if( mb == null ) throw new IllegalArgumentException("For export "+nodeName+": no method binding for handleMessage");
// Erstellen Sie den Inhalt der Zuordnungsdatei.
// Legen Sie den Namen des Zielkennsatzes in der lokalen Umgebung fest.
mappingContent =
"<assign value=\""+mb.getMethod()+"\">" +
"<output path=\"LocalEnvironment/Destination/RouterList/DestinationData/labelName\"/>" +
"</assign>";
// Andere Funktionsselektoren müssen manuell konvertiert werden.
} else {
// Ist der Funktionsselektor eine Identitätszuordnung (d. h., jeder native Methodenname ist mit dem
// entsprechenden Operationsname identisch), kann der Wert direkt aus dem MQ-Nachrichtenheader // in den Namen des Zielkennsatzes verschoben werden.
//
// Beispiel: Für den Funktionsselektor 'Target Function' wird mit der folgenden Angabe// der native Methodenname aus dem MQRFH2-Ordner 'usr' in den nativen 'labelName' verschoben.
//
// <move>
// <input path="MQRFH2/usr/TargetFunctionName"/>
// <output path="LocalEnvironment/Destination/RouterList/DestinationData/labelName"/>
// </move>
//
// Dazu muss das untergeordnete Element "any" des Ordners 'MQRFH2/usr' in den folgenden Schementyp
// umgesetzt werden: //
// <?xml version="1.0" encoding="UTF-8"?>
// <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
// <xsd:element name="TargetFunctionName" type="xsd:string"/>
// </xsd:schema>
//
// Ebenso kann die Zuordnung wie folgt mithilfe von if-Elementen erstellt werden:
// IF MQRFH2/usr/TargetFunctionName == nativemethod1 THEN labelName = operation1
// IF MQRFH2/usr/TargetFunctionName == nativemethod2 THEN labelName = operation2
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" function selector of type "+fsName+" needs to be manually converted");
}
// Wenn der Funktionsselektor in eine Zuordnung aufgelöst werden konnte, erstellen // Sie eine Zuordnungsdatei und setzen Sie sie auf dem Zuordnungsknoten.
if( mappingContent != null ) {
mappingContent = mappingPrefix + mappingContent + mappingSuffix;
// Erstellen Sie die Zuordnungsdatei als Ressource in einem konvertierten Projekt.
// Fügen Sie für die folgenden JAR-Dateien Projektabhängigkeiten hinzu.
// Wählen Sie in der Java-Perspektive das Converter-Java-Projekt aus.
// Klicken Sie mit der rechten Maustaste auf 'Eigenschaften' und
// Wählen Sie 'Java Build Path > Libraries > Add External JARS...' (Java-Erstellungspfad -
// Bibliotheken - Externe JARs hinzufügen) aus. Fügen Sie 'org.eclipse.core.jobs.jar' hinzu.
// Fügen Sie 'org.eclipse.equinox.common.jar' hinzu.
IProject targetProject = converterContext.moduleConverter.getTargetProject();
IFile mappingFile = targetProject.getFile(mapFileName+".map");
if( mappingFile.exists() )
throw new IllegalArgumentException("For export "+nodeName+": Mapping file "+mapFileName+" .map already exists");
mappingFile.create(new ByteArrayInputStream(mappingContent.getBytes("UTF-8")),true,null);
// Setzen Sie die Zuordnungsdatei auf dem Zuordnungsknoten.
MessageMSLMap fsMessageMap = new MessageMSLMap(mapFileName);
fsMappingNode.setMappingExpression(fsMessageMap);
}
// Erstellen Sie einen RouteToLabel-Knoten (er leitet die Nachricht an den Anforderungsablauf für die Operation weiter).
RouteToLabelNode routeToLabelNode = (RouteToLabelNode)createNode(converterContext.targetFlow,nodeName+EXPORT_ROUTE,ROLE_MAIN,RouteToLabelNode.class,nodes);
// Konvertieren Sie den Datenhandler für den Nachrichtentext.
// Dies ist die Standardeinstellung für alle Operationen, die in den Methodenbindungen überschrieben werden kann.
// Hinweis: Dieser Converter hat nichts mit den Datenhandlern für MQ-Header zu tun.
Object dbRef = mqExportRequest.getBodyDataBindingReferenceName();
String dataBindingName = dbRef == null ? "" : dbRef.toString();
// Bearbeiten Sie den integrierten XML-Datenhandler.
if( dataBindingName.equals(DH_XML) ) {
// Für den XML-Datenhandler wird die Nachrichtendomäne mit einem ResetContentDescriptor-Knoten auf XMLNSC gesetzt.
ResetContentDescriptorNode dataHandlerNode = (ResetContentDescriptorNode)createNode(converterContext.targetFlow,nodeName+EXPORT_DATA_HANDLER,"DH",ResetContentDescriptorNode.class,nodes);
dataHandlerNode.setMessageDomain("XMLNSC");
dataHandlerNode.setResetMessageDomain(true);
// Setzen Sie den Datenhandlerknoten zwischen den Zuordnungsknoten des Funktionsselektors und den RouteToLabel-Knoten.
converterContext.targetFlow.connect(fsMappingNode.OUTPUT_TERMINAL_OUT,dataHandlerNode.INPUT_TERMINAL_IN);
converterContext.targetFlow.connect(dataHandlerNode.OUTPUT_TERMINAL_OUT,routeToLabelNode.INPUT_TERMINAL_IN);
} else {
// Bei anderen Datenhandlern wird Datenhandler durch einen Passthrough-Knoten dargestellt, // der manuell konvertiert werden muss.
PassthroughNode dataHandlerNode = (PassthroughNode)createNode(converterContext.targetFlow,nodeName+EXPORT_DATA_HANDLER,"DH",PassthroughNode.class,nodes);
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" data handler of type "+dataBindingName+" needs to be manually converted");
// Setzen Sie den Datenhandlerknoten zwischen den Zuordnungsknoten des Funktionsselektors und den RouteToLabel-Knoten.
converterContext.targetFlow.connect(fsMappingNode.OUTPUT_TERMINAL_OUT,dataHandlerNode.INPUT_TERMINAL_IN);
converterContext.targetFlow.connect(dataHandlerNode.OUTPUT_TERMINAL_OUT,routeToLabelNode.INPUT_TERMINAL_IN);
}
// Möglicherweise verwendet die Antwortnachricht einen anderen Datenhandler, der von
// diesem Converter nicht unterstützt wird.
Object responsedbRef = mqExportResponse.getBodyDataBindingReferenceName();
String responseDataBindingName = responsedbRef == null ? "" : responsedbRef.toString();
if( !responseDataBindingName.equals(dataBindingName) )
createToDoTask(converterContext.flowFile,"MQ Export binding "+nodeName+
" response data handler is different to request and needs to be manually converted.");
// Die Konvertierung ist abgeschlossen.
return nodes;
}
public Terminal getInputTerminal(String sourceTerminalName, Nodes nodes) {
// Rufen Sie den Knoten ab und ordnen Sie ihn dem zugehörigen Eingabeterminal zu.
return ((MQOutputNode)nodes.getNode(ROLE_EXIT)).INPUT_TERMINAL_IN;
}
public Terminal getOutputTerminal(String sourceTerminalName, Nodes nodes) {
// Rufen Sie den Knoten ab und ordnen Sie ihn dem Ausgabeterminal zu.
return ((MQInputNode)nodes.getNode(ROLE_ENTRY)).OUTPUT_TERMINAL_OUT;
}
}
Weitere Informationen finden Sie unter WebSphere ESB-Konvertierungstool ausführen.