Page History

This tutorial describes how to create a very simple Hello World style of JBI binding component. This tutorial is as minimalistic as possible so as to focus on key concepts and not drown in details. The Hello World binding component will respond to all requests with the message:

{panel}

The following sections will walk through the creation, packaging, testing and deployment of the Hello World binding component. 

h2. Prerequisites

* Maven 2.0.4 or higher

 
** If you have never used Maven previously the Maven [Getting Started Guide|http://maven.apache.org/guides/getting-started/index.html] explains some valuable concepts surrounding Maven

 
* ServiceMix 3.1-incubating-SNAPSHOT or higher

 
** See the [ServiceMix downloads|http://servicemix.org/site/download.html] to grab a nightly build as ServiceMix 3.1 has not yet been released

* A broadband internet connection so Maven can automatically download

 dependencies 

h2. A Very Brief Introduction to Java Business Integration 

The [Java Business Integration (JBI) spec|http://jcp.org/en/jsr/detail?id=208] provides a standards-based, service-oriented approach to application integration through the use of an abstract messaging model, without reference to a particular protocol or wire encoding. JBI introduces the concepts of Binding Components (BCs), Service Engines (SEs) to  Service Units (SUs) and Service Assemblies (SAs) to define an architecture for vendor-neutral pluggable components. The purpose of this architecture is to provide standards-based interoperability amongst components/services.

 

JBI components are can be thought of as the _smallest applications_ or _services_ accessible in a service-oriented architecture. Each service has a very specific purpose and therefore a narrow scope and set of functionality. Components come in two flavors: Service Engines (SE) and Binding Components (BC). SUs must be packaged into a SA to be deployed to the JBI container. An SA is a _complete application_ consisting of one or more services. By comparison, this is similar to the way that WAR files must be packaged inside of an EAR file to be deployed to a J2EE container.

 

See also the page providing information on [working with service

 

To create a SE, execute the following command on the command-line:

{panel}

The command above will create a directory named {{hello-world-bc-su}} that houses a Maven project for the JBI service engine being created here. The name of the directory is taken from the {{artifactId}} parameter.

 

The first three parameters to the {{mvn}} command (-DarchetypeGroupId=org.apache.servicemix.tooling -DarchetypeArtifactId=servicemix-binding-component -DarchetypeVersion=3.1-incubating-SNAPSHOT) identify which Maven archetype to use for the {{archetype:create}} goal, while the last two parameters (-DgroupId=org.apache.servicemix.samples.helloworld.bc -DartifactId=hello-world-bc-su) uniquely identify the Maven project that is being generated. The {{groupId}} is used as the Java package and the {{artifactId}} is used as the project name. Therefore, only alphanumeric characters are valid values for the {{groupId}} and {{artifactId}} parameters.

 POM|http://fisheye3.cenqua.com/browse/servicemix/trunk/pom.xml?r=trunk] in the {{<version>}} element. 
{tip}

The output from executing the {{archetype:create}} goal is shown below:

{noformat}
[INFO] Scanning for projects...
[INFO] Reactor build order: 
[INFO]   A custom project
[INFO]   A custom project
[INFO]   Hello World JBI Component
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] ----------------------------------------------------------------------------
[INFO] Building Hello World JBI Component
[INFO]    task-segment: [archetype:create] (aggregator-style)
[INFO] ----------------------------------------------------------------------------
[INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'.
[INFO] Setting property: velocimacro.messages.on => 'false'.
[INFO] Setting property: resource.loader => 'classpath'.
[INFO] Setting property: resource.manager.logwhenfound => 'false'.
[INFO] ************************************************************** 
[INFO] Starting Jakarta Velocity v1.4
[INFO] RuntimeInstance initializing.
[INFO] Default Properties File: org/apache/velocity/runtime/defaults/velocity.properties
[INFO] Default ResourceManager initializing. (class org.apache.velocity.runtime.resource.ResourceManagerImpl)
[INFO] Resource Loader Instantiated: org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader
[INFO] ClasspathResourceLoader : initialization starting.
[INFO] ClasspathResourceLoader : initialization complete.
[INFO] ResourceCache : initialized. (class org.apache.velocity.runtime.resource.ResourceCacheImpl)
[INFO] Default ResourceManager initialization complete.
[INFO] Loaded System Directive: org.apache.velocity.runtime.directive.Literal
[INFO] Loaded System Directive: org.apache.velocity.runtime.directive.Macro
[INFO] Loaded System Directive: org.apache.velocity.runtime.directive.Parse
[INFO] Loaded System Directive: org.apache.velocity.runtime.directive.Include
[INFO] Loaded System Directive: org.apache.velocity.runtime.directive.Foreach
[INFO] Created: 20 parsers.
[INFO] Velocimacro : initialization starting.
[INFO] Velocimacro : adding VMs from VM library template : VM_global_library.vm
[ERROR] ResourceManager : unable to find resource 'VM_global_library.vm' in any resource loader.
[INFO] Velocimacro : error using  VM library template VM_global_library.vm : org.apache.velocity.exception.ResourceNotFoundException: 
Unable to find resource 'VM_global_library.vm'
[INFO] Velocimacro :  VM library template macro registration complete.
[INFO] Velocimacro : allowInline = true : VMs can be defined inline in templates
[INFO] Velocimacro : allowInlineToOverride = false : VMs defined inline may NOT replace previous VM definitions
[INFO] Velocimacro : allowInlineLocal = false : VMs defined inline will be  global in scope if allowed.
[INFO] Velocimacro : initialization complete.
[INFO] Velocity successfully started.
[INFO] [archetype:create]
[INFO] Defaulting package to group ID: org.apache.servicemix.samples.helloworld.bc
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating Archetype: servicemix-binding-component:3.1-incubating-SNAPSHOT
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: org.apache.servicemix.samples.helloworld.bc
[INFO] Parameter: packageName, Value: org.apache.servicemix.samples.helloworld.bc
[INFO] Parameter: basedir, Value: /Users/bsnyder/src/hello-world-smx
[INFO] Parameter: package, Value: org.apache.servicemix.samples.helloworld.bc
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: artifactId, Value: hello-world-bc-su
[WARNING] org.apache.velocity.runtime.exception.ReferenceException: reference : template = archetype-resources/pom.xml [line 68,column 16] : 
${servicemix-version} is not a valid reference.
[WARNING] org.apache.velocity.runtime.exception.ReferenceException: reference : template = archetype-resources/pom.xml [line 73,column 16] : 
${servicemix-version} is not a valid reference.
[WARNING] org.apache.velocity.runtime.exception.ReferenceException: reference : template = archetype-resources/pom.xml [line 97,column 18] : 
${xbean-version} is not a valid reference.
[INFO] ********************* End of debug info from resources from generated POM ***********************
[INFO] Archetype created in dir: /Users/bsnyder/src/hello-world-smx/hello-world-bc-su
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Mon Jan 15 13:35:44 MST 2007
[INFO] Final Memory: 5M/10M
[INFO] ------------------------------------------------------------------------
{noformat}

Again, Maven creates a directory using the {{artifactId}} provided as the directory name. Inside this directory resides the {{pom.xml}} and the {{src}} directory. If you see the BUILD SUCCESSFUL message, proceed to the next section. Otherwise see the note below about a BUILD ERROR.

{code}
{note}

h2. Compiling the Project 

Since we just created this project, we should first compile it just to make sure nothing is wrong with what the archetype generated. To compile, package and test the project, execute the following command from the command-line: 

{code}
$ cd ./hello-world-bc-su
$ mvn install 
{code}

This command should produce the following output:

 Creating the JBI Component

 

Before we create any custom functionality, let's first examine some of the items generated by the servicemix-service-engine Maven archetype in this simple component we're developing. These classes extend class from either the [JBI spec APIs|http://java.sun.com/integration/1.0/docs/sdk/api/index.html] or from the

 [{{servicemix-common}}|http://fisheye3.cenqua.com/browse/servicemix/trunk/common/servicemix-common/src/main/java/org/apache/servicemix/common] package. 

* {{pom.xml}} - This is the [Maven POM|http://maven.apache.org/guides/introduction/introduction-to-the-pom.html]] file. This XML file contains all the metadata related to the project so Maven can carry out its functionality. 

* {{MyBootstrap.java}} - Implements [{{javax.jbi.component.Boostrap

}}|http://java.sun.com/integration/1.0/docs/sdk/api/javax/jbi/component/Bootstrap.html] which is called by the JBI container as part of the component lifecycle (i.e.g, when the component is installed and uninstalled). This is where you place logic to set up and tear down things when the component is started and stopped.

 

* {{MyComponent.java}} - Extends the

 [{{DefaultComponent}}|http://fisheye3.cenqua.com/browse/servicemix/trunk/common/servicemix-common/src/main/java/org/apache/servicemix/common/DefaultComponent.java?r=trunk], a convenience class that makes creating JBI components much easier and provides some additional lifecycle management of components deployed to the JBI container. This class should be fleshed out by overriding methods in the {{DefaultComponent}} to configure and initialize the component. 

* {{MyConsumerEndpoint.java}} - Extends [{{ConsumerEndpoint}}|http://fisheye3.cenqua.com/browse/servicemix/trunk/common/servicemix-common/src/main/java/org/apache/servicemix/common/endpoints/ConsumerEndpoint.java?r=trunk] and implements {{MyEndpointType}}. If you'd like to create a BC that fulfills the consumer role, implement the {{process()}} method in this class. 

* {{MyEndpointType.java}} - This class is simply an interface marker for [Apache XBean|http://geronimo.apache.org/xbean] so it can generate an XML schema document. 

* {{MyProviderEndpoint.java}} - Extends [{{ProviderEndpoint}}|http://fisheye3.cenqua.com/browse/servicemix/trunk/common/servicemix-common/src/main/java/org/apache/servicemix/common/endpoints/ProviderEndpoint.java?r=trunk] and implements {{MyEndpointType}}. If you'd like to create a BC that fulfills the provider role, depending on the MEP being supported, implement the {{processInOnly()}} method or the {{processInOut()}} method in this class. 

* {{MySpringComponentTest.java}} - A simple JUnit test class that extends a helper class to make configuring ServiceMix very easy. 

* {{src/test/resources/spring.xml}} - The very simple and generic ServiceMix configuration file.

 

Now that we've gotten a bird's eye view of what we're working with, let's proceed to adding the custom functionality.

 

h3. Adding Custom Functionality 

Before creating custom functionality for the BC, you need to understand the role of a JBI BC. A BC is simply a binding to a service that is external to the JBI normalized message router (NMR) using some type of communications protocol (e.g., FTP, HTTP, JMS, etc.). It's also the responsibility of the BC to handle any conversion of the message format into [Normalized Messages|http://servicemix.org/site/5-jbi.html#5.JBI-Normalizedmessage] that can be sent along to the NMR. This is known as message normalization.

 

For example, if we were to create a BC that uses [SNMP|http://www.protocols.com/pbook/tcpip9.htm#SNMP] as the application layer protocol, the SNMP RFC specifies the message format to be used with particular versions of SNMP. It would be the responsibility of the BC to handle not only the communication via the SNMP protocol but also to handling the marshalling of SNMP messages to/from JBI normalized messages. The BC would simply be a binding to a service external to the NMR that speaks SNMP messages via the SNMP protocol.

 

More on this later in the tutorial. For now, let's proceed with the custom functionality.

 

{note:title=Using an IDE}
It is at this stage that you should employ the use of an IDE. An IDE can dramatically reduce the work necessary to import clases, override methods and so much more. Because Maven can generate project files for Eclipse and IntelliJ IDEA, either one can be used. Throughout this tutorial, Eclipse will be used. To generate project files for Eclipse, execute the Maven {{eclipse:eclipse}} goal and then import the project into your Eclipse IDE. 
{note}

The creation of a binding component is dependent upon the role that it will play. BCs are consumers, providers or both. Below are definitions of the two roles as they pertain to BCs: 

* *Consumer* - A consumer BC receives requests from an external service and publishes those requests to the NMR. 
* *Provider* - A provider BC receives requests from the NMR and publishes those requests to an external service. 

This is why both the {{MyConsumerEndpoint.java}} and the {{MyProviderEndpoint.java}} exist when using the servicemix-binding-component archetype to create a Maven project for a SU. This way the BC that you're creating can play both the consumer role and the provider role. For the sake of this tutorial, we will create implement both roles. 

First let's implement the consumer functionality. To do so, open {{MyConsumerEndpoint.java}} and let's take a look at he {{process()}} method as shown below: 

{code}
public void process(MessageExchange exchange) throws Exception {
    // TODO: As we act as a consumer (we just send JBI exchanges)
    // we will receive responses or DONE / ERROR status here
}
{code}

One important item of note before we get started is that this tutorial will not be accessing any services external to the JBI container. The reason for this is that setting up a service external to the JBI container would dramatically increase the complexity of this tutorial. Instead, we will just simulate such functionality by hard-coding some text to be returned. 

This method is just a stub that needs to be filled in with our custom functionality. Take note of the comment in that method stub stating that this method will send JBI message exchanges and will receive responses or status messages in this method. Based on these comments, we know that we have a few tasks to handle in the implementation of this method. So let's get started. 

Below is the method body that can be copied and pasted into the method stub. Following the display of this method, we will pick apart this method a bit to explain the various pieces of logic: 

{code:title=The {{MyConsumerEndpoint.process()}} Method}
public void process(MessageExchange exchange) throws Exception {
    // TODO: As we act as a consumer (we just send JBI exchanges)
    // we will receive responses or DONE / ERROR status here
	
	// The component acts as a consumer, this means this exchange is received because
    // we sent it to another component.  As it is active, this is either an out or a fault
    // If this component does not create / send exchanges, you may just throw an UnsupportedOperationException
    if (exchange.getRole() == MessageExchange.Role.CONSUMER) {
        // Exchange is finished
        if (exchange.getStatus() == ExchangeStatus.DONE) {
            return;
        // Exchange has been aborted with an exception
        } else if (exchange.getStatus() == ExchangeStatus.ERROR) {
            return;
        // Exchange is active
        } else {
            // Out message
            if (exchange.getMessage("out") != null) {
                // TODO ... handle the response
                exchange.setStatus(ExchangeStatus.DONE);
                getChannel().send(exchange);
            // Fault message
            } else if (exchange.getFault() != null) {
                // TODO ... handle the fault
                exchange.setStatus(ExchangeStatus.DONE);
                getChannel().send(exchange);
            // This is not compliant with the default MEPs
            } else {
                throw new IllegalStateException("Consumer exchange is ACTIVE, but no out or fault is provided");
            }
        }
    // Unknown role
    } else {
        throw new IllegalStateException("Unkown role: " + exchange.getRole());
    }
}
{code}



{note:title=Important Information!}
This tutorial will not be accessing any services external to the JBI container. Instead, we will just simulate such functionality by hard-coding some text to be returned. 
{note}

imports

* {{javax.jbi.messaging.ExchangeStatus}} 
* 

_This is a work in progress. I will finish this up very soon._

h2. Testing the Hello World Binding Component

Thanks to the archetype, testing the component is very easy because it already created a test. The only change we'll make is to the string being sent by the client code. In the {{src/test/java}} directory is the {{org.apache.servicemix.samples.helloworld.bc.MySpringComponentTest}} test. Simply open this test and change line #36 from this:

 

{noformat}

{noformat}

Notice that not only do we see that the build was successful, but also note the text in the output above that was printed by the test (*<hello>Hello World! Message \[<hello>Ski Colorado!</hello>\] contains \[28\] bytes.</hello>*). This is the message we were expecting to be output from the test. So if you see this, you just wrote a JBI component and tested it successfully. Now this SU needs to be wrapped in a SA so it can be deployed to the JBI container. 

h2. Wrapping the Service Unit in a Service Assembly

 

The component we created above and packaged as a SU cannot be directly deployed to a JBI container until it's wrapped in a SA. This can be done by creating a SA with a dependency on the SA. From within the {{hello-world-smx}} directory, execute the following commands to create the project for the SA:

{noformat}

The {{hello-world-smx}} directory should now contain the following two directories:

|Mailing Lists]. 

Now that we have a project for the SA, we need to edit the POM so that the project depends upon the JBI component we created above. This can be done by editing the POM for the SA to add a dependency upon the {{hello-world-bc-su}} as listed below:

{code}

{noformat}

{noformat}

h2. Incorporating the Projects Into a Top Level POM

Now that we have created the SU and SA projects, a top level {{pom.xml}} must be manually created and made aware of each subproject. This will allow all the projects to be built automatically without having to build each project in order manually. Maven will discover all the projects and build them in the proper order. In the {{hello-world-bc-su}} directory, create a file named {{pom.xml}} containing the following content:

{code

}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.apache.servicemix.samples.helloworld</groupId>
  <artifactId>hello-world-smx</artifactId>
  <packaging>pom</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>Hello World JBI Component</name>

  <modules>
    <module>hello-world-sa</module>
    <module>hello-world-bc-su</module>
  </modules>

</project>

{code}

This POM will allow the example to be easily folded in to the ServiceMix samples. The {{<modules>}} element denotes the other projects that were created above using the Maven archetypes. Once the {{pom.xml}} file from above is saved into the {{hello-world-smx}} directory, you should now see the following:

xml
{code}

All projects can now be built using the following command on the command-line from the top level {{hello-world-smx}} directory:

 

{noformat}

{noformat} 

As long as you see the BUILD SUCCESSFUL message in the output continue to the next section to give each project a unique name. 

h2. Give Each of the Maven Subprojects a Name 

Notice in the output above that there are a two projects named _A custom project_. This is because the archetypes create projects with this generic name. Let's give each project a unique name via each component's {{pom.xml}} file. This name will allow Maven's output to denote a component's name in its output making our development work a bit easier. To name each project, simply edit each {{pom.xml}} and replace {{<name>A custom project</name>}} with an appropriate name. Below are the instructions for naming each component's project: 

* Edit {{hello-world-sa/pom.xml}} and replace {{<name>A custom project</name>}} with {{<name>Hello World Service Assembly</name>

}}
* Edit {{hello-world-bc-su/pom.

xml}} and replace {{<name>A custom project</name>}} with {{<name>Hello World BC Service Unit</name>

}}

Now when the projects are built you will no longer see a project named _A custom project_. Instead you'll now see _Hello World SE Service Unit_ and _Hello World Service Assembly_. Rebuild the projects again using the {{mvn clean install}} command on the command-line to see the change.

 

h3. Deploying the Component 

Now that the SA is built, we're ready to deploy it to the JBI container.

 

_This is a work in progress. I will finish this up very soon.

.
{note}

h2. Additional Resources 

* [Creating a Standard JBI Component]
* [Notes on Creating JBI Component using maven2]
* [Roadmap for a perspective Servicemix developer]