JBI Component Technical Overview
Contributed and maintained by Vince Genovese
December, 2007
This guide provides an overview on Java Business Integration (JBI) concepts. It also includes overview information on JBI components available in the full download with NetBeans IDE 6.0. This includes information for configuring, deploying, starting, and stopping JBI components.
For more information on individual JBI components refer to the User Guide available for each JBI component.
Contents
JBI Overview
Java Business Integration (JBI) is a standard developed under the Java Community Process (JCP) as an approach to implementing a service-oriented architecture (SOA). It defines an environment for plug-in components that interact using a services model based directly on Web Services Description Language (WSDL) 2.0. The plug-in components function as service providers, or service consumers, or both.
Components that supply or consume services locally (within the JBI environment) are termed Service Engines. Components that provide or consume services using some sort of communications protocol are called Binding Components.
JBI components, once installed in the JBI environment, interact with each other using message exchanges published by the JBI component providing the services. The message exchanges provide service descriptions that are the sole source of information needed for service consumer components to interact with the service provider.
The JBI environment provides a lightweight messaging infrastructure for the exchange of messages between the JBI components, which always use this messaging infrastructure as an intermediary.
Figure 1 below illustrates basic messaging concepts in a JBI runtime environment.
Figure 1: JBI Runtime Environment
Figure 1 shows JBI components (Service Engines and Binding Components) in a JBI runtime environment. Each JBI component communicates with the JBI Normalized Message Router (NMR) using only the communication protocol it is expecting (for example, using HTTP, JMS, or some other communication protocol).
Because each JBI component communicates with the NMR, each component thus can communicate with any other JBI component within the JBI runtime environment. Note that Service Engines provide other JBI components access to services while Binding Component provide access to services that are external to the JBI environment.
Service Engines
Service Engines provide or consume services locally within the JBI runtime environment, enabling services such as business logic, processing, transformation, and routing services.
For example, some Service Engines might execute long-lived business processes, while others provide data transformation or sophisticated Electronic Data Interchange (EDI) services.
The following links describe in greater detail the service engines available with NetBeans IDE 6.0 Preview with SOA (M9):
Binding Components
Binding Components provide protocol independence for transport or communication. They access remote services using a specific protocol, and place those services onto the JBI Normalized Message Router. Other JBI components can then access these services from the NMR.
Binding Components are specialized for specific external protocols, such as HTTP, JMS, and others. This allows any JBI component to communicate over any protocol or transport available from Binding Components deployed to the JBI runtime environment. There is no need to implement these protocols separately in business logic.
The following links describe in greater detail the binding components available with NetBeans IDE 6.0:
JBI Component Life Cycle
The JBI components available with the NetBeans IDE 6.0 are installed as part of the GlassFish application server, which is included in the Full download of the IDE. Initially, the installed JBI components are in the stopped state of the JBI component life cycle. Refer to the section Life Cycles Within the JBI Framework for more information on the JBI component lifecycle, and how to start, stop, and shutdown JBI components.
Service Assemblies
Each type of JBI component needs specific application artifacts to configure how the component provides and consumes services. For example, an EAR file can be used to configure a Java EE Service Engine to provide a desired service. A collection of such related artifacts is called a Service Assembly. Each application artifact in the service assembly is a service unit. The service assembly contains configuration information that defines to which JBI component each service unit is deployed.
For example, the EAR file mentioned above plus another application artifact, the SOAP Binding configuration data used to make the service available to SOAP clients, constitute service units within a service assembly. Once an assembly is ready for use, it is deployed to the JBI environment. The JBI environment automatically distributes the service units to the appropriate JBI components that use them.
Service assemblies are typically created and deployed in a development tools environment, such as that provided by the NetBeans IDE. Other administrative tools are available. For more information, refer to the section JBI Administration.
Life Cycles Within the JBI Framework
JBI Components, service assemblies, and service units have life cycle states that are controlled by JBI administrative tools. The NetBeans IDE 6.0 provides administrative tools for managing the lifecycle states of the JBI components and service assemblies. The lifecycle states of service units are managed indirectly through the service assembly. Other administrative tools are available, as described in the section JBI Administration.
The GlassFish application server persists the life cycle state of JBI components and service assemblies. When the application server shuts down and then restarts, JBI components and service assemblies revert to their state at the time the application server shut down.
JBI Component Life Cycle
Table 1: JBI Component Life Cycle
When you first install NetBeans IDE 6.0, the installer installs JBI service engines and binding components that are provided with the NetBeans IDE. After installation, these components are in the stopped state. You can stop, start, or shutdown JBI components using the JBI Manager in the NetBeans IDE. The following procedure shows how to start a JBI component.
To start a JBI component using the JBI Manager in the NetBeans IDE:
After expanding the nodes, you can view the installed JBI components. If a component icon has a down arrow badge, this means the component has not been started or has been shut down. A red warning badge indicates that the component has been stopped (or is not running).
Figure 2: JBI Components in NetBeans IDE
The state of a component is persistent. If you shut down the application server and then restart it, the JBI component returns to the state at the time the application server shut down.
Service Assembly Life Cycle
Table 2: JBI Service Assembly Life Cycle
The life cycle for service units is dependent on the life cycle for the service assemblies which contain the service units. When you deploy, start, stop, and shutdown a service assembly, the same action occurs for all service units contained within the service assembly.
Deploying Service Assemblies to Components
One of the most frequent JBI administration tasks is to deploy a service assembly to a component. Here is the typical order of events for this scenario:
This task is performed multiple times, once for each service assembly you deploy to the component.
A JBI component can be in the stopped state before the service assembly is deployed to it. Once the service assembly is deployed it automatically starts. (Optional) Stop or shutdown the service assembly.
Once a service assembly is deployed and started, you can explicitly stop or shutdown the service assembly. You cannot exchange messages or invoke services within that service assembly unless the service assembly is in the started state. Uninstall a JBI component.
When uninstalling a JBI component, first make sure all service assemblies are stopped, shut down, and undeployed. This is to avoid other services attempting to access services that will no longer be available because of the uninstallation.
Then stop, shut down, and uninstall the JBI component.
Runtime Properties for JBI Components and Service Assemblies
JBI components have runtime properties that describe the component or define their behavior. Properties that describe the component are read-only and provide information such as the name or life cycle state. Properties that define behavior are configurable and can be modified according to the requirements of the composite application that utilizes the component.
JBI service assemblies and service units have read-only properties that describe the service assembly or service unit.
JBI Component Runtime Properties
Some component properties are common to all JBI components, but an individual component might have specific properties that control behavior specific to that component. Table 3 lists the properties that are common to all JBI components. Refer to each components User Guide for information on additional runtime properties specific to that component.
Table 3: Runtime Properties for JBI Components
Max Threads
OutboundThreads Yes The number of threads utilized by a component can be configured to optimize the behavior of the component. Depending on the component, this property might apply to all threads or outbound threads.
The number of threads you configure depends on the number of messages that can be active when the component is running.
Default value: 10
Using environment variables provides greater flexibility in modifying configurations for JBI components.
To configure the runtime properties of a JBI component using the NetBeans JBI Manager:
Service Assembly Runtime Properties
Service assembly runtime properties provide information about the service assembly.
Table 4: Runtime Properties for Service Assemblies
Service Unit Runtime Properties
Service unit runtime properties provide information about the service unit.
Table 5: Runtime Properties for Service Units
JBI Administration
Figure 3 illustrates the JBI runtime environment available with NetBeans IDE 6.0 Preview with SOA (M9). It includes several of the JBI components that are installed by default in the JBI environment. Figure 3 also references the JBI administrative functions necessary to install JBI components and deploy service assemblies to JBI components.
Figure 3: JBI Runtime Environment Administration
JBI Administration Tools
The NetBeans IDE provides several tools you can use to administer JBI composite applications.
Invoke the JBI Manager from the Runtime tab of the NetBeans IDE. Right-click a JBI component or service assembly to view the administration options available. GlassFish application server Admin Console
Select the JBI node in the application server Admin Console to view the screens available for JBI administration. The application server provides help screens to assist you with administration tasks. Application server Command Line Interface (CLI)
CLI administration commands are available from the GlassFish application server. The application server provides man pages to assist you with the administration tasks. ANT Task Reference and ANT Target Reference
You can use the ANT Task Reference and ANT Target Reference to administer JBI composite applications. You can locate the ANT references in your application server installation at the following location: <AppServerInstallDir>\jbi\doc\antdoc\ Composite Application Service Assembly (CASA) Editor
The CASA Editor provides a high level view of a composite application, allowing you to interactively specify service endpoints and configurations. Invoke the CASA Editor from the Project window in the NetBeans IDE. To invoke the CASA Editor, right-click a composite application project and select Edit Project.
Bookmark this page
Documentation
Projects:
Sponsored by 
You are viewing a mobilized version of this site...
View original page here
