JavaCompute node
Use the JavaCompute node to work with messages by using the Java™ language.
- Developer
- Application Integration Suite
- Standard
- Advanced
- Express
- Scale
- Adapter
Purpose
By using this node, you can complete the following tasks:
- Java plug-in API
- Java Architecture for XML Binding (JAXB)
- Document Object Model (DOM)
The JavaCompute node is contained in the Transformation drawer of the palette, and is represented in the IBM® Integration Toolkit by the following icon:
Using this node in a message flow
The JavaCompute node uses the same execution model as Java user-defined nodes and therefore the restrictions and assumptions associated with Java user-defined nodes also apply to Java code developed for JavaCompute nodes; for more information, see Creating a message processing or output node in Java. Only one instance of the JavaCompute node is created regardless of the number of threads running against the flow (either as a result of additional instances or multiple input nodes). Therefore, all of your user Java code must be thread safe and re-entrant. For more information, see User-defined extensions execution model and Threading considerations for user-defined extensions.
To open the New Java Compute Node Class wizard, double-click the JavaCompute node. The wizard guides you through the creation of a Java class that contains some skeleton code. This skeleton code is displayed in a Java editor. For more information about creating Java code for a JavaCompute node, and for examples of the skeleton code or template that are provided, see Creating Java code for a JavaCompute node. If it is not the first time that you have double-clicked the node, the Java code is displayed.
onInitialize()
and onDelete()
.
If you want the node to perform cleanup operations, for example closing
sockets, include an implementation of the onDelete method: public void onDelete()
{
// perform node cleanup if necessary
}
The onInitialize()
method is called
either during deployment or on integration node startup. During deployment,
the method is called before deployment has been committed. Other nodes
can throw exceptions during their initialization; therefore, the flow
will fail to deploy, even if the onInitialize()
method
for this node works. If your onInitialize()
method
throws an exception, the flow either fails to deploy, or fails to
start. Therefore, complete tasks that will always work or always fail
during the onInitialize()
method. The integration
node does not try to start the flow again until the integration node
is restarted. If you need to initialize an external connection that
might need to be retried, do so on the first message through the flow
so that the flow can retry the transaction as necessary.For instructions about how to complete specific tasks with a JavaCompute node, see Writing Java.
Specifying Java
Code Java statements to customize the behavior of the JavaCompute node. For example, you can customize the node to create a new output message or messages, using input message or database content (unchanged or modified), or new data. For example, you might want to modify a value in the input message by adding a value from a database, and store the result in a field in the output message.
Code the Java statements that you want in a Java file that is associated with the JavaCompute node.
If a Java file does not exist for this node, right-click the JavaCompute node and click Open Java to create and open a new Java file in the Editor view. If the file exists already, click Browse beside the Java Class property to display the JavaCompute Node Type Selection window. When you type at least one character in the Select field, matching Java classes are listed. You can use the asterisk (*) to represent any character as part of a search string; for example, a*b. Select the appropriate Java class and click OK. You can store the Java file in your application, or, if multiple solutions use the same Java file, you can store it in a shared library. For more information, see Java isolation.
Java in applications
Earlier versions of WebSphere® Message Broker and IBM Integration Bus did not support Java isolation in applications. All Java that was deployed to the integration server (or execution group) was loaded into a single class loader, which was then used by all JavaCompute nodes in all applications. This behavior precluded the use of duplicate classes.
From IBM Integration Bus Version 9.0.0.3, you can now use Java isolation at the application level: A Java class loader is built for each application, and it contains only the Java that is deployed in that application and any included libraries.
You can enable and disable Java isolation for individual applications by setting the Java Isolation configuration property on the Manage tab of the BAR file editor. If the runtime cannot find the Java Isolation attribute in the deployment XML for the application, then Java Isolation defaults to false. All BAR files that are built with IBM Integration Bus Version 10 or later have a Java Isolation added to the application broker.xml file. The deploy manager looks for the Java Isolation attribute, and if the attribute is found, the value is sent to the runtime, even if the property is overridden. When the property is not overridden, the value of true is sent to the runtime.
Terminals and properties
When you put an instance of the JavaCompute node into a message flow, you can configure it; see Configuring a message flow node. To associate an instance of a JavaCompute node with a Java class, configure the node's properties. The properties of the node are displayed in the Properties view. All mandatory properties for which you must enter a value (those that do not have a default value defined) are marked with an asterisk.
The JavaCompute node terminals are described in the following table.
Terminal | Description |
---|---|
In | The input terminal that accepts a message for processing by the node. |
Failure | The output terminal to which the input message is routed if a failure is detected during the computation. (Even if the Validate property is set, messages that are propagated to the Failure terminal of the node are not validated.) |
Out | The output terminal to which the transformed message is routed. |
Alternate | An alternative output terminal to which the transformed message can be routed, instead of to the Out terminal. |
The following tables describe the node properties. The column headed M indicates whether the property is mandatory (marked with an asterisk if you must enter a value when no default is defined); the column headed C indicates whether the property is configurable (you can change the value when you add the message flow to the BAR file to deploy it).
The Description properties of the JavaCompute node are described in the following table.
Property | M | C | Default | Description |
---|---|---|---|---|
Node name | No | No | The node type: JavaCompute | The name of the node. |
Short description | No | No | A brief description of the node. | |
Long description | No | No | Text that describes the purpose of the node in the message flow. |
The Basic properties for the JavaCompute node are described in the following table.
Property | M | C | Default | Description |
---|---|---|---|---|
Java class | Yes | No | None | The name of the Java class
that is used in this node. This name must be displayed in the list
of Java classes that are available
in the project references for the integration project. To select a file that already exists, click Browse. When you type at least one character in the Select field, matching Java classes are listed. You can use the asterisk (*) to represent any character as part of a search string; for example, a*b. Select the appropriate Java class and click OK. |
Java classloader service | No | Yes | None | The name of the JavaClassLoader configurable
service that is used in this node. If no name is specified, and a
if JavaClassLoader configurable service with the same name as the
integration server exists, it is used in this node. Otherwise, no
JavaClassLoader configurable service is used. All the nodes in an integration server that specify the same JavaClassLoader configurable service use the same instance of the classloader. Consequently all the nodes use the same in-memory version of the classes, including access to the same static variables. Java classes that are deployed in shared libraries are not available to the JavaClassLoader configurable service. For more information, see JavaCompute node class loading. |
The Parser Options properties for the JavaCompute node are described in the following table.
Property | M | C | Default | Description |
---|---|---|---|---|
Use XMLNSC Compact Parser for XMLNS Domain | No | No | Cleared | Setting this property causes the outgoing MQRFH2 to specify the XMLNS instead of XMLNSC parser, allowing an external application to remain unchanged. If outgoing messages do not contain MQRFH2 headers, this property has no effect. |
The Validation properties of the JavaCompute node are described in the following table.
Set the validation properties to define how the message that is produced by the JavaCompute node is validated. These properties do not cause the input message to be validated. It is expected that, if such validation is required, the validation has already been performed by the input node or a preceding validation node. For more details, see Validating messages and Validation properties.
Property | M | C | Default | Description | mqsiapplybaroverride command property |
---|---|---|---|---|---|
Validate | No | Yes | None | This property controls whether validation takes place, and what part of the message is validated. Valid values are None, Content and Value, Content, and Inherit. | validateMaster |
Failure action | No | No | Exception | This property controls what happens if a validation failure occurs. You can set this property only if Validate is set to Content or Content and Value. Valid values are User Trace, Local Error Log, Exception, and Exception List. |
Property | M | C | Default | Description |
---|---|---|---|---|
Events | No | No | None | Events that you have defined for the node are
displayed on this tab. By default, no monitoring events are defined
on any node in a message flow. Use Add, Edit,
and Delete to create, change or delete monitoring
events for the node; see Configuring monitoring event sources by using monitoring properties for details. You can enable and disable events that are shown here by selecting or clearing the Enabled check box. |