Jun 23

In some views SOA is represented as a series of 4 layers: Presentation Layer (SOA 1), Business Process Layer (SOA 2), Business Service Layer (SOA 3) and Technical Layer (SOA 4). Typically each layer higher up in the hierarchy consumes services exposed by the layer under it. So the Presentation Layer would consume services provided by the Business Process or Business Service Layers. Service interfaces are described using Web Services Description Language (WSDL), sheltering service consumers from details of service implementation. Web Services are seen as the technical means to implement the decoupled functional layers in a SOA development. Decoupling allows implementations of business functionality at different layers to be swapped in and out without disturbing other layers in the stack.

The business idea is that patients are looked after in various healthcare facilities. Frequently applications need to allow selection of a facility and to access facility details for display to human operators. A relational database is used to hold the details of facilities which are a part of the healthcare enterprise. To shelter application developers from the details of the data store facility list and details are made available as a multi-operation web service. This web service will be used to construct the web application that provides a user view into the facilities and facility details.

The previous document in this series, “GlassFish ESB v 2.1   Creating a Healthcare Facility Web Service Provider”, walked the reader through the process of implementing a GlassFish ESB v2.1-based, multi-operation web service which returns facility list and facility details. In this document I will walk through the process of developing a Visual Web Application which will use the Web Service as a data provider. We will use the NetBeans 6.5.1 IDE, which comes as part of the GlassFish ESB v2.1 installation. The application will be implemented as a Visual Web JavaServer Faces Application using JSF component provided by Project Woodstock. This application will introduce the technology in a practical manner and show how a multi-operation web service can be used as a data provider, decoupling the web application from the data stores and specifics of data provision.

Note that this document is not a tutorial on JavaServer Faces, Visual Web JSF, Project Woodstock components or Web Application development. Note also that all the components and technologies used are either distributed as part of the NetBeans 6.5, as part of the GalssFish ESB v2.1 or are readily pluggable into the NetBeans IDE. All are free and open source.

It is assumed that a GlassFish ESB v2.1-based infrastructure, supplemented by the Sun WebSpace Server 10 Portal functionality and a MySQL RDBMS instance, are available for development and deployment of the web application discussed in this paper. It is further assumed that the web service, developed using instructions in “GlassFish ESB v 2.1 – Creating a Healthcare Facility Web Service Provider, is available and deployed to the infrastructure. The instructions necessary to install this infrastructure are discussed in the blog entry “Adding Sun WebSpace Server 10 Portal Server functionality to the GlassFish ESB v2.1 Installation”, supplemented by the material in blog entry “Making Web Space Server And Web Services Play Nicely In A Single Instance Of The Glassfish Application Server”.

Here is the document – 01_FacilityService_WebApplication.pdf

While I am migrating my blog to blogs.czapski.id.au some links in older posys may be broken. For as long as it works, go to the http://blogs.sun.com/javacapsfieldtech/ find the post with the identical title.
Mar 13

Java CAPS 5.x came with its own, built-in version control system, which many people liked and many despised. Java CAPS 6 Repository still has that version control system. Unlike the repository-based components standard NetBeans components, EJBs, and the JBI-based components, developed through the OpenESB Project and supported, for a fee, in the GlassFishESB product, must use an external version control system, if they are to be placed under version control.

This note discusses how a Subversion VCS can be installed on a Windows platform and used to provide version control for non-Repository components in Java CAPS 6 product and for projects in the GlassFishESB product and OpenESB project.

Clearly, non-Windows platforms can be similarly configured to support Subversion.

This Note, Subversion_with_OpenESB_GlassFishESB_or_JavaCAPS6, is a step-by-step guide to getting Subversion installed and configured to work with NetBeans 6.1. It is not a tutorial on version control.

Jan 08

The Note “HL7 Processor Demonstration – Java CAPS 6/JBI and OpenESB” walks the reader through development of a Java CAPS 6/JBI-based / OpenESB-based solution that addresses a Healthcare-related business problem. The Note elaborates on the healthcare background necessary to get a notion of what is being done and why, and provides detailed steps required to implement and exercise the solution.

I recorded a screencast of a session during which I discuss the business side of the Note, then discuss, implement, deploy and exercise all components of the solution documented in the Note.

The screencast is here: HL7Processor_Exercise_Screencast.avi. The associated archive, 00_HL7Processor_example_screencast_companion.zip, contains code fragments and other bits and pieces which are used, or referred to, in the screencast. Of some interest are the Note itself, in documents/00_HL7_Example_Development_Instructions_Final.pdf, and the brief example implementation instructions, in documents/00_HL7_ExampleBrief.pdf. I followed the brief instructions while I was building the projects when recording the screencast.

The screencast, which is over 320 Mb in size and takes 2 hours and 50 minutes to play, may require a TechSmith Compression Codec on your machine to allow your player to play the media. You can get one from the TechSmith site: http://www.techsmith.com/download/codecs.asp. Information on the codec can also be found here: http://www.movavi.com/codec/TSCC.html. If you prefer, and you are on Windows, you can get the CamPlay.exe from here: CamPlay.zip and use it instead.

Tagged with:
Jan 01

This Note walks the reader through development of a Java CAPS 6/JBI-based / OpenESB-based solution that addresses a Healthcare-related business problem. The Note elaborates on the healthcare background necessary to get a notion of what is being done and why, and provides detailed steps required to implement and exercise the solution to the business problem.

Updated note, where GlassFsish ESB v2.1 is used instead of Java CAPS 6, is available at 00_HL7_Example_Development_Instructions_Final_1.1.2.pdf

We will use the HL7 Binding Component, the File Binding Component, the JMS Binding Component, the SOAP/HTTP Binding Component, the BPEL 2.0 Service Engine, the JavaEE Service Engine, the HL7 Encoder and EJB-based Web Services in a JBI-based solution.

In the process we will create XML Schema Documents (XSDs), Web Services Description Language Documents (WSDLs), a BPEL 2.0 Business Process, an EJB-based “Implementation First” web service, an EJB- and WSDL-based “Interface First” web service, a bunch of Composite Applications, BPLE 2.0 mapping, BPEL 2.0-based Web Service orchestration, on-the-fly conversion of HL7 version 2.3.1 delimited messages to their XML equivalents. We will get a pretty good exposure to what OpenESB and Java CAPS 6/JBI components look like, how they work and how they can be used to create real business solutions. Above all, we will develop and test a solution that is more sophisticated then the customary “Hello World” examples but not so complex as to take too long to build and become too hard to comprehend by a novice user.

The particular business problem and the particular solution came about because once upon a time there was intent to build a series of related OpenESB projects – HL7 Processor, MDM Processor and IEP Processor – that would:

  • receive HL7 v2.x delimited messages
  • convert HL7 v2.x messages to their equivalent XML format
  • split message stream into ADT A01s, ADT A03s and other
  • convert A01s to an abbreviated Custom Patient XML format
  • convert A03s to an abbreviated Custom Discharge format
  • send Custom Patients to a JMS Queue for processing by a MDM solution
  • send Custom Discharges to a JMS Queue for processing by an IEM solution
  • have the MDM process Custom Patients into a Master Patient Index
  • have the IEP process Custom Discharges to flag excessive length of stay

The MDM Processor and the IEP Processor made it to the Sun CEC 2008 as demonstrations, with associated Tutorials by Tom Barrett, and demonstration recordings by me. The HL7 Processor did not make it. With the appearance of Java CAPS 6 Update 1 more JBI components made it into the officially supported Sun product. While the HL7 BC and the HL7 Encoder did not make it into this Update they will, eventually. Both components are already available from the OpenESB site and can be installed into the Java CAPS 6 Update 1 installation as unsupported components. This is what we will do for this Note.

The complete Note is to be found here.

The archive containing supplementary material you can use to save yourself the trouble of downloading component and, above all else, containing test files with HL7 delimited records, is here.

For these interested in processing HL7 using GlassFish ESB v2.1 there is a blog entry, “GlassFish ESB v2.1, MySQL v5.1 – Make HL7 v2.3.1 Delimited Messages from Custom Delimited Records with HL7 Encoder“, which discusses, amongst other things, how to create a custom HL7 v2 ADT A04 XSD and a “match any” XSD.

Tagged with:
Dec 19

Following the CEC 2008 Conference in Las Vegas, where the Java CAPS Stream saw a bunch of presentations and demonstrations, I am happy to offer screencasts of the three demonstration sessions I recorded for the event.

The GlassFish ESB screencast is the ScreenCast of the CEC 2008 GlassFish ESB Essentials Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in
the GlassFish ESB Tutorial and Lab document. The screencast is an extended version of what the CEC audience got to see. In this screencast I use the OpenESB distribution to discuss, design and implement an abbreviated Supply Chain solution
. I use the File BC, the SOAP/HTTP BC, BPEL 2.0 SE, the Custom Ecoder, the XSD Editor, the WSDL Editor, BPEL correlations, BPEL Pick wit Timer, CASA Editor and a bunch of other OpenESB/GlassFish ESB featiures and facilities. Watching the screencast will give you a pretty good idea what the tooling looks like, how easy it is ti use it, how a theoretical requirement can be turned into a practical design and how that design can be implemented and exercised using the tooling and infrastructure you can get free of charge and use as much as you might desire.

Data for the following two screencasts/demonstrations is produced by the solution discussed in the next blog entry, which ought to precede these two.

The Java CAPS 6/Mural Master data Management screencast is the ScreenCast of the CEC 2008 Java CAPS Essentials Master Data Management (MDM) Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in the Java CAPS Essentials MDM Tutorial and Lab document. In the screencast I discuss what the Master Data Management (MDM) is, how a Healthcare enterprise might leverage it to improve its business and how the OpenESB or Java CAPS 6 can be used to implement MDM. I use OpenESB to design a Master Patient Index Data Model, implement it with the tool, generate Data Model-based Master Index Data Management Web Application, build an integration solution to feed the MDM solution with transactional data form Hospital Information Systems and build a broadcast processor solution that can be used to send master patient index updates to downstream systems which have a need to be kept in synch with the enterprise view of the patient. One will get a very good idea of what the core Master Data Management is about, how easy it is to create the MDM Application and related integration components using the OpenESB/Java CAPS 6 tooling, and how the business of maintaining master patient index looks and works like.

The Java CAPS 6 / Intelligent Event Processor screencast is the ScreenCast of the CEC 2008 Java
CAPS Essentials IEP Lab demonstration. This is a recording of the demonstration described in detail by Tom Barrett in the Java CAPS Essentials IEP Tutorial and Lab document.The screencast is what the CEC audience got to see. In this screencast I demonstrate how an Intelligent Event Processing (IEP) solution is built and exercised. The solution addresses a Helathcare business problem – it calculates an Average Length of Stay for each patient in a sliding time window, based on data from an ADT A03 HL7 Discharge message, works out which patients’ Length of Stay exceeds average for the patients in the window by 1.5 times, and passes records related to these patients
on while discarding ‘normal’ records.

The AVIs were recorded with Camtasia Studio. You may need a Camtasia Player to playe them on Windows. You could also try getting a Camtasia codec for your platform/player from the Camtasia site.

I had audio quality problems when directly playing the recordings through Mozilla, which used the Quicktime plugin. The best thing to do is to download the recordings and try different players until one works for you.;


Tagged with:
Nov 18

It has been a while. I was busy. One of the things that kept me busy was putting together demonstrations for the CEC 2008 in Las Vegas, then delivering them. As an offshoot of that work I have a fair bit of material to share, which will take some time to put together into a form that can be posted in the blog. This piece is the first one.

Whereas Java CAPS 6 supports interaction with the Java MQ infrastructure through the Enterprise Manager, neither OpenESB nor GlassFishESB include the ‘Enterprise’ class functionality found in the Java CAPS ‘classic’, GUI for interaction with the JMS being one of example.

Here is a step-by-step on how to configure Hermes JMS (http://www.hermesjms.com/) for use with Java MQ, distributed as part of the OpenESB, GlassFishESB and Java CAPS 6. <- This link points to the original post.

The updated post, including material from the comments below, is available as HermesJMS_Configuration_for_JavaMQ and should be used instead.

Jul 23

Java CAPS 5.x used to have a Scheduler eWay. Java CAPS 6 also has the Scheduler eWay but only on the Repository-based side. At this point in time there is no Scheduler JCA Adapter or a Scheduler Binding Component. Why would one be bothered by that? One would be bothered because there are business requirements that call for scheduling of activities. The one that comes to mind immediately is polling an FTP server for a file which to transfer. For polling the local file system there is the Batch Inbound JCA, which was used in solutions discussed in JCA Notes 2 and 3. For Batch FTP JCA there is no such thing.
Rather then ignoring the issue of lack of the Scheduler JCA Adapter I determined to see what can be done to provide this functionality for non-Repository-based Java CAPS 6 solutions.
When asked, one of my colleagues in the US suggested that EJB Timers are the way to go and provided the links to the material. I looked at what was discussed, threw up my hand in the air and exclaimed. I will not quote what I said. In short, EJB Timers may be all very well for a competent Java EE developer but not for a regular Integration, or SOA, developer. EJB Timers are, in my view, way too complex to implement and do not offer sufficient advantage over a Scheduler eWay to make it worth while to spend the time developing a solution that uses them.
The next thing I looked at was the open source Quarz scheduler, which also turned up to require more effort then I considered worth while for the Notes.
I felt that the simplest thing to do will be to use an external scheduler, a native one, provided by the OS. For Windows, on which I develop for the Notes, there is the “Scheduled Tasks” scheduler. For Unix there are Cron facilities. Both are well know and typically good enough in terms of timer resolution and scheduling flexibility. Above all else, using one does not require me to write scheduler code myself, merely write the code that triggers my solution when the scheduled event fires.
So, this Note walks through implementation of a Scheduler solution, which can be used to trigger a Batch FTP JCA solution or any other JCA-based or JBI-based solution that has to be triggered to some schedule.

Document 00Scheduler.pdf contains the entire Note.

Tagged with:
Jul 14

Someone asked a question along the lines of “Is it possible to develop a solution in OpenESB where the HTTP BC receives a request and the SMTP BC uses it to send electronic mail with no BPEL logic to tie the two together”. I though that the answer was “Yes” but I felt I had to verify it. Vishnuvardhan Piskalaramesh from Sun, who is looking after the SMTP BC, and Sherry Weng from Sun, who is looking after the HTTP BC, helped along and here is the result.

This note describes, with illustrations, a mini integration solution wherein an appropriately formulated HTTP GET request is used to submit an electronic mail to a SMTP server, using the HTTP Binding Component and the SMTP Binding Component, without the need to provide any transformation logic. This is another example where a
practical JBI-based integration solution can be constructed in minutes.
05JBI_HTTP2SMTP_NoBPEL.pdf provides the illustrated discussion.

Jun 21

The attached document explores the ability of Java CAPS 6/JBI and OpenESB to expose and execute Java-based logic as a JBI service. It walks through the process of creation, deployment and execution of a simple File-to-File integration solution that reads an XML record from a text file, invokes java logic that operates on that record then writes the XML response record into a file.


There are errors in pictures on pages 12 and 13. The WSDL name in the pictures does not correspond to the name in the text. This error is corrected in revision 1.1 of the document, 04File2FielJavaEE_1.1.pdf. Thanks to Juraj Kazda for spotting the issue.

Jun 15

The attached document briefly explores the Encoder aspect of Java CAPS 6/JBI and OpenESB. It walks through the process of creation, deployment and execution of a simple File-to-File integration solution that reads comma-delimited record from a text file, ‘decodes’ then into XML and writes the XML-equivalent records into a file. The project is then extended to ‘encode’ XML records back to CSV format on output.

The focus is the practice of using JBI components not the theory of JBI.

This document addresses the integration solution developers, not developers of Service Engines or Binding Components.

The project uses JBI components only, that’s why it is just as good for OpenESB exploration as it is for Java CAPS 6/JBI exploration.

JBI (Java Business Integration) is not discussed to any great extent. JBI artifact names are used in discussion but not elaborated upon. Explanations are provided where necessary to foster understanding of the mechanics of developing integration solutions using JBI technologies in OpenESB and Java CAPS 6/JBI.

Java CAPS 6 and OpenESB are two of a number of toolkits that implement the JBI specification (JSR 208). When I use an expression like “In JBI …” I actually mean “In JBI as implemented in Java CAPS 6 and OpenESB …”. The same things may well be implemented differently in other JBI toolkits.

Java CAPS 6 “Revenue Release” is used and shown in illustrations. OpenESB can be used instead however the appearance of components shown in illustrations may vary somewhat.

I use Windows to develop these solutions and make no effort to verify that the solutions will run on other platforms.

The complete walkthrough is here.

preload preload preload