Designing a repository-based Java CAPS project requires the following tasks:
Start the necessary internal and external servers.
Start the NetBeans IDE and open a new or existing CAPS project.
Create, configure, and connect design elements. For details, see the end-to-end scenarios.
As needed, create business logic and orchestrate business processes and/or page flows. For details, see the end-to-end scenarios.
Build the CAPS application, and then deploy and test it on an application server.
As needed, bridge the CAPS application to JBI and combine it with other projects to create a composite application. Then, build the composite application and deploy/test it on an application server.
Java CAPS repository-based projects can include the following design elements, each with its own type of editor:
Properties to be used for design-time components such as adapters, engines, and queues
Properties to be used for runtime servers for external and internal systems
Message libraries and object type definitions (OTDs) to model and encode data
Java collaboration definitions (JCDs) to transform data
Other data-transformation engines, such as for eTL collaborations or XSLT transformations
Sun Master Index components
Business processes (BPs) and page flows to implement business-logic rules and to orchestrate the execution of components and web services. Within Java CAPS projects, the editor uses Business Process Execution Language (BPEL) 1.0.
Other specialized design elements, such as page layouts or cascading style sheets (CSSs)
Connectivity maps (CMaps) to establish and configure connections between design-time components
Deployment profiles (DPs) to assign engines, adapters, and queues with corresponding server resources
Composite applications can include the following additional design elements, each with its own type of editor:
Properties to be used for Binding Components (BCs) and Service Engines (SEs)
Business logic and orchestration. In the JBI container, composite applications use BPEL 2.0.
Web Service Description Language (WSDL) elements with editable message definitions, port types, partner links, and so forth
Composite Application Service Assembly (CASA) configurations between JBI module connections with WSDL ports and external modules
This section presents a scenario that takes you through the steps required to create a simple application without requiring any special external systems. The simplicity of the application's runtime execution is grotesquely disproportionate to the tools you use to design it. :-) This is because the purpose of the scenario is instructive rather than functional: It shows you how to exercise the main design components of Java CAPS and how to use a Java CAPS application in a JBI container.
The intermediate goals you will reach and the design components you will use are summarized below:
Identify and configure data endpoints: a source for input and a target for output.
In this scenario, you will use a file for input data records and JMS for output data records.
In a real-world application, you might use several input and output streams encompassing multiple external systems. You would not use JMS as a primary endpoint, but rather as a conduit for persisting data.
Model the input and output data using OTDs.
In this scenario, you will create a user-defined OTD for input and an XSD-based OTD for output.
In a real-world application, you might use OTDs from a specialized prebuilt message library, or you might use OTDs corresponding to database adapters and/or communication adapters.
Perform a transformation on the input data.
In this scenario, you will copy data using getter and setter methods, perform a comparison, and insert a value based on a variable.
In a real-world application, you might well do just a simple copy to translate between disparate systems, or you might instead create many modules that perform hundreds or thousands of operations on the data.
Design a simple business process.
In this scenario, you will use a very simple Receive-Activity-Reply pattern.
In a real-world application, you might not use business processes at all, or you might use multiple complex business processes with complex logic.
Design a connectivity map.
In this scenario, you will create and populate a connectivity map, connect the components, and configure the connections.
In a real-world application, you might use multiple connectivity maps.
Create a deployment profile and then build an Enterprise Application Resource (EAR) file.
In this scenario, you will assign the components in one connectivity map to a few internal systems and one external system (File).
In a real-world application, you might use multiple connectivity maps, and you would usually have several different external systems.
Deploy the EAR file to an application server and then test the application with sample data.
In this scenario, you will feed sample data one record at a time and check output.
To test the design of a real-world application, you might need to feed several different kinds of sample data from several systems, you would try out a wide variety of positive and negative test cases, and iteratively refine your design.
(In a production deployment, you would also address such issues as balancing loads, tuning throughput performance, scaling, monitoring, and so forth.)
Before You Begin
Navigate to your C:\JavaCAPS6\ folder.
Start the two servers you need by running these two shortcuts:
start_repository
start_appserver_domain1
Start the NetBeans IDE by running this shortcut:
start_netbeans
If you are an experienced Java CAPS designer, take time to acquaint yourself with the differences between the new NetBeans IDE and the Enterprise Designer GUI from previous releases:
The GUI has a different look and feel. Experiment with panes that can be independently docked, hidden, and rearranged, and acquaint yourself with such new features as macros, source editors, tag libraries, keyboard shortcuts, refactoring options, versioning tools, and so forth. Online help applies to the entire NetBeans IDE, not to CAPS-specific design components.
Java CAPS projects are now just one of many different project types, and projects that are not currently in use are not displayed.
Java CAPS environments are now subsumed into a larger category of Services.
