WebSphere Message Broker Version 8.0.0.5 Betriebssysteme: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Sehen Sie sich die Informationen zur aktuellen Produktversion im IBM Integration Bus Version 9.0 an.

Nachrichtenverarbeitungs- oder Sendeknoten in Java erstellen

Ein Nachrichtenverarbeitungsknoten wird zur Verarbeitung einer Nachricht und ein Sendeknoten zur Ausgabe einer Nachricht als Bitstrom verwendet.

Vor dem Start

WebSphere Message Broker stellt die Quelle für die zwei benutzerdefinierten Musterknoten 'SwitchNode' und 'TransformNode' bereit. Sie können diese Knoten in ihrem aktuellen Zustand verwenden oder sie ändern.

Im Hinblick auf die Codierung eines Nachrichtenverarbeitungsknotens und eines Sendeknotens lässt sich feststellen, dass die beiden Typen im Wesentlichen dieselben Services bereitstellen. Sie können an einem Sendeknoten Nachrichten verarbeiten, und ebenso können Sie mit einem Nachrichtenverarbeitungsknoten eine Ausgabenachricht als Bitstrom weitergeben. Zur Vereinfachung wird in diesem Abschnitt von einem Nachrichtenverarbeitungsknoten gesprochen, auch wenn die Funktionen beider Knotentypen erläutert werden.

Ein benutzerdefinierter Java-Knoten wird als Datei mit der Erweiterung .jar verteilt.

Neues Java-Projekt erstellen

Vor der Erstellung von Java-Knoten im WebSphere Message Broker Toolkit müssen Sie ein neues Java-Projekt erstellen:
  1. Klicken Sie Datei > Neu > Projekt. Wählen Sie Java aus und klicken Sie auf Weiter.
  2. Geben Sie im Feld Projektname einen Namen für das Projekt an und klicken Sie auf Weiter.
  3. Wählen Sie im Teilfenster Java Settings (Java-Einstellungen) die Registerkarte Bibliotheken aus und klicken Sie auf Add External JARs (Externe JAR-Dateien hinzufügen).
  4. Wählen Sie Installationsverzeichnis\classes\jplugin2.jar aus.
  5. Befolgen Sie die Eingabeaufforderungen auf den anderen Registerkarten, um andere Einstellungen für die Erstellung zu definieren.
  6. Klicken Sie auf Finish (Fertigstellen).
Sie können jetzt die Quelle für Ihren Java-Knoten in diesem Projekt entwickeln.

Klasse des Nachrichtenverarbeitungsknotens deklarieren

Jede Klasse, durch die MbNodeInterface implementiert wird und im LIL-Pfad des Brokers enthalten ist, wird im Broker als Nachrichtenverarbeitungsknoten registriert. Bei der Implementierung von MbNodeInterface, muss auch eine evaluate-Methode für diese Klasse implementiert werden. Die evaluate-Methode wird vom Broker für jede Nachricht aufgerufen, die durch den Fluss übermittelt wird.

Der Klassenname muss mit dem Wort 'Node' enden. Wenn Sie z. B. den Namen als 'Basic' im WebSphere Message Broker Toolkit zugeordnet haben, muss der Klassenname 'BasicNode' lauten.

Wenn Sie beispielsweise die Klasse des Nachrichtenverarbeitungsknotens deklarieren möchten, gehen Sie folgendermaßen vor:
package com.ibm.jplugins;

import com.ibm.broker.plugin.*;

public class BasicNode extends MbNode implements MbNodeInterface
Deklarieren Sie die Klasse im WebSphere Message Broker Toolkit:
  1. Klicken Sie auf Datei > Neu > Sonstige, wählen Sie Klasse aus und klicken Sie auf Weiter.
  2. Legen Sie für die Namensfelder des Pakets und der Klasse die entsprechenden Werte fest.
  3. Löschen Sie den Text im Textfeld 'Superclass' (Superklasse), und klicken Sie auf Durchsuchen.
  4. Wählen Sie die Klasse MbNode aus, und klicken Sie auf OK.
  5. Klicken Sie neben dem Textfeld 'Interface' (Schnittstelle) auf die Schaltfläche Hinzufügen, und wählen Sie MbNodeInterface aus.
  6. Klicken Sie auf Finish (Fertigstellen).

Knotenkonstruktor definieren

Wenn eine Instanz des Knotens erstellt wird, wird der Konstruktor der Knotenklasse des Benutzers aufgerufen. Erstellen Sie die Terminals des Knotens, und initialisieren Sie in diesem Konstruktor Standardwerte für Attribute.

Einem Nachrichtenverarbeitungsknoten sind eine Reihe von Eingabeterminals und Ausgabeterminals zugeordnet. Die Methoden createInputTerminal und createOutputTerminal werden verwendet, um einem Knoten Terminals hinzuzufügen, wenn eine Instanz des Knotens erstellt wird.

Im Folgenden finden Sie ein Beispiel für die Erstellung eines Knotens mit einem Eingabeterminal und zwei Ausgabeterminals:

public MyNode() throws MbException
{
				// create terminals here
				createInputTerminal ("in");
			createOutputTerminal ("out");
				createOutputTerminal ("failure");
}

Auf Nachrichtendaten zugreifen

In vielen Fällen muss der benutzerdefinierte Knoten auf den Inhalt der Nachricht zugreifen, die an seinem Eingabeterminal empfangen wurde. Die Nachricht wird als Baumstruktur aus Syntaxelementen dargestellt. Nutzen Sie die mitgelieferte Dienstprogrammfunktion, um Methoden für das Nachrichtenmanagement, den Nachrichtenpufferzugriff, die Syntaxelementnavigation und den Syntaxelementzugriff auszuwerten (evaluate).

Durch die Klasse MbElement wird die Schnittstelle für die Syntaxelemente bereitgestellt.

Beispiel:

  1. So navigieren Sie zum relevanten Syntaxelement in der XML-Nachricht:
        MbElement rootElement = assembly.getMessage().getRootElement();
        MbElement switchElement = 
    						rootElement.getLastChild().getFirstChild().getFirstChild();
  2. So wählen Sie das Terminal aus, das durch den Wert dieses Elements angegeben wird:
        String terminalName;
        String elementValue = (String)switchElement.getValue();
        if(elementValue.equals("add"))
          terminalName = "add";
        else if(elementValue.equals("change"))
          terminalName = "change";
        else if(elementValue.equals("delete"))
          terminalName = "delete";
        else if(elementValue.equals("hold"))
          terminalName = "hold";
        ELSE
          terminalName = "failure";
        
        MbOutputTerminal out = getOutputTerminal(terminalName);

Nachrichtenobjekt umwandeln

Die empfangene Eingabenachricht ist schreibgeschützt. Vor dem Umwandeln einer Nachricht müssen Sie diese deshalb in eine neue Ausgabenachricht schreiben. Es können Elemente aus der Eingabenachricht kopiert werden, oder es können neue Elemente in der Ausgabenachricht erstellt werden.

Durch die Klasse MbMessage werden die Copy-Konstruktoren und die Methoden zum Abrufen des Stammelements der Nachricht bereitgestellt. Durch die Klasse MbElement wird die Schnittstelle für die Syntaxelemente bereitgestellt.

Beispiel: Bei einer ankommenden Nachrichtenassembly mit eingebetteten Nachrichten, kann in der evaluate-Methode Ihres benutzerdefinierten Knotens folgender Code vorhanden sein:
  1. So erstellen Sie eine neue Kopie der Nachrichtenassembly und der zugehörigen eingebetteten Nachrichten:
        MbMessage newMsg = new MbMessage(assembly.getMessage());
        MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);
  2. So navigieren Sie zum relevanten Syntaxelement in der XML-Nachricht:
        MbElement rootElement = newAssembly.getMessage().getRootElement();
        MbElement switchElement = 
    						rootElement.getFirstElementByPath("/XML/data/action");
  3. So ändern Sie den Wert eines vorhandenen Elements:
      String elementValue = (String)switchElement.getValue();
        if(elementValue.equals("add"))
          switchElement.setValue("change");
        else if(elementValue.equals("change"))
          switchElement.setValue("delete");
        else if(elementValue.equals("delete"))
          switchElement.setValue("hold");
        ELSE
          switchElement.setValue("failure");
  4. So fügen Sie eine neue Kennung als untergeordnetes Element der Switch-Kennung hinzu:
        MbElement tag = switchElement.createElementAsLastChild(MbElement.TYPE_NAME,
                                                               "PreviousValue",
                                                               elementValue);
  5. So fügen Sie dieser neuen Kennung ein Attribut hinzu:
        tag.createElementAsFirstChild(MbElement.TYPE_NAME_VALUE,
                                      "NewValue",
                                      switchElement.getValue());
    
        MbOutputTerminal out = getOutputTerminal("out");
Als Teil der Umsetzung kann es erforderlich sein, einen neuen Nachrichtenhauptteil zu erstellen. Zum Erstellen eines neuen Nachrichtenhauptteils müssen Sie eine der folgenden Methoden verwenden, mit denen ein Parser einem Nachrichtenbaumstrukturordner explizit zugeordnet wird:
createElementAfter(String) 
createElementAsFirstChild(String) 
createElementAsLastChild(String) 
createElementBefore(String) 
createElementAsLastChildFromBitstream(byte[], String, String, String, String, int, int, int) 
Folgende Methoden dürfen nicht verwendet werden, weil sie dem Ordner keinen Parser als Eigner zuordnen:
createElementAfter(int)
createElementAfter(int, String, Object) 
createElementAsFirstChild(int) 
createElementAsFirstChild(int, String, Object) 
createElementAsLastChild(int) 
createElementAsLastChild(int, String, Object) 
createElementBefore(int) 
createElementBefore(int, String, Object) 

Nachricht weitergeben

Bevor Sie eine Nachricht weitergeben, müssen Sie entscheiden, welche Nachrichtenflussdaten Sie weitergeben möchten, und ob diese an ein Knotenterminal oder an einen Label-Knoten weitergegeben werden sollen.

Beispiel:
  1. Gehen Sie folgendermaßen vor, um die Nachricht an das Ausgabeterminal 'out' weiterzugeben:
    MbOutputTerminal out = getOutputTerminal("out");
            out.propagate(newAssembly);
  2. So geben Sie die Nachricht an einen Kennsatzknoten weiter:
    MbRoute label1 = getRoute ("label1");
    Label1.propagate(newAssembly);

Rufen Sie die Funktion clearMessage() im letzten Try/Catch-Block auf, um den Speicher zu löschen, der für die Nachrichtenbaumstruktur zugeordnet ist.

Wenn Sie das gleiche MbMessage-Objekt mehrmals weitergeben möchten, rufen Sie die Methode finalizeMessage() des MBMessage-Objekts auf, damit alle an der Nachricht vorgenommenen Änderungen im nach dem Java-Knoten generierten Bitstrom wiedergegeben werden. Beispiel:
MbMessage newMsg = new MbMessage(assembly.getMessage());
MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);
...
newMsg.finalizeMessage(MbMessage.FINALIZE_NONE);
out.propagate(newAssembly;
...
newMsg.finalizeMessage(MbMessage.FINALIZE_NONE);
out.propagate(newAssembly);

Knotennamen deklarieren

Der Name des Knotens muss mit dem Knoten identisch sein, der im WebSphere Message Broker Toolkit verwendet wird. Alle Knotennamen müssen die Endung "Node" haben. Deklarieren Sie den Namen mit der folgenden Methode:

public static String getNodeName()
{
   return "BasicNode";
}
Wenn diese Methode nicht deklariert wird, erstellt das Java-API-Framework einen Standardknotennamen gemäß den folgenden Regeln:
  • Der Klassenname wird an den Paketnamen angehängt.
  • Die Punkte werden entfernt, und der erste Buchstabe von jedem Teil des Paket- und Klassenamens wird in Großbuchstaben gesetzt.
Beispiel: Standardmäßig wird folgender Klasse der Knotenname "ComIbmPluginsamplesBasicNode" zugewiesen:
package com.ibm.pluginsamples;
public class BasicNode extends MbNode implements MbNodeInterface
{
   ...

Attribute deklarieren

Knotenattribute werden auf die gleiche Weise deklariert wie Eigenschaften von Java-Beans. Sie müssen getter- und setter-Methoden für die Attribute schreiben. Das API-Framework schließt aus den Regeln für die Java-Bean-Introspektion auf die Attributnamen. Sie können beispielsweise die folgenden zwei Methoden deklarieren:

private String attributeVariable;

public String getFirstAttribute()
{
  return attributeVariable;
}

public void setFirstAttribute(String value)
{
  attributeVariable = value;
}

Der Broker schließt daraus, dass in diesem Knoten ein Attribut mit der Bezeichnung 'firstAttribute' enthalten ist. Dieser Name wird von den Namen der Methoden zum Abrufen und Festlegen abgeleitet, und nicht von den Variablennamen von Mitgliedern interner Klassen. Attribute können nur als Zeichenfolgen festgelegt werden. Deshalb müssen numerische Werte in den Methoden zum Abrufen und Festlegen in Zeichenfolgen umgewandelt werden. In der folgenden Methode wird beispielsweise ein Attribut mit der Bezeichnung 'timeInSeconds' definiert:

int seconds;

public String getTimeInSeconds()
{
  return Integer.toString(seconds);
}

public void setTimeInSeconds(String value)
{
  seconds = Integer.parseInt(value);
}

Knotenfunktionen implementieren

Die in MbNodeInterface definierte Methode evaluate wird vom Broker für die Verarbeitung der Nachricht aufgerufen. Die gesamte Verarbeitungsfunktion für den Knoten ist in dieser Methode enthalten.

Die Methode evaluate enthält zwei Parameter, die durch den Broker übermittelt werden:
  1. In MbMessageAssembly sind die folgenden Objekte enthalten, auf die mit den entsprechenden Methoden zugegriffen werden kann:
    • Ankommende Nachricht
    • Lokale Umgebung
    • Globale Umgebung
    • Ausnahmeliste
  2. Eingabeterminal, auf dem die Nachricht angekommen ist.
Im folgenden Codeauszug können Sie beispielsweise sehen, wie die evaluate-Methode geschrieben werden kann:
public void evaluate(MbMessageAssembly assembly, MbInputTerminal inTerm) throws MbException
  {
    // add message processing code here

    getOutputTerminal("out").propagate(assembly);
  }

Die Nachrichtenflussdaten, die aus der Nachricht, der Umgebung, der lokalen Umgebung und der Ausnahmeliste bestehen, werden am Eingangsterminal des Knotens empfangen.

Instanz des Knotens löschen

Eine Knoteninstanz wird durch folgende Aktionen gelöscht:
  • Sie beenden den Broker.
  • Sie entfernen den Knoten oder Nachrichtenfluss, in dem der Knoten enthalten ist, und implementieren die Konfiguration erneut.
Wenn der Knoten Bereinigungsoperationen durchführen soll, beispielsweise das Schließen der Sockets, fügen Sie eine Implementierung der Methode onDelete ein:
public void onDelete()
{
  // bei Bedarf Knotenbereinigung ausführen
}

Diese Methode wird sofort vom Broker aufgerufen, bevor er den Knoten löscht.

Bemerkungen | Marken | Downloads | Bibliothek | Support | Feedback

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Letzte Aktualisierung:
        
        Letzte Aktualisierung: 2015-02-28 16:22:05


TaskthemaTaskthema | Version 8.0.0.5 | as09970_