Author : Srinivasan Chikkala
Date : 10/16/06
Draft Version :  0.1

JBI  Component Development Tools ( JBICDT ) User View

This document describes the usecases and the userview that will be supported for JBI Components Development Tools (JBICDT).

JBICDT contains GUI based tools that provide integrated development environment for developing Service Engines and Binding Components. These tools are based on Netbeans IDE and provides the standard Netbeans IDE user experience in developing JBI Components using Netbeans IDE.


JBICDT i mainly targeted to run on Netbeans IDE 5.5 or above. The minimum version of the Netbeans IDE that will be supported for JBICDT is 5.5. JBICDT will be installed on the Netbeans IDE as a set of Netbeans modules.  JBICDT modules will be part of the Netbeans Enterprise Pack 5.6 and will be added to soa1? cluster of the enterprise pack tools.


Target users are the JBI Component developers who develop Service Engines and Binding Components using JBI APIs and SPIs. These users can use JBICDT along with the standard java development tools
provided in the IDE.


The following usecases will be supported in JBICDT from the set of requirements from

Usecase #
Create Component project for Service Engine (SE) Development
Create Component project for Binding Component (BC) Development
Create sample component code for SE  
Create sample component code for BC
View Component ( SE or BC )  artifacts
Customize Component Project
Change Component description

Change component name in JBI.xml and build scripts

Change component description in JBI.xml

Add/remove libraries

Add/remove external jar files and update JBI.xml

Add/remove dependent project jar files and update JBI.xml

Change Installation options

Select target JBI server

Select component start after installation

Change test options

Build and deploy test SA before junit test runs

Compile component code
Include JBI jar as library in compile classpath

Include exteranl jar or dependent project jar files in compile classpath

Package component code
Package external jars and dependent project jars in the component zip file

Install component
Select target JBI server for installation

Install and start ( optional ) component

Test component

(optional ) Build and deploy testSA before running junit test

Provide help on JBI APIs in Java Editor
Code complete JBI APIs  in Java editor window

Bring up inline help window for JBI APIs in Java editor window

Schema validate jbi.xml in xml text editor

User Workflow

A standard Netbeans IDE user interactions will be used in JBICDT for JBI Component development activities by providing Projects, Actions, Wizards, Nodes and Editors for creating and manipulating JBI Service Engine( SE) or Binding Component ( BC ) artifacts. A Developer would create, edit, build, install and test the JBI components ( SE or BC) using JBICDT. For developing SE or BC, JBI developer starts with creating or opening an already created project corresponding to SE or BC and view/edit/build/test component artifacts in the project environment. The component ( SE or BC ) project will have ant based build scripts for compile, package, install and test the component, a explorer view for navigating to the JBI artifacts, set of actions to perform various tasks like edit, build, install and test etc.

The following are the common steps that user will perform in component development lifecycle using JBICDT
  1. Create a project  - select the project wizard using the project templates dialog and enter required data for creating the project and the set of component artifacts ( jbi.xml and the sample java code ) for  SE or BC project.
  2. Edit the java code for the component -  navigates to the java code under source packages in the project view and bring up the java editor for add/modify the java code. User can use inline help and code completion for the JBI APIs used in the code.
  3. Add/remove java libraries - add/remove jar files required for the component which can be external to the IDE or produced by the dependent projects in the IDE using project customizer.
  4. Build component  - select project standard actions to clean, compile and package the component code into a zip file for installation to JBI Platform.
  5. Add test code -  create a junit test cases in the Test source folder that can act as a service consumer or service provider to send/receive messages from the component. Some times, user might want to create a test service assembly to deploy it to the components in the jbi server as part of the test which can be deployed by the project test action if configured through project customizer to deploy the test service assembly.
  6. Install component  -  select project action that can install the component to the JBI Platform.
  7. Test component. - select the project action from the project node to run the unit tests with optional test service assembly deployment to test the installed component.
  8. Debug component  - starts the appserver in debug mode and then attach the appserver debugger to the IDE so that the component code can be debugged
  9. Control component lifecycle ( start, stop or shutdown ) - during the test/debug cycle, user changes the state of the component
  10. Uninstall component  - can uninstall component from the target server for re-installing the modified component from the IDE.

Service Engine Project Wizard

<Service Engine Wizard Image>
Service Engine Wizard

Binding Component Project Wizard

<Binding Component Wizard Image>
Binding Component Project Wizard

Project View

<Project Explorer View Image>

Project View

Project Actions

<Project Actions popup menu Image>
Project Actions

Project Customizer

<Project customizer Image>