Creating a message processing or output node in Java

Before you can create Java nodes in the IBM Integration Toolkit, you must create a new Java project:

1. Click File > New > Project. Select Java and click Next.
2. In the Project name field, enter a project a name, then click Next.
3. On the Java Settings pane, select the Libraries tab, and click Add External JARs.
4. Select install_dir\classes\jplugin2.jar.
5. Follow the prompts on the other tabs to define any other build settings.
6. Click Finish.

You can now develop the source for your Java node within this project.

For example, to declare the message processing node class:

package com.ibm.jplugins;

import com.ibm.broker.plugin.*;

public class BasicNode extends MbNode implements MbNodeInterface

Declare the class in the IBM Integration Toolkit:

1. Click File > New > Other, select Class, then click Next.
2. Set the package and class name fields to appropriate values.
3. Delete the text in the Superclass text field and click Browse.
4. Select MbNode and click OK.
5. Click the Add button next to Interfaces text field, and select MbNodeInterface.
6. Click Finish.

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

For example, if you have an incoming message assembly with embedded messages, you could have the following code in the evaluate method of your user-defined node:

1. To create a new copy of the message assembly and its embedded messages:

       MbMessage newMsg = new MbMessage(assembly.getMessage());
       MbMessageAssembly newAssembly = new MbMessageAssembly(assembly, newMsg);

2. To navigate to the relevant syntax element in the XML message:

       MbElement rootElement = newAssembly.getMessage().getRootElement();
       MbElement switchElement = 
   			rootElement.getFirstElementByPath("/XML/data/action");

3. To change the value of an existing element:

     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. To add a new tag as a child of the switch tag:

       MbElement tag = switchElement.createElementAsLastChild(MbElement.TYPE_NAME,
                                                              "PreviousValue",
                                                              elementValue);

5. To add an attribute to this new tag:

       tag.createElementAsFirstChild(MbElement.TYPE_NAME_VALUE,
                                     "NewValue",
                                     switchElement.getValue());
   
       MbOutputTerminal out = getOutputTerminal("out");

As part of the transformation, you might need to create a new message body. To create a new message body, use one of the following methods, which specifically assigns a parser to a message tree folder:

createElementAfter(String) 
createElementAsFirstChild(String) 
createElementAsLastChild(String) 
createElementBefore(String) 
createElementAsLastChildFromBitstream(byte[], String, String, String, String, int, int, int) 

Do not use the following methods, which do not associate an owning parser with the folder:

createElementAfter(int)
createElementAfter(int, String, Object) 
createElementAsFirstChild(int) 
createElementAsFirstChild(int, String, Object) 
createElementAsLastChild(int) 
createElementAsLastChild(int, String, Object) 
createElementBefore(int) 
createElementBefore(int, String, Object) 

For example:

1. To propagate the message to the output terminal "out":

   MbOutputTerminal out = getOutputTerminal("out");
           out.propagate(newAssembly);

2. To propagate the message to a Label node:

   MbRoute label1 = getRoute ("label1");
   Label1.propagate(newAssembly);

To propagate the same MbMessage object multiple times, call the finalizeMessage() method on the MBMessage object, so that any changes made to the message are reflected in the bit stream that is generated downstream of the Java node; for example:

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);

public static String getNodeName()
{
   return "BasicNode";
}

If this method is not declared, the Java API framework creates a default node name using the following rules:

• The class name is appended to the package name.
• The dots are removed, and the first letter of each part of the package and class name are capitalized.

For example, by default, the following class is assigned the node name "ComIbmPluginsamplesBasicNode":

package com.ibm.pluginsamples;
public class BasicNode extends MbNode implements MbNodeInterface
{
   ...

The evaluate method has two parameters that are passed in by the broker:

1. The MbMessageAssembly, which contains the following objects that are accessed using the appropriate methods:
   • The incoming message
   • The LocalEnvironment
   • The global Environment
   • The ExceptionList
2. The input terminal on which the message has arrived.

For example, the following code extract shows how you might write the evaluate method:

public void evaluate(MbMessageAssembly assembly, MbInputTerminal inTerm) throws MbException
  {
    // add message processing code here

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

An instance of the node is deleted when either:

• You shut down the broker.
• You remove the node or the message flow that contains the node, and redeploy the configuration.

If you want the node to perform any cleanup operations, for example closing sockets, include an implementation of the onDelete method:

public void onDelete()
{
  // perform node cleanup if necessary
}