Another Story ...

Heraldry (1/4) : The origins

2024-10-09T14:54:00.000-07:00

Did you know the real origin of the coat of arms? There have been a lot of misconception about it. The picture just above is the Plantagenet enamel, considered as the oldest known coat of arms.

It is in the 12th century that a new emblem appeared in Europe that profoundly transformed the symbolic uses of medieval society: the coat of arms. The coat of arms, through the code that constitutes its grammar: the blazon, has influenced our value systems linked to identity, kinship and belonging to a group or a community in general.

So we are talking about emblems and symbols here. So what is the difference between an emblem and a symbol?

An emblem is a sign that indicates the identity of an individual or a group of individuals: the name, the uniform, the iconographic attribute, and the coat of arms are emblems.

A symbol, on the other hand, has as its signifier not a physical person, but an abstract entity, an idea, a notion, a concept. Time for example, love, justice, death are symbols. Sometimes, certain figures, certain colors, certain objects are both emblems and symbols. The blue, white, red flag is both the emblem of France, but also the symbol of a certain idea of the republic, democracy and freedoms.

Coats of arms are therefore emblems, even if they themselves often use symbols (for example, the use of the color red or golden yellow or an eagle or a wild animal can evoke power). The coat of arms as such symbolizes descent or a family alliance, land ownership, or even a profession.

What is the origin of heraldic art?

In the Middle Ages, a herald was a minor domestic officer in the service of a prince or nobleman whose mission was to carry messages, declare war or announce tournaments. Over time, the herald specialized in this activity, a bit like our modern sports reporters. To do this, he had to deepen his knowledge of coats of arms and the associated language to describe blazons.

But how did coats of arms and blazons initially appear? Greek vases sometimes show warriors with circular shields decorated with animal or plant figures that look a bit like coats of arms. In fact, neither the Greeks nor the Romans used coats of arms, because the same colours and figures were found from one group of individuals to another and did not sanction a particular belonging to a family, a deme or a city.

Another origin often heard is that the coat of arms comes from a Byzantine or Muslim loan following the Crusades. This is false, since the adoption of heraldic art in the countries of the Middle East is much later than its appearance in Western Europe.

The origin of coats of arms is linked to two phenomena: the transformation of feudal society around the year 1000, as well as the evolution of military equipment at that time.

In the 11th century, most fighters were covered with chainmail with a hood and a nasal helmet that made them unrecognizable by friends or foes. They therefore took the habit of painting geometric, animal and floral figures on their large shields, which served as a sign of recognition in the heart of the fray. It should also be noted that shields were generally reinforced with more or less wide metal plates, and sometimes even fur in order to cushion the blows of swords, lances or axes. We will see that all this will have an effect on the design and appearance of coats of arms.

Coats of arms are therefore initially a way for a group of warriors to identify themselves as belonging to a noble family, a fief, or even a suzerain. These coats of arms will be found not only on the shields of the fighters, but also on the armor and crest of the knight, the caparison of their steed, the banners, as well as the seals that seal official documents, and finally for principalities and kingdoms: on coins.

But this is another story ...

To know more (in French): Michel Pastoureau, L'Art héraldique au Moyen Âge, Seuil, 2018.

The French HealthCare Ecosystem in five infographics

2019-02-28T05:23:00.000-08:00

The new National French PHR (Dossier Médical Partagé) – How does it work? - Part 2

2019-01-28T07:17:00.003-08:00

In my preview post, I was describing how to create a record into the new National French PHR (Dossier Médical Partagé).
In this article, I will explore the content of the DMP and discuss the potential challenges of adding new data to it.

First I log with my credentials (login and password) and provide a 2 factor authentication 6 digits number sent to me either by email of SMS.

My DMP contains several tabs:

RÉCAPITULATIF (summary)
DOCUMENTS (documents)
MES INFORMATIONS (my informations)
GESTION DU DMP (record management)
HISTORIQUE DES ACCÈS (Access log)

Let's start by trying to add manually a document. For this, I have two options:

Typing a document
Adding a file

Writing a document:

Adding a file:

Coming back to the main documents tab, we can see that it can potentially contain various types of healthcare related documents:

Synthèses (syntheses)

Traitements et soins (treatments and care)

Compte-rendus (reports)

Imagerie médicale (medical imagerie)

Biologie (biology / Lab results)

Prévention (prevention)

This page has a search section:

The document section itself can be expanded according to very precise documents sub-types:

Synthèses (syntheses)

Synthèse (synthesis)
Synthèse d'épisode de soins (summary episode of care)

Traitements et soins (treatments and care)

CR ou fiche de suivi de soins par auxiliaire médical (report or medical assistant care follow-up card)
Dispensation médicamenteuse (Drug dispensing)
Dispensation autre (Dispensation other)
Plan personnalisé de soins (Personalized care plan)
Prescription de médicaments (Prescription of drugs)
Prescription de soins (Prescription of care)
Prescription autre (Prescription other)
Protocole de soins affection longue durée (ALD) (Long-term care protocol)

Comptes-rendus (reports)

CR d'accouchement (delivery report)
CR d'acte diagnostique (diagnostic act report)
CR d'acte thérapeutique (therapeutic act report)
CR d'admission (admission report)
CR d'anesthésie (reports of anesthesia)
CR de bilan d'évaluation de la perte d'autonomie (assessment report reports of loss of autonomy)
CR de bilan fonctionnel par auxiliaire médical (reports of functional assessment by medical auxiliary)
CR de consultation pré-anesthésique (pre-anesthetic consultation report)
CR de passage aux urgences (emergency room report)
CR de réunion de concertation pluridisciplinaire (tumor board report)
CR de télé-médecine (telemedicine report)
CR séjour hospitalier (report of hospital stay)
CR opératoire (surgery report)
CR ou fiche de consultation ou de visite (visit report)
Lettre de liaison à la sortie d'un établissement de soins (Liaison letter exit of a care facility)

Imagerie médicale (medical imaging)

CR d'imagerie médicale (medical imaging report)
Document encapsulant une image d'illustration non DICOM (document including a non-DICOM image)

Biologie (biology)

CR d'anatomie et de cytologie pathologiques (anatomy and pathological cytology report)
CR d'examens biologiques (biological examination report)

Prévention (Prevention)

CR d'acte diagnostique à visée préventive ou de dépistage (report of diagnostic act)
CR d'acte thérapeutique à visée préventive (Preventive action report)

Now lets looks at the type of data I have in my record. These have been pushed into my DMP by the French national health insurance (Caisse d'Assurance maladie) accessible via my account AMELI (Assurance Maladie En LIgne). Each patient in France has one unique INSEE number used for healthcare tracking (children use their parents accounts) and other administrative purpose. Supplemental coverage is also usually provided by private mutual insurers.

So far it is not clear to me whether they provide any additional information to my record.

A warning indicates that the displayed data is a reflection of information from reimbursement or support held by health insurance organizations mandatory for the last 24 months. They are provided for information purposes only and exhaustiveness can not be guaranteed, especially in the event of an administrative change during these 24 months.

There are 5 possible sections (In my case the section hospitalization is empty).

Pharmacie / fournitures (Pharmacy and various supplies - e.g. optician / glasses)
Hospitalisation (Hospitalization)
Soins médicaux et dentaires (Medical and dental care)
Radiologie (Radiology)
Biologie (Biology)

Here is how these sections look like (data has been modified/changed for obvious privacy concern).

Let's start with the Pharmacy and Medical Supplies section:

The section Medical and Dental Care includes medical care including PCP, physiotherapist, nurse, dentist, dermatologist, ophthalmologist visits:

The section Radiology includes body and dental scans:

La section Biology includes Labs data (only dates, coding act and types, not the results themselves):

To sum-up my data is well organized and easy to access. However only the payer information is available (French national insurance) which is not very different from what I could obtain directly from my AMELI account (Assurance Maladie En LIgne). There is no useful clinical information that I could share with healthcare professionals, expect perhaps if I had manually entered some of the information myself. For example, I could have added my lab results from the paper report I had received from the labs or manually added over-the-counter drugs.

In my next post I will look at other features of my DMP such a consent, trusted people and organ donation options.

The new National French PHR (Dossier Médical Partagé) – How does it work? - Part 1

2019-01-14T12:01:00.001-08:00

Since November 2018, each French patient can have access to a new national Patient Health Record (PHR) called in French the Dossier Médical Partagé or DMP (shared medical file).

How does it work from an end-user perspective? In this post, I describe my first experience with this new healthcare application - with all security and privacy precautions related to my protected health information (PHI).

I have seen several large scale initiatives starting (e.g. Microsoft HealthVault, KP/MyHealth Manager) with some initiatives including GoogleHealth who was abandoned for some time and was reborn in another form as Google Cloud for Healthcare.

I have been working in the medical data integration and processing field for many years now and even share a patent in this domain. By experience, I know that the most difficult part is not to design and create a scalable and secure structured medical repository, but to make sure that it is supplied with up-to-date and relevant data. I have a good knowledge of HL7, IHE profiles and other data integration standards and I recognize the complexity of acquiring and reconcile medical data to be used by healthcare professionals.

First, let’s start with the creation of my DMP. There are several options to create a national PHR/DMP in France. The first one is to ask a pharmacist to create it for you, the second option is to initiate the creation of the DMP yourself. This is the later I have chosen.

From the main DMP web site creation page https://www.dmp.fr/patient/creation/etape1, I was able to create my account in few minutes after providing a specific creation code generated by dmp.fr and my social security or INSEE number (the main personal ID for patients in France).

I also need to add a 11 digit number that is located on my Carte Vitale, the health insurance card of the national health care system in France.

... some contact info (email and phone):

and very important, consent:

and my account is created (credentials have been modified for obvious reasons).

Additional information is requested (e.g. address etc):

Now that my account has been created, I am able to access it using my personal credentials:

A two factor numeric ID is also sent to my cell phone (or email account) can be requested:

and used for additional security:

For the first connection, I have the option to change some of my account settings:

and some "break-the-glass" type authorization settings:

Overall the experience of creating my DMP/PHR account was quite easy and without any particular problem. It was fast and secure. The initial performance of the application seems good, having in mind that this is just the beginning and that only a small number of patients of the French population have a DMP account.

In my next post, I will explore the functionalities and the type of data that could be part of a DMP.

jBPM and BPMN 2.0 workflow creation

2015-09-25T13:26:00.003-07:00

In my previous post I was describing how to install and run jBPM console.

In this one post, I would like to describe how quickly create a workflow calling a web service.
I will be using a public weather web service based API (OpenWeatherMap) for convenience.

With this restful based API, I can easily query the current weather in a city or a zip code area:

   http://api.openweathermap.org/data/2.5/weather?q=Paris

   http://api.openweathermap.org/data/2.5/weather?zip=94404,us

I will now start by creating a new project called Meteo via the jBPM KIE console:

This will create a project where you will be able to add business processes and task forms.

Next, I am creating a business process called ObtainWeatherForecast to enter a city or zip code, call the web service and display the corresponding weather forecast:

Automatically, the Process Modelling / Shape Repository panel opens with an initial default Start Event generated.

Two side panes are quite useful to add:

On the left the Object library.
On the right side, the Properties of the BPMN diagram elements.You click on the top buttons to show the panes.

First I am going to define a set of variables that will be available in the process to maintain internal values so I can share information between nodes.
For this I click on the background of the business process and edit the Variable Definitions Properties of the ObtainWeatherForecast business process.

In the Process Modelling panel, when you select a node (event or task), you can select some very useful context icons
such as View the BPMN Node Source, create a new task or event, link nodes etc ...

When adding a new task, you have various ways to do this.

If the task is one of the 8 basic Tasks (User, Send, Receive, Manual, Service, Business Rule, Script, None),
then you can either click on the task context icon to create the next task node (as a generic/none type)
from an existing event node or a task node (1a) and specify one of the other 7 basic type if needed using the tool context icon for a more specific one (1b).

You can also use the Object library and drag/drop the task (2) and link the nodes via the link context icon (3).

If you want to add a more specific Service Task (Email, Log, REST, WS), then you can use the Object Library and select the corresponding Service Task (4).

The REST Service task has its Data Input (info associated to RESTful call) and Data Output (result from the call) properties already populated:

For the Data Assignment variables, we are going to set the Method to GET and for a quick hard-coded test,
we are going to set the url to http://api.openweathermap.org/data/2.5/weather?q=Paris
Then we are going to map the object Result of the call (use [Output Mapping]) to our process variable forecast.
Later we will be able to use the forecast JSON output and extract and display the associated information.

At this point you can add another Script Task for displaying the weather forecast result and complete the business process workflow
with a Terminate End Event, link all nodes and add useful properties such as names.

To deploy your Project and Business Process, select Build & Deploy.

After your project is successfully deployed, you select Deploy|Process Deployments.

You can then see your deployed project with the option to Deactivate it or Undeploy it.

Now you can check the Process Definitions and start ObtainWeatherForecast business process by clicking on the Start button:

After execution of the process, if you look at your Process Variables as part of the process definition, you can obtain the current weather in Paris (JSON returned object):

{"coord":{"lon":2.35,"lat":48.85},"weather":[{"id":803,"main":"Clouds","description":"broken clouds","icon":"04n"}],"base":"cmc stations","main":{"temp":287.89,"pressure":1024,"humidity":67,"temp_min":286.15,"temp_max":289.26},"wind":{"speed":2.6,"deg":20},"clouds":{"all":75},"dt":1443208502,"sys":{"type":1,"id":5615,"message":0.0054,"country":"FR","sunrise":1443159717,"sunset":1443202883},"id":2988507,"name":"Paris","cod":200}

One last tip on this first hands-on experience. If your Project Explorer goes away for some reasons (it seems there is a bug in 6.2.0 final related to this). Try to click on the reset perspective button:

First Steps with jBPM and BPMN 2.0 Modelization Tools

2015-08-07T16:46:00.000-07:00

In this post, I would like to share my initial experience with jBPM and BPMN 2.0 modelization tools in general. jBPM is an open-source workflow engine written in Java that can execute business processes described in BPMN 2.0.

Business Process Model and Notation (BPMN) is a graphical representation for specifying business processes in a business process model. As an architect, I have been using BPMN as a language for business process modeling (e.g. for the functional breakdown of complex processing pipelines for genomics systems).

They are different ways to install jBPM. The quickest installations options include:

downloading a zip file and install it on a PC or
downloading and using a docker image (particularly suitable for Mac OS)

In this post, I will describe option #1 (basic zip based install). In this case, what you obtain is a zip file - e.g. jbpm-6.2.0.Final-installer-full.zip - latest version as of 8/7/2015.

First make sure you have installed Apache Ant and it is on your Windows Path.
To install type the following command at the prompt in the jbpm-installer folder:

$ ant install.demo

After few minutes, all dependencies are fully downloaded and jBPM is installed.

You are now ready to start the web-based Knowledge Is Everything KIE workbench (there is also an Eclipse IDE plugin available with the download that you can use).

$ ant start.demo
Alternatively you can also download and start the demo without eclipse:

$ ant install.demo.noeclipse
$ ant start.demo.noeclipse

Issues deploying jbpm-console.war

if jbpm-console.war cannot be deployed in JBoss wildfly application server (former JBoss AS).
see folder: ...\jBPM\jbpm-installer\wildfly-8.1.0.Final\standalone\deployments
and check log file: ...\jBPM\jbpm-installer\wildfly-8.1.0.Final\standalone\log\server.log.
You might have encounter an issue with your proxy!!!
There are several ways to fix this, including

installing KIE outside your firewall/proxy server influence (not from our office!)
modify your file ...\jBPM\jbpm-installer\build.xml file:

                 <exec executable="${jboss.full.path.win}" spawn="yes" osfamily="windows">
                      <env key="JAVA_OPTS" value="-XX:MaxPermSize=256m -Xms256m -Xmx512m" />
                      <arg value="-b" />
                      <arg value="${jboss.bind.address}" />
                      <arg value="--server-config=standalone-full.xml" />
                      <arg value="-Dorg.kie.demo=true" />
                      <arg value="-Dorg.kie.example=false" />
                      <arg value="-Dhttp.proxyHost=...." />
                      <arg value="-Dhttp.proxyPort=8999" />
                      <arg value="c standalone-full.xml"/>

Using KIE

If successfully deployed, go to your browser (use Chrome for better experience!) and enter

http://localhost:8080/jbpm-console/kie-wb.html

You should have access to the jBPM KIE console (see also video demo here and look at jBPM6 Developer Guide).

The default user name and password are 'admin'.

To have access to the business process demos click Authoring/Project and choose async-examples.

Then Business Processes/check weather (one of the demos - this one is very simple and fun!).

This displays a very simple business process where the user can enter a zip code and obtain the weather forecast associated to the zip code in question:

Open the properties pane if not displayed by clicking the double arrow on the top right side of the application.

You can initially do a copy of the demo in case you want to make some modifications to the demo process. You will need to modify the ID and the Version of the business process and save a copy.

Enter a new name and optionally some comments for the new version of the process:

The copy should now appear in the list of business processes:

Deployment of a Process is done by opening the Project and select Build/Build & Deploy:

To run the demo process, select Process Management/Process Definitions then select your process and click on the start Action icon:

Enter the user name ('admin') and a US zip code - Here I am using 94036 (Palo Alto, CA).

Migrating Healthcare Applications to the Cloud through Containerization and Service Brokering

2015-04-02T16:29:00.002-07:00

Organizations that are building their own cloud infrastructure from scratch or rely uniquely only on an infrastructure as a service (IaaS) from a provider, risk spending valuable resources and time building a specialized platform instead of focusing on their core business. On the other hand, organizations who adopt a turnkey proprietary cloud stack will lack flexibility and may end up locked into a specific technology or vendor.

Instead of designing the cloud architecture from the bottom up or the top down, a better strategy is to design from the inside out. By starting with the platform as a service (PaaS) as the central critical layer and creating ways to use various IaaS models and offerings in generic ways, it is possible to create a flexible and efficient lifecycle for the services and applications running on the platform.

In Healthcare, PaaS technology such as the one offered by Pivotal Cloud Foundry facilitates the rapid creation and migration of existing applications towards better user engagement, increasing collaboration between care givers and improving the lives of patients, while reducing the total cost of ownership (TCO).

The main characteristics of this platform are:

Application containerization

Optimized application scaling

Application to service brokering

Abstraction of IaaS

Excellent application lifecycle management

Automatic middleware stack and operating system configuration

Advanced application monitoring

In this architecture, backing services (e.g., databases, caching systems, other data services (e.g., Amazon S3), messaging/queueing systems, SMTP services, various external APIs (Google Maps, terminology services, healthcare registry services) are just attached resources. For example, there is a distinction between a local digital imaging and communications in medicine (DICOM) local image store and a remote, 3rd party DICOM picture archiving and communication system (PACS) service hosted in the cloud.

The type of platform is especially suitable managing micro services, which allows better componentization, development and testing processes, decentralized governance, resilience and maintainability. These services, especially when they are based on a RESTful architecture, are extremely easy to build, integrate, test, extend, and maintain, and are extremely adapted for mobile applications integration.

Good and efficient lifecycle management is important to produce and maintain high quality software. This is particularly important in healthcare where the patient life is at risk or a breach of privacy could occur as a result of poor quality software.

The advantage of abstracting the IaaS layer access through a common API is that there no need to have multiple versions of application code for each deployment model. The same code will work and be monitored the same way for all cloud deployment models, including on premise and hybrid.

On top of the generic open PaaS infrastructure, we are adding generic and cross-cutting capabilities not part of the original platform including:

Identity management to allow customers, patients and consumers to be accurately and uniquely recognized by using an enterprise master patient index (eMPI) for patients and a lightweight directory access protocol (LDAP) based directory for healthcare providers and consumers.

Security/Identity Access Management: authentication, authorization, and single sign-on, all critical to secure provider, patient, and consumer applications and in certain cases, can be addressed by declarative proxification of these services.

Cloud-based, connected device management: device registration, discovery, routing, diagnostics, remote control, firmware provisioning, data collection, device-app-user pairing (we are currently supporting 6 million active consumer devices).

Open cloud based clinical workflow collaboration capabilities.
Secure cloud-based big data store and analytics capability (e.g., to store patient’s observations and genomic data.

We are also creating and exposing healthcare and wellness related services that applications can consume:

IHE-based demographic, clinical, providers web services (e.g., PIX/PDQ, XDS, HPD)

A virtual longitudinal healthcare record (VHR) and associated services
- ATNA-based auditing services
- Consent and delegation services

Our HealthSuite Digital platform also offers high availability, scalability, privacy and security compliance with regulations (e.g., HIPAA, HITECH) and standards (e.g., NIST SP800-53, ISO 27001) using multitenancy, redundancy, 24/7 monitoring and operations, and disaster recovery.

More on: F. Andry, R. Ridolfo, J. Huffman, Migrating Healthcare Applications to the Cloud through Containerization and Service Brokering, 8th International Conference on Health Informatics (HealthINF 2015), pp. 164-171, Lisbon, Portugal, January 2015.

Java Code Refactoring

2013-06-06T16:58:00.000-07:00

I recently browsed again the excellent book Code Complete from Steve McConnell while in the middle of several Java code reviews. Although the book is nor specifically dedicated to Java code, I still found it quite useful and inspiring.

The chapter on refactoring in particular offers a very practical perspective that all programmer should have in mind when it comes to infuse a dose of evolution in the life cycle of their software.

What I found particularly valuable are the checklists that the author has put together: reasons to refactor, specific re-factorings (data level, statement level, routine-level, class-implementation, class-interface, system-level), refactoring safely, strategies, summary.

In this post, I would like to illustrate some of these refactoring techniques with java code snippets.

Since I do not have time to comment every item in these checklists, I decided to pick-up those that are not trivial or obvious and might bring the best return on your refactoring investment. These items are high-lighted in green and developed in sections at the end of this article.

If you think that missing items are worth explaining, please add a comment to this post and I will be glad to add a specific paragraph for those as well.

Checklist: Reasons to Refactor

Code is duplicate
A routine is too long
A loop is too long or too deeply nested
A class/interface/method has poor cohesion ⇐
A class interface does not provide a consistent level of abstraction ⇐
A parameter list has too many parameters ⇐
Changes within a class tend to be compartmentalized
Changes require parallel modifications to multiple classes ⇐
Inheritance hierarchies have to be modified in parallel
Related data items that are used together are not organized into classes ⇐
A routine uses more features of another class than of its own class
A primitive data type is overloaded
A class doesn't do very much
A chain of routines passes tramp data ⇐
A middle man object isn't doing anything
One class is overly intimate with another
A routine has a poor name
Data members are public
A subclass uses only a small percentage of its parents' routines
Comments are used to explain difficult code
Global variables are used
A routine uses setup code before a routine call or takedown code after a routine call
A program contains code that seems like it might be needed someday

Checklist: Summary of Refactorings

Data Level Refactoring

Replace a magic number with a named constant ⇐
Rename a variable with a clearer or more informative name
Move an expression inline
Replace an expression with a routine
Introduce an intermediate variable
Convert a multi-use variable to a multiple single-use variables ⇐
Use a local variable for local purposes rather than a parameter
Convert a data primitive to a class
Convert a set of type codes to a class
Convert a set of type codes to a class with subclasses
Change an array to an object
Encapsulate a collection ⇐
Replace a traditional record with a data class

Statement Level Refactorings

Decompose a boolean expression
Move a complex boolean expression into a well-named boolean function
Consolidate fragments that are duplicated within different parts of a conditional
Use break or return instead of a loop control variable
Return as soon as you know the answer instead of assigning a return value within nested if-then-else statements
Replace conditionals with polymorphism (especially repeated case statements) ⇐
Create and use null objects instead of testing for null values

Routine Level Refactorings

Extract a routine
Move a routine's code inline
Convert a long routine to a class
Substitute a simple algorithm for a complex algorithm
Add a parameter
Remove a parameter
Separate query operations from modification operations
Combine similar routines by parameterizing them
Separate routines whose behavior depends on parameters passed in ⇐
Pass a whole object rather than specific fields
Pass specific fields rather than a whole object
Encapsulate downcasting ⇐

Class Implementation Refactorings

Change value objects to reference objects
Change reference objects to value objects
Replace virtual routines with data initialization
Change member routine or data placement
Extract specialized code into a subclass ⇐
Combine similar code into a superclass

Class Interface Refactorings

Move a routine to another class
Convert one class to two
Eliminate a class
Hide a delegate ⇐
Replace inheritance with delegation
Replace delegation with inheritance
Remove a middle man ⇐
Introduce a foreign routine
Introduce a class extension
Encapsulate an exposed member variable
Remove Set() routines for fields that cannot be changed
Hide routines that are not intended to be used outside the class
Encapsulate unused routines ⇐
Collapse a superclass and subclass if their implementations are very similar

System Level Refactorings

Duplicate data you can't control ⇐
Change unidirectional class association to bidirectional class association
Change bidirectional class association to unidirectional class association
Provide a factory routine rather than a simple constructor
Replace error codes with exceptions or vice versa

Selected items refactoring samples in java

A class/interface/method has poor cohesion

A class, interface or method should be only responsible for a precise and meaningful set of functionality and behavior. For example,the interface KitchenAppliance below lacks cohesion. A generic kitchen appliance should not allow to wash both clothes and dishes.

public interface KitchenAppliance {
 public float waterConsumption = 0;
 public float energyConsumption = 0;
 void washClothes();
 void washDishes();
}

⇒

public interface WashingKitchenAppliance {
 public float waterConsumption = 0;
 public float energyConsumption = 0;
 void wash();
}

A class interface does not provide a consistent level of abstraction

In Java, a consistent level of abstraction is usually obtained when the objects that represent abstract actors perform work, report on, change their state and communicate with other java objects in a a compatible and comparable way.
The use of inheritance, encapsulation and polymorphism is usually the key to a consistent level of abstraction and is at the core of good design patterns. In the example below, an intermediary level of abstraction, e.g. DairyAnimal (cows, goats) and MeatAnimal (pigs, steers), could be created to avoid specifying the type of food for each animal and focus on more specific features for the sub-classes.

public class Animal extends LivingThing
{
 private Location loc;
 private double energyReserves;

 public boolean isHungry() {
  return energyReserves < 2.5;
 }
 public void eat(Food food) {
  energyReserves += food.getCalories();
 }
 public void moveTo(Location location) {
  this.loc = location;
 }
}

thePig = new Animal();
theCow = new Animal();
if (thePig.isHungry()) {
    thePig.eat(tableScraps);
}
if (theCow.isHungry()) {
    theCow.eat(grass);
}
theCow.moveTo(theBarn);

⇒

public class DairyAnimal extends Animal {
 private Double milkProduction;

 public Double getMilkProduction() {
  return milkProduction;
 }
        ...
}

A parameter list has too many parameters

Methods with too many parameters is an indication that the code has either been badly designed initially (lack of abstraction) or has evolved over the months or years without proper refactoring. One elegant solution for creational methods/constructor requiring a large number of parameters is to use a builder pattern well define in Joshua Bloch's Effective Java and offers a way to use optional parameters:

public NutritionFacts(int servingSize, int servings, int sodium, int iron, int fat, int carbs) {
     this.servingSize = servingSize;
     this.sodium = sodium;
     this.servingSize = servingSize;
     this.iron = iron;
     this.fat = fat;
     this.carbs = carbs;
}

NutritionFacts soda = new NutritionFacts(240, 8, 35, 13, 0, 27);

⇒

public class NutritionFacts {
 private int servingSize = 0;
 private int servings  = 0;
 private int sodium  = 0;
 private int iron  = 0;
 private int fat  = 0;
 private int carbs  = 0;

 public static class Builder {
  private int servingSize;
  private int servings;
  private int sodium;
  private int iron;
  private int fat;
  private int carbs;

  public Builder(int servingSize, int servings) {
   this.servingSize = servingSize;
   this.servings = servings;
  }
  
  public Builder sodium(int val) {
   this.sodium = val;
   return this;
  }
  
  public Builder iron(int val) {
   this.iron = val;
   return this;
  }

  public Builder fat(int val) {
   this.fat = val;
   return this;
  }

  public Builder carbs(int val) {
   this.carbs = val;
   return this;
  }
  
  public NutritionFacts build() {
   return new NutritionFacts(this);
  }
 }
 
 private NutritionFacts(Builder builder) {
  servingSize = builder.servingSize;
  servings = builder.servings;
  sodium = builder.sodium;
  iron = builder.iron;
  fat = builder.fat;
  carbs = builder.carbs;
 }
}

NutritionFacts soda = new NutritionFacts(240, 8).build();
or
NutritionFacts soda = new NutritionFacts(240, 8).sodium(35).iron(13).fat(0).carbs(27).build();
or
NutritionFacts soda = new NutritionFacts(240, 8).sodium(35).iron(13).carbs(27).build();

Changes require parallel modifications to multiple classes

If you regularly have to modify the same set of classes then try to refactor these classes with the correct level of abstraction and factorization so changes only affect one class.

Related data items that are used together are not organized into classes

Recurrent set of operations can be combined in its own class:

theCow = new DairyAnimal();
theCow.brush();
theCow.feed();
theCow.milk();
theCow.feed();

⇒

public class DairyAnimalOperation {
 public void tend(DairyAnimal dairyAnimal) {
  dairyAnimal.brush();
  dairyAnimal.feed();
  dairyAnimal.milk();
  dairyAnimal.feed();
};

A chain of routines passes tramp data

"Tramp data" refers to passing data to one method so it can be passed to another one (Page-Jones 1988). This can be solved by introducing a better level of abstraction in the interfaces in question

Replace a magic number with a named constant

The word magic refers to the use of numeric or string literal. Use constants or Enums instead.

public double areaOfCircle (double radius)  {  
    return Math.pow(radius * 3.14159, 2);  
}

⇒

private static final double PI = 3.14159;

public double areaOfCircle (double radius)  {  
    return Math.pow(radius * PI, 2);  
}

Convert a multi-use variable to a multiple single-use variables

Common offenders are variable names like i,j, temp. These need to be replaced by specific names (e.g. row, column).

for (int i=0;i&tl;N;i++) {
    for (int j=0;j&tl;M;j++) {
       matrix[i][j] = 0; 
    }
}

⇒

for (int row=0;row&tl;numRows;row++) {
    for (int colum=0;colum&tl;numColumns;colum++) {
        matrix[row][colum] = 0; 
    }
}

Encapsulate a collection

Instead of returning the collection itself, encapsulate a read-only collection instance with specific methods to add or remove elements in the original collection. You can leverage unmodifiable view methods that are part of the collection class for this:

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
public static <T> List<T> unmodifiableList(List<? extends T> list)
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)

Replace conditionals with polymorphism

With polymorphism, subclasses of a class possesses their own specific behaviors and share also some of the functionality of their parent class. Refactor conditionals, especially complex case statements with polymorphism design:

Bike myBike = new Bike();
String bikeType = "default";
witch(myBike.getTireWidth()) {
 case 23 : 
  if (myBike.getSuspension().compareToIgnoreCase("Simple") == 0) {
   bikeType = "Road bike";
  }
 break;
 default : 
  if (myBike.getSuspension().compareToIgnoreCase("Dual") == 0) {
   bikeType = "Mountain bike";
  }
 break;
}

⇒

public class MountainBike extends Bicycle {
    private String suspension;

    public MountainBike(
               int startCadence,
               int startSpeed,
               int startGear,
               String suspensionType){
        super(startCadence,
              startSpeed,
              startGear);
        this.setSuspension(suspensionType);
    }

    public String getSuspension(){
      return this.suspension;
    }

    public void setSuspension(String suspensionType) {
        this.suspension = suspensionType;
    }
} 

public class RoadBike extends Bicycle{
    private int tireWidth;

    public RoadBike(int startCadence,
                    int startSpeed,
                    int startGear,
                    int newTireWidth){
        super(startCadence,
              startSpeed,
              startGear);
        this.setTireWidth(newTireWidth);
    }

    public int getTireWidth(){
      return this.tireWidth;
    }

    public void setTireWidth(int newTireWidth){
        this.tireWidth = newTireWidth;
    }
}

Separate routines whose behavior depends on parameters passed in

If you have a method which executes different statements based on a particular parameter value, figure out if you can break the method into separate ones without passing the parameter in question.

Encapsulate downcasting

Objects returned by a method should use the most specific type possible.

public class A {
 public String doSomething() {
  return "Do something.";
 }
}

public class B extends A {
 public String doSomethingMoreSpecific() {
  return "Do something more specific.";
 }
}

public class DownCast {

 private List<A> list;
 
 public List<A> getList() {
  return list;
 }


 public List<B> getMostSpecificList() {
  return (List<B>) (List<?>) list;
 }

  
 public void setList(List<A> list) {
  this.list = list;
 }

 public DownCast() {
  list = new ArrayList<A>();
  for (int i=0;i<10;i++) {
   list.add(new B());
  }
 }

}

public static void main(String[] args) {
  
 DownCast obj = new DownCast();
 List<A> listOfA = obj.getList();
 System.out.println(listOfA.get(0).doSomething());
   
 List<B> listOfB = obj.getMostSpecificList();
 System.out.println(listOfB.get(0).doSomethingMoreSpecific());
    
}

Extract specialized code into a subclass

Refactor specialized code into specific own subclasses if the code in question is only used in a subset of initial classes.

Hide a delegate

If Class A calls B then C while A was supposed to only call B and B calls C, then dissociates C from A and have B calls C only.

Remove a middle man

On the other hand, if you think that A should call C directly as long as the role of B is still clearly defines, does not have overlap with C and can be used independently of C.

Encapsulate unused methods

Create new interfaces for the most common used set of methods

public class Bird {
 
 private String species;
 private String eggColor;
 private String food;
 private int flySpeed;
 private int flyHeight;
 private String dragType;
 private String wingType;
 
 public String getSpecies() {
  return species;
 }
 public void setSpecies(String species) {
  this.species = species;
 }
 public String getEggColor() {
  return eggColor;
 }
 public void setEggColor(String eggColor) {
  this.eggColor = eggColor;
 }
 public String getFood() {
  return food;
 }
 public void setFood(String food) {
  this.food = food;
 }
 public int getFlySpeed() {
  return flySpeed;
 }
 public void setFlySpeed(int flySpeed) {
  this.flySpeed = flySpeed;
 }
        ...
}

⇒

public interface BirdFlight {
 public int getFlySpeed();
 public void setFlySpeed(int flySpeed);
 public int getFlyHeight();
 public void setFlyHeight(int flyHeight);
 public String getDragType();
 public void setDragType(String dragType);
 public String getWingType() ;
 public void setWingType(String wingType);
}

public class Bird implements BirdFlight {
 
 private String species;
 private String eggColor;
 private String food;
 
 public String getSpecies() {
  return species;
 }
 public void setSpecies(String species) {
  this.species = species;
 }
 public String getEggColor() {
  return eggColor;
 }
 public void setEggColor(String eggColor) {
  this.eggColor = eggColor;
 }
 public String getFood() {
  return food;
 }
 public void setFood(String food) {
  this.food = food;
 }
 
 @Override
 public int getFlySpeed() {
  ...
 }
 @Override
 public void setFlySpeed(int flySpeed) {
  ...
 }
 @Override
 public int getFlyHeight() {
  ...
 }
 @Override
 public void setFlyHeight(int flyHeight) {
  ...
 }
 ...
  
}

Duplicate data you can't control

As long as layering principles are not violated, wrap or access data maintain by the system via a consistent way/interface/API. A typical examples is data shares in GUI control in the front-end layer. Try to find a way to copy/mirror the data in question and treat it as reference source of data.

Advanced UML Sequence Diagrams

2013-05-17T15:04:00.000-07:00

A Sequence Diagram is a type of UML Interaction Diagram that is used to model objects that need to pass messages to accomplish a task.

The messages are usually defined in the order of the execution.

Objects interactions can include:

creation and termination
requests
invoke object operations
notifications

In the very simple sequence diagram below, a user sends a query to a health IT application that retrieve a clinical document to an XDS Repository. The clinical data is returned back to the user (an actor in this type of diagram).

Object colors can indicates a different scope between objects (e.g gray here indicate a component that is part of a different sub-system, or out-of-scope for the current document or release etc).

Lifelines are vertical dashed lines with the object positioned at the top.

Messages are horizontal lines with arrows pointing in the direction in which the message is sent with annotation (method, parameters, arguments, return value, type of control flow etc ...)

UML 2.0 has two forms of messages:

operation call : the invocation of an operation of a receiving object (either synchronous or asynchronous)
signal : a message object sen out by one object and handle by another one (always asynchronous)

Synchronous messages usually have solid arrows (by the way, in the tool I use, return synchronous messages for not have a solid arrow). Asynchronous message use dashed arrows.

An interaction operand is a container that groups the interaction fragments and uses an optional guard expression or interaction constraint. When the guard condition is not present, the interaction is always executed.

Interaction operators include:

Alternative (alt)
Option (opt) :
Break (break) :
Parallel (par)
Loop (loop)
Critical (critical) or (region)
Negative (neg)
Assertion (assert)
Strict Sequence (strict)
Weak Sequence (seq)
Ignore (ignore)
Consider (consider)

Lets consider a simple alternative (alt) operand.

Imagine that in the initial sequence diagram, that we want to request a document, we request a clinical document from an external source (CCD producer system).

In this case, the first thing is to add a combined fragment on top of the existing diagram, and choose the alt type:

Then conditions are added (if and else equivalent):

Then you can add the new alternative message (to the external CCD producer system) and re-organize the layout of the diagram : placing the combined fragment below the incoming message and moving the else clause separation (dotted line) below the first alternative (accessing the XDS repository). In my tool, you can use ALT-Left-Mouse click for this:

There are numerous UML modeling tools available (commercial or free). For his post, I used Enterprise Architect.

Richfaces Ajax CDI Push and JBoss

2013-03-28T09:25:00.001-07:00

You may not know it, but when you go to a restaurant, you most likely to be served via a method called service à la russe (service in the Russian Style). This is in contradiction to the much older traditional service à la française (service in the French Style).

In the original French Style, all the food was brought from the kitchen into the dining room of the aristocrats or high clergy and served all at once. Then the cooks who lost their jobs during the French revolution, end-up opening places call restaurants to make a living when common people could come to eat and relax (from the verb se restaurer in French), meaning "to restore itself".

French serving style remains in some high class restaurants where small tables or guéridons are moved close to the guest's table where the food preparation is completed and served.

The buffet is a variation of the French Style where the guests help themselves from the table (in French it is traditionally a piece of furniture that looks like a table with drawers called in fact buffet).

On the other hand, the Russian Style that comes from Russia was introduced in the French restaurants during the 19th century where courses are brought to the table sequentially by the waiter. This is now the style in which most modern western restaurants serve food (with some significant modifications).

The place setting (called a cover) for each guest includes a service plate, all the necessary cutlery except those required for dessert, and stemmed glasses for water, wines and champagne.

Guests immediately remove their napkins and place them in their laps.

The rule is as such: a filled plate is always replaced with an empty one, and no place goes without a plate until just before the dessert course.

Directly before dessert everything is removed from the place settings but the wine and water glasses. Crumbs are cleared and dessert is served.

As you can see, both styles have very precise rules and mechanisms that must be followed to ensure the best service.

Richfaces itself offers several Ajax server-side push mechanisms to bring data from the server to the client.

Interesting to point-out by the way, that a waiter in french is called "un serveur" (someone who serves) and that the same word is used to design a server in computer science.

These three Ajax Push methods are:

TopicsContext - accesses a RichFaces message queue directly
Push CDI - uses the CDI Event mechanism to fire messages
Push JMS - the RichFaces Push consumes messages from an enterprise messaging system and exposes them to the client (tightly coupled with the JMS runtime)

In a previous article I was explaining how RichFaces Extended Data Tables can be enhanced.

In this article, I will describe how Richfaces Ajax Push CDI can be implemented and deployed specifically on a JBoss container (I am using JBoss application server 7.0)

The Richfaces showcase describes well as usual the java and JSF code needed to implements the CDI Ajax Push. One thing though, the Push JMS mechanism in not explicated in the show case, but described in the chapter 3 of the documentation.

First what does CDI means?

If you look at your project facets (I am using Eclipse IDE), you will see that CDI stands for Context and Dependency Injection.

Container/Context Dependency Injection in Java EE 6 decouples the processing threads of event producers and event consumers by using the Observer pattern in the form of event broadcasting.

An event in CDI is just a regular POJO that can be fired by any class through the use of the Event implementation injected automatically by the container via the @Inject annotation.

 

import java.io.Serializable;

import javax.enterprise.context.RequestScoped;
import javax.enterprise.event.Event;

import javax.inject.Inject;
import javax.inject.Named;

import org.richfaces.cdi.push.Push;

@Named
@RequestScoped
public class PushCdiBean implements Serializable {

 private static final long serialVersionUID = 6414191802542861042L;
 public static final String PUSH_CDI_TOPIC = "pushCdi";
 private String message = "";

 @Inject
 @Push(topic = PUSH_CDI_TOPIC)
 Event<string>pushEvent;
 
 
 public void sendMessage() throws Exception {
  if (pushEvent == null) {
  } else {
   pushEvent.fire(message);
  }
  message = "";
 }

 public String getMessage() {
  return message;
 }

 public void setMessage(String message) {
  this.message = message;
 }
}

If you download the source code of the Richfaces showcase (I am using richfaces-4.3.1.Final), you will see that the readme file located under .\richfaces-4.3.1.Final\examples\richfaces-showcase describes useful steps necessary to deploy the sample application on various containers, including JBoss.

First, you need your Maven pom file to have both the Java API CDI and the atmosphere dependencies:

<dependency>
 <groupId>javax.enterprise</groupId>
 <artifactId>cdi-api</artifactId>
 <version>1.1-20130222</version> 
</dependency>
<dependency>
 <groupId>org.atmosphere</groupId>
        <artifactId>atmosphere-runtime</artifactId>
        <version>1.0.10</version>
</dependency>

To be able to inject your CDI bean, your WEB-INF folder needs to contain a bean.xml file:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:weld="http://jboss.org/schema/weld/beans" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://docs.jboss.org/cdi/beans_1_0.xsd http://jboss.org/schema/weld/beans http://jboss.org/schema/weld/beans_1_1.xsd"> </beans>

On your deployment platform, you need JBoss standalone configuration located in .\standalone\configuration\standalone-full.xml to have a JMS topic that match your Push CDI topic:


<jms-destinations>
 <jms-queue name="testQueue">       
  <entry name="queue/test"/>  
  <entry name="java:jboss/exported/jms/queue/test"/>
        </jms-queue>  
 <jms-topic name="pushCdi">
         <entry name="topic/pushCdi"/>  
 </jms-topic>     
</jms-destinations>

You also need to start the JBoss server in full configuration:

Another necessary step is to create the JMS user account/password:

From there, you should be able to test your Ajax CDI push application. In my case, the consumer is a popup window that I launch by clicking a button (see code below):

Producer code:

<ui:define name="body">
 <h:form id ="from">
  <a4j:commandButton value="Message Consumer"
   oncomplete="#{rich:component('cdi_message_consumer_popup')}.show();" />
  <h:panelGrid columns="4">
   <h:outputLabel value="Message:" />
   <h:inputText id="messageInput" value="#{pushCdiBean.message}"/>
   <a4j:commandButton value="Send" 
    action="#{pushCdiBean.sendMessage}"
    execute="@form" 
    render="messageInput" 
    oncomplete="#{rich:element('messageInput')}.value=''"/>
  </h:panelGrid>
 </h:form>
 <ui:include src="rf_ajax_push_consumer_popup.xhtml" />
</ui:define>

Consumer code:

<rich:popupPanel 
 id="cdi_message_consumer_popup" 
 modal="false"
 resizeable="false" top="100" 
 left="300" 
 autosized="true"
 domElementAttachment="parent">
 <f:facet name="header">
  <h:outputText value="Ajax Push/CDI Message Consumer    " />
 </f:facet>
 <f:facet name="controls">
  <h:outputLink value="#"
   onclick="#{rich:component('cdi_message_consumer_popup')}.hide(); return false;">
   <h:outputText value="X" styleClass="textHeader" />
  </h:outputLink>
 </f:facet>
 <h:form>
  <h:panelGrid columns="3">
   <a4j:push address="pushCdi" 
    onerror="alert('error: ' + event.rf.data)"
    ondataavailable="jQuery('<li />').prependTo('#messages').text(event.rf.data)">
   </a4j:push>
   <ul id="messages" />
  </h:panelGrid>
 </h:form>
</rich:popupPanel>

The message (simple string) is send to the server and pushed back to the browser. The original message is then cleaned:

A big thank to my colleague Asha Ambikavijayakumaran for figuring out all the tricky details for the JBoss deployment for this Richfaces showcase!

All ingredients and open source code related to this recipe can be found at YummyCode on the JSF Plate project.

Advanced RichFaces Extended Data Tables

2013-02-09T09:53:00.001-08:00

With Mardi Gras and Carnival around the corner, this is crêpe season!

This post is the first of a set of recipes that describe useful tips and reusable code and patterns related to Java, JSF 2.0 and RichFaces 4.0. In this article I am describing practical integration code when using advanced Richfaces Extended Data Tables.

The RichFaces showcase describes well how to start creating your own extendedDataTable. However, here are some additional personal ingredients that can be very handy when preparing an appealing stack of JSF based web pages.

1) Setting your Table

The first time your try to put together a RichFaces extendedDataTable, you might encounter the following behavior: your table does not look like as you expected it: columns have a default size (the length of the label) and the whole size is the size of your whole window, so you end up with a large white space where they are no columns:

One reason could be that no column or table size has been specified:


 <rich:extendedDataTable id="table" value="#{countries.countryItems} var="country" >
    <f:facet name="header">
        <h:outputText value="Countries" />
    </f:facet>
    <rich:column>
        <f:facet name="header">
            <h:outputText value="Name" />
        </f:facet>
        <h:outputText value="#{country.name}" />
    </rich:column>
    <rich:column>
        <f:facet name="header">
            <h:outputText value="Capital" />
        </f:facet>
        <h:outputText value="#{country.capital}" />
    </rich:column>
    <rich:column>
        <f:facet name="header">
            <h:outputText value="Language(s)" />
        </f:facet>
        <h:outputText value="#{country.languages}" />
    </rich:column>
</rich:extendedDataTable>

One way to quickly fix this is to assign specific sizes to your columns and headers (in my case these are absolute values in pixels and have adjusted the values to take into account the height of a row and the presence of a vertical scroller). I have also added single selection mode so I can click on a row to retrieve more information about a certain item:


<rich:extendedDataTable id="table" value="#{countries.countryItems}"
    var="country" selection="#{countries.selection}" 
    style="height:190px; width:503px;"
    selectionMode="single">
    <a4j:ajax execute="@form" event="selectionchange" listener="#{countries.selectionListener}"/>
        <f:facet name="header">
            <h:outputText value="Countries" />
        </f:facet>
        <rich:column width="100px">
            <f:facet name="header">
                <h:outputText value="Name" />
            </f:facet>
            <h:outputText value="#{country.name}" />
        </rich:column>
        <rich:column width="100px">
            <f:facet name="header">
                 <h:outputText value="Capital" />
            </f:facet>
            <h:outputText value="#{country.capital}" />
        </rich:column>
        <rich:column width="300px">
            <f:facet name="header">
                <h:outputText value="Language(s)" />
            </f:facet>
            <h:outputText value="#{country.languages}" />
        </rich:column>
</rich:extendedDataTable>

2) Interaction improvements

Let say now that you want to add a button to load or refresh the information in the table and that this takes some time because you are connected to a remote service. You may want to show to the end-user an indicator that some processing or data retrieval is happening (for this example, I added a waiting function in the iem list bean to simulate a few seconds wait).

I propose to use an animated GIF and take advantage of the RichFaces a4j:status (an indicator of an Ajax request. It has two states: start and stop. The start state indicates that an Ajax request is in progress. When an Ajax response is returned, the component switches to the stop state).

In this case, I refer to a4j:status every time I click on the refresh button to download the countries statistics. I have also added an animated GIF file called processing.gif in my webapp/img folder and top aligned both the button and the ajax indicator into a JSF panel grid:


<h:panelGroup>
    <h:panelGrid columns="2" columnClasses="alignTop, alignTop">
        <a4j:commandButton value="Refresh" status="refreshTable"
     oncomplete="#{countries.refresh()}" />
        <a4j:status name="someProcessing">
            <f:facet name="start">
         <h:graphicImage value="/img/processing.gif" />
     </f:facet>
        </a4j:status>
    </h:panelGrid>
</h:panelGroup>

As a result, the processing indicator appears next to the button when it is clicked and disappear after the table has been refreshed.

In fact, you can use the same indicator when selecting a row to display detailed information about an item if the retrieval of the additional information takes too long for the user (e.g. more than a couple of seconds):

<a4j:ajax execute="@form" event="selectionchange" status="someProcessing" listener="#{countries.selectionListener}" />

3) Adding some coloring and flavor

If you don't have a predefine look and feel (e.g. a reusable template or UI toolkit), you can easily use the themes and skins that come with RichFaces. A skin can be quickly added to the web.xml file as follow:

<context-param>
    <param-name>org.richfaces.skin</param-name>
    <param-value>wine</param-value>
</context-param>

Some of my favorites predefined skins are deepMarine and wine:

4) The missing ingredients

Even though the RichFaces Extended Data Tables have a lot of features such as filtering, sorting, scrolling, frozen columns, here are always missing ingredients that you would like to use to offer a better experience to the end user. One that you will not find in the ExtendedDataTable is the wrapping of text in a column or a robust column horizontal scrolling. Hopefully this feature will be added in future release.

5) Always give a tip if you can

Offering tips is generally a good practice. It makes feel everybody happy: the person who provides it knowing that he/she has done a good job, and the end-user who enjoys it and saves time using them.

In this example, I have added a column to to indicate which countries have a GDP above one Trillion US Dollars. When the use hovers the mouse above the checkbox or the name of the country, a tooltip appears and shows the GDP number for the selected country.

Tooltips can be easily added as follow:

<rich:column styleClass="#{msg.status}" width="35px">
    <f:facet name="header">
        <h:outputText value="GDP > $1T" />
    </f:facet>
    <rich:tooltip mode="client" target="largeGDPCountry">
        <h:outputText value="#{country.name} - 2011 GDP: #{country.gdp} > $1T" />
    </rich:tooltip>
    <h:graphicImage id="largeGDPCountry" value="/img/checkmark.png" rendered="#{country.largeGdp}" alt="GDP" />
</rich:column>
<rich:column width="100px">
    <f:facet name="header">
        <h:outputText value="Name" />
    </f:facet>
    <h:outputText id="countryName" value="#{country.name}" />
    <rich:tooltip mode="client" target="countryName">
        <h:outputText value="#{country.name} - 2011 GDP: #{country.gdp} $M" />
    </rich:tooltip>
</rich:column>

Ingredients and open source code related to this recipe can be found at YummyCode on the JSF Plate project.

Multitenancy and Healthcare Software Applications

2012-09-28T09:34:00.001-07:00

Virtualization abstracts the running stack and components in order to have services users to appear to run on a separate physical machine has been an earlier attempt to lower the cost of resources. In fact, virtualization has brought tremendous progresses in heath care for the development, testing and running applications during the past 10 years or so. However multitenancy goes one step further.

Multitenancy is at the core of the design of Web based applications offered as Software as a Service (SaaS). In a multitenant software application, the service offered to each client organization (e.g. in healthcare that would be a physician office, a lab, a clinic ...) is virtually partitioned. Data and configuration are separate for each organization that use the service. This is required to ensure the confidentiality of the patient records.

In a multitenancy architecture, the same set of hardware, network resources, software stack, application code base are shared between all users of the service. As a result, SaaS applications are managed and delivered more efficiently at a lower cost.

Here is a subset of the services management tasks that can be greatly simplified by a multitenancy architecture :

patch deployments
GUI, API and platform/stack upgrades
data migration
customizations
customer support
monitoring
reporting

The amount of resource: hardware, network and IT staff, dedicated to a specific application is drastically reduced from a model where every organization has its own instance. In addition to this, multitenancy tends to benefit the whole user set of a particular service, since defects fixes and new features are deployed incrementally very frequently. Agile development process methodologies such as Scrum are particularly suitable for this technology since development and deployment cycles can be extremely short.

This can be critical in healthcare when several organizations such as hospitals, labs and pharmacies using the same service, need to exchange data across an Health Information Exchange or a Regional Health Information Organization). In this case, all end-points of the HIE have to use the same data format , the same protocols and security scheme. Is parts or all of the end-points are running in a multitenant architecture, then the orchestration of all end-points is facilitated greatly. For example, every time a new service functionality is deployed available, all end-points have access to it and are compatible. Moreover, maintenance such are the provisioning and re-provisioning of user credentials and security certificates is simplified. Finally monitoring and reporting such as meaningful use are much easier to implement and deploy.

The unified architecture and deployment topology (for development, QA testing, staging and production), makes the application cheaper to develop, deploy and maintain. In healthcare software development, it can take more than a year to acquire not only the necessary IT skills, but also knowledge of the domain.This is why it is very difficult to hire, train and keep qualified engineers, support and administration specialists, and the demand is growing. With a multitenancy model, more and better services can be developed and maintained with the same engineering and IT workforce. The support specialists can then refocus their efforts on solving end-users problems related to healthcare rather than pure IT infrastructure and improve customer satisfaction overall.

Further more, multitenancy provides much greater performance, scalability and maintainability as applications are generally hosted on elastic cloud infrastructures and platforms. Even though more and more vendors offer cloud based products from basic elastic resources through infrastructure as a Service (IaaS), or a full customizable development and deployment cloud based platform (PaaS), professional healthcare IT professionals are still reluctant to have their patient's records hosted on commercial public clouds. Obviously, offloading generic healthcare related services that do not contain any PHI information (e.g. ICDx, HL7, SNOMED taxonomy and terminology services) can certainly be realized from private to public cloud if needed. On the other hand, when any patient demographic information or clinical data is included, healthcare IT decision makers needs assurances that the data is always secure and the applications and processes involved are in compliance with HIPAA regulation. One minimum requirement for example is that all protected data must be encrypted at rest and in flight at all time. Other legal requirements in certain states also require that the patient's data stays within the limit of the states and this can be an issue when physical servers on public clouds can reside anywhere.

The migration of legacy single tenant applications to multitenant based services is definitively challenging and requires new paradigms (e.g. metadata driven architecture and data models, polymorphic applications), new tools and platforms and engineers and IT personnel familiar with this new model and its related technologies. Multitenancy is an essential part of the whole cloud computing market for the healthcare industry that is estimated to grow to $5.4 billion by 2017.

Multitenancy is certainly one of the most critical technologies that will drastically help improve the efficiency of healthcare, reduce cost and will be the base of business intelligence and data warehousing solutions to make better health predictions and decisions for the overall population.

How to create a simple CXF based JAX-RS Client

2012-06-13T14:19:00.003-07:00

In my previous blog post, I did explain how to create a REST API using CXF and Spring.

This time I would like to describe how to quickly create a client that can call the REST API while reusing the resources POJO classes,
so the un-marshalling is done by JAXB.

For this I am using the CXF WebClient which is very simple to use:

import WebClient from org.apache.cxf.jaxrs.client.WebClient
import your POJOs
import a JABX provider (I am using Jackson JAXB JSON provider)

Here is a very simple standalone program that does exactly this (make sure your REST API has been deployed locally):

 
import com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider;
import org.apache.cxf.jaxrs.client.WebClient;
import java.util.ArrayList;
import java.util.List;

public class App 
{
    public static void main( String[] args )  throws Exception { 
      
     List<Object> providers = new ArrayList<Object>();
     providers.add( new JacksonJaxbJsonProvider() );
   
     WebClient client = WebClient.create("http://localhost:8080/poc_restapi_cxf/api", providers);
     client = client.accept("application/json").type("application/json").path("/order").query("id", "1");
   
     Order order = client.get(Order.class);
     System.out.println("Order:" + order.getCustomerName());
  
    }
}

With this very simple client program, the response to your request (JSON) is automatically unmarshalled to a Java object.

If you are using maven, make sure you have the correct dependencies in your pom file:

    <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-rt-transports-http</artifactId>
       <version>${cxf.version}</version>
       <scope>provided</scope>
    </dependency>
   
    <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-rt-rs-extension-search</artifactId>
       <version>${cxf.version}</version>
       <scope>provided</scope>
    </dependency>
     
    <dependency>
       <groupId>org.apache.cxf</groupId>
       <artifactId>cxf-rt-rs-extension-providers</artifactId>
       <version>${cxf.version}</version>
       <scope>provided</scope>
    </dependency>
      
    <dependency>
    <groupId>com.fasterxml.jackson.jaxrs</groupId>
       <artifactId>jackson-jaxrs-json-provider</artifactId>
       <version>2.0.2</version>
    </dependency>

REST API with CXF and Spring

2012-05-29T16:01:00.000-07:00

For the past couple of years, I have developed REST APIs using RESTEasy since the target deployment platform was JBOSS. More recently I have considered using Apache CXF instead. One reason is that we wanted to use a single technology to create web services (we are using CXF for our SOAP based web services).

In this article I will show how to create a very simple REST web service using CXF and Spring and describe how to deploy it on JBOSS AS 7.0.

I have found several tutorials describing how to create CXF based REST web services but none with Spring and working when deployed on JBOSS AS 7.0. Part of the proof of concept (POC) code sample I am describing in this article come from Sandeep Bhandari article "REST Web Service Using CXF - Beginner's Tutorial" which I enriched with Spring integration and deployment configuration for JBOSS AS 7.0.

In my POC example, there is not much differences for the POJO classes representing the order resources (I made them a little bit simple):

class Order

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "order")
public class Order {
 
    private String itemName;
    private int quantity;
    private String customerName;
    
    @XmlElement
    public String getItemName() { return itemName; }
    
    public void setItemName(String itemName) { this.itemName = itemName; }
    
    @XmlElement
    public int getQuantity() { return quantity; }
    
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    
    @XmlElement
    public String getCustomerName() { return customerName; }
    
    public void setCustomerName(String customerName) { this.customerName = customerName; }
}

class OrderList

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "OrderList")
public class OrderList {

    List orders;
   
    @XmlElement(name = "order")
    public List getOrder() {
        if (orders == null) {
            orders = new ArrayList();
        }
        return this.orders;
    }
}

The web.xml file specify only the CXF servlet:

<web-app>

    <display-name>Archetype Created Web Application</display-name>
   
 <servlet>
  <servlet-name>CXFServlet</servlet-name>
  <servlet-class>
   org.apache.cxf.transport.servlet.CXFServlet
  </servlet-class>
   <load-on-startup>1</load-on-startup> 
 </servlet>

 <servlet-mapping>
  <servlet-name>CXFServlet</servlet-name>
  <url-pattern>/api/*</url-pattern>
 </servlet-mapping>
 
</web-app>

The file cxf-servlet.xml specify the service bean and the JAX-RS providers:

 <beans 
    xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:beans='http://www.springframework.org/schema/beans'
 xmlns:jaxrs="http://cxf.apache.org/jaxrs"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://cxf.apache.org/jaxrs 
 http://cxf.apache.org/schemas/jaxrs.xsd
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context.xsd">
  

  <jaxrs:server id="restContainer" address="/" >
  
            <jaxrs:serviceBeans>
        <ref bean="simpleService" />
     </jaxrs:serviceBeans>  
     
           <jaxrs:providers>
               <ref bean="jaxbProvider"/>
               <ref bean="jsonProvider"/> 
           </jaxrs:providers>
      
        </jaxrs:server>
     
     <bean id="simpleService" class="com.acme.poc.restapi.cxf.service.SimpleServiceImpl" />
  <bean id="jaxbProvider" class="org.apache.cxf.jaxrs.provider.JAXBElementProvider"/>  
  <bean id="jsonProvider" class="org.codehaus.jackson.jaxrs.JacksonJsonProvider" />
  
</beans>

The SimpleService interface:

import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;  

@Path("/order/")
public interface SimpleService {
 @GET
 @Produces("application/xml")
 @Path("{orderId}")
 public Order getOrderXml(@PathParam ("orderId") int id);
 
 @GET
 @Produces("application/json") 
 @Path("/")
 public Order getOrderJson(@QueryParam("id") @DefaultValue("-1") String strId);
 
 @GET
 @Produces("application/xml")
 @Path("all")
 public OrderList getAllOrders();
}

The SimpleServiceImpl class:

import java.util.ArrayList;
import java.util.List;

public class SimpleServiceImpl implements SimpleService {
 
 List list = new ArrayList();
 
 public SimpleServiceImpl () {
         Order order = new Order();
         order.setItemName("Veggie Pizza");
         order.setQuantity(9);
         order.setCustomerName("OptumInsight");
         list.add(order);
         
         order = new Order();
         order.setItemName("Green Salad");
         order.setQuantity(2);
         order.setCustomerName("OptumInsight");
         list.add(order);
  }
 
 @Override
    public Order getOrderXml(int id) {
   return getOrder(id);
    }
 
 @Override
 public Order getOrderJson(String strId) {
  int id = Integer.valueOf(strId);
  return getOrder(id);
 }
 
 @Override
 public OrderList getAllOrders() {
  OrderList fullList = new OrderList();
        for(Order order : list) {
         fullList.getOrder().add(order);
        }
        return fullList;
 }
 
 // Common method returning an Order POJO
 public Order getOrder(int id) {
  if ((id > 0) && (id <= list.size())) {
   return list.get(id - 1);
  }
         else
          return null;
 }
}

Finally the pom.xml file for maven:

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.acme.poc.restapi</groupId>
  <artifactId>poc_restapi_cxf_client</artifactId>
  <version>1.0</version>
  <packaging>jar</packaging>

  <name>poc_restapi_cxf_client</name>
  <url>http://maven.apache.org</url>
  
    <properties>
      <spring.version>3.1.0.RELEASE</spring.version>
      <cxf.version>2.6.0</cxf.version>
      <jackson.version>1.9.7</jackson.version>
      <junit.version>4.8.1</junit.version>    
   </properties>
  
   <dependencies>
   
     <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-rt-transports-http</artifactId>
        <version>${cxf.version}</version>
   <scope>provided</scope>
     </dependency>
   
     <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-extension-search</artifactId>
      <version>${cxf.version}</version>
    <scope>provided</scope>
     </dependency>
     
     <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-extension-providers</artifactId>
      <version>${cxf.version}</version>
    <scope>provided</scope>
     </dependency>
  
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    
  </dependencies>
  
  <build>
    <finalName>poc_restapi_cxf_client</finalName>
     <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
               <source>1.6</source>
               <target>1.6</target>
               <encoding>UTF-8</encoding>
            </configuration>
         </plugin>
    </plugins>
  </build>
</project>

The file jboss-deployment-structure.xml is used for JBOSS deployment:

<jboss-deployment-structure>
 <deployment>
  <dependencies>
   <module name="org.apache.cxf" services="import">
    <imports>
     <include path="**" />
    </imports>
   </module>
  </dependencies>
 </deployment>
</jboss-deployment-structure>

In addition to this, before you deploy on JBOSS, you need to make some modifications on your web application server:

1) Download the latest edition of CXF (2.6.0) and placed just one jar from the distribution into the folder /modules/org/apache/cxf/main/cxf-2.6.0.jar (This contains all of the CXF codebase, except the dependencies)

2) Open /modules/org/apache/cxf/main/module.xml
   Remove all resource elements (the JARs)
   Add a new resource element similar to the deleted ones with cxf-2.6.0.jar being the only Jar referenced
   Add dependency to module named: javax.ws.rs.api :

<module xmlns="urn:jboss:module:1.1" name="org.apache.cxf">
   <resources>
        <resource-root path="cxf-2.6.0.jar"/>
        <!-- 
        <resource-root path="cxf-api-2.4.4.jar"/>
          ...
        <resource-root path="cxf-xjc-ts-2.4.0.jar"/> 
        -->
    </resources>
     <dependencies>
        <module name="asm.asm" />
        <module name="javax.api" />
        <module name="javax.annotation.api" />
        <module name="javax.jms.api" />
        <module name="javax.jws.api" />
        <module name="javax.mail.api" />
        <module name="javax.resource.api" />
        <module name="javax.servlet.api" />
        <module name="javax.ws.rs.api" />
        <module name="javax.xml.bind.api" services="import"/>
        <module name="com.sun.xml.bind" services="import"/>
        <module name="javax.wsdl4j.api" />
        <module name="javax.xml.soap.api" />
        <module name="javax.xml.stream.api" />
        <module name="javax.xml.ws.api" />
        <module name="org.apache.commons.lang" />
        <module name="org.apache.neethi" />
        <module name="org.apache.velocity" />
        <module name="org.apache.xml-resolver" />
        <module name="org.apache.ws.xmlschema" />
        <module name="org.apache.ws.security" />
        <module name="org.apache.santuario.xmlsec" />
        <module name="org.springframework.spring" optional="true"/>
    </dependencies>
</module>

3) Create folder /modules/org/springframework/spring/main/
   Create module.xml
   Copy all the text from the CXF module.xml into this new one
   Erase the last dependency (itself)
   Erase the resource against cxf JAR (because this is the copy for spring)
   Download latest Spring framework, and copy all the Spring jars into the folder
   Add all of these JARs to the module.xml inside tag.
   Add dependency to module named: org.apache.commons.logging

<module xmlns="urn:jboss:module:1.1" name="org.springframework.spring">
    <resources>
  <resource-root path="spring-aop-3.1.0.RELEASE.jar" />
  <resource-root path="spring-asm-3.1.0.RELEASE.jar" />
  <resource-root path="spring-beans-3.1.0.RELEASE.jar" />
  <resource-root path="spring-context-3.1.0.RELEASE.jar" />
  <resource-root path="spring-core-3.1.0.RELEASE.jar" />
  <resource-root path="spring-expression-3.1.0.RELEASE.jar" />
  <resource-root path="spring-web-3.1.0.RELEASE.jar" />
        <!-- Insert resources here -->
    </resources>
    <dependencies>
        <module name="asm.asm" />
        <module name="javax.api" />
        <module name="javax.annotation.api" />
        <module name="javax.jms.api" />
        <module name="javax.jws.api" />
        <module name="javax.mail.api" />
        <module name="javax.resource.api" />
        <module name="javax.servlet.api" />
        <module name="javax.xml.bind.api" services="import"/>
        <module name="com.sun.xml.bind" services="import"/>
        <module name="javax.wsdl4j.api" />
        <module name="javax.xml.soap.api" />
        <module name="javax.xml.stream.api" />
        <module name="javax.xml.ws.api" />
        <module name="org.apache.commons.lang" />
        <module name="org.apache.commons.logging" />
        <module name="org.apache.neethi" />
        <module name="org.apache.velocity" />
        <module name="org.apache.xml-resolver" />
        <module name="org.apache.ws.xmlschema" />
        <module name="org.apache.ws.security" />
        <module name="org.apache.santuario.xmlsec" />
    </dependencies>
</module>

java XSLT processing with Saxon

2012-04-19T16:31:00.009-07:00

Recently, I was looking for an efficient way to reduce the size of XML based clinical documents (CCD) that I am sending from a java REST API to mobile devices. These healthcare HL7 XML documents contain textual narrative blocks that are not used by the applications residing on the mobile devices.

On solution was to use Saxon, an open source XSLT processor in conjunction with a transformation style sheet to strip the Continuity of Care Documents of their narrative blocks.

In a CCD, each section under ClinicalDocument/component/structuredBody/component can have a text section that usually contains a narrative block similar to HTML content that can typically add 30% or more to the size of the CCD document:

This has the advantage to avoid creating a full DOM representation, and is more robust and flexible than an event based sequential SAX processor.

The first step is to create a XSLT stylesheet that will transform (in my case strip the text sections) from the XML document.
In my case, since I wanted to remove all text sections, I was able to use an identity transform mechanism that I modified to strip the text sections (uses the hl7 namespace):

<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='2.0'
xmlns:hl7="urn:hl7-org:v3">

<xsl:output indent="no"/>
<xsl:strip-space elements="*"/>

<!-- identity template -->
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>

<!--  remove descriptive sections -->
<xsl:template match="hl7:text"/>  

</xsl:stylesheet>

Then I placed this file (I named it ccd_no_text_sections.xsl) under the /src/main/resources folder.

To use this XSLT stylesheet with Saxon, you need to use one of the Saxon Java libaries.
If you using maven, for example, just add the dependencies to your pom file based on the version you want to use:

<dependency>
 <groupId>net.sf.saxon</groupId>
 <artifactId>saxon</artifactId>
 <version>9.0</version>
</dependency>

<dependency>
 <groupId>net.sf.saxon</groupId>
 <artifactId>saxon-dom</artifactId>
 <version>9.0</version>
</dependency>

or for the latest free version:

<dependency>
 <groupId>net.sf.saxon</groupId>
 <artifactId>Saxon-HE</artifactId>
 <version>9.4</version>
</dependency>

Then you need to create a transformer and call your style sheet for the transformation.
In my case, since I was planning other transformations, I decided to cash the XSLT transformer into a HashTable as follow:

import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashMap;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

public class XSLTProcessor {

 private static final HashMap<String,Transformer> TRANSFORMER_CACHE = new HashMap<String,Transformer>();

 final static String CCD_NO_TEXT_SECTIONS = "/ccd_no_text_sections.xsl";
  
 private XSLTProcessor() {
   // no instantiation
 }

 private static Transformer getCCDTransformer() throws TransformerConfigurationException {

  Transformer transformer = TRANSFORMER_CACHE.get(CCD_NO_TEXT_SECTIONS);
  if (transformer == null) { 
   TransformerFactory tsf = TransformerFactory.newInstance();
         InputStream is = XSLTProcessor.class.getResourceAsStream(CCD_NO_TEXT_SECTIONS);
   transformer = tsf.newTransformer(new StreamSource(is));
   return transformer;
  }
  return transformer;
 }
 
 public static String stripTextSections(final String xmlString) throws TransformerConfigurationException,
        TransformerException, 
        TransformerFactoryConfigurationError {

        final StringReader xmlReader = new StringReader(xmlString);
        final StringWriter xmlWriter = new StringWriter();
        final Transformer ccdTransformer = getCCDTransformer();
        ccdTransformer.transform(new StreamSource(xmlReader),
            new StreamResult(xmlWriter));
        
        return xmlWriter.toString();
 }
}

In this way, you can easily add new transformers if needed and refer to them by their stylesheet name located under the resource folder.
In addition to this, the transformer is created only once and always available for a transformation.

The transformation can be called directly on the document as follow:

try {
    String new_ccd = XSLTProcessor.stripTextSections(ccd);
}
catch (TransformerConfigurationException e) {
    log.error("TransformerConfigurationException"+e);
}
catch (TransformerException e) {
    log.error("TransformerException"+e);
}
catch (TransformerFactoryConfigurationError e) {
    log.error("TransformerFactoryConfigurationError"+e);
}

RESTEasy Interceptors

2012-04-02T11:03:00.005-07:00

RESTEasy can intercept JAX-RS invocations and route them through listener-like objects called interceptors. There are four interception points on the server side:

wrapping around MessageBodyWriter invocations
wrapping around MessageBodyReader invocations
through pre-processors, which intercept the incoming request before unmarshalling occurs
through post-processors, which are invoked immediately after the JAX-RS method finishes

An interceptor can be very useful to implement crosscutting concerns such as logging and security. Although interceptors are not as powerful as Aspect Oriented Programming (AOP) - (e.g. no type-safety or debugging) , they still offer a quick way to create more compact and maintainable code.

In this article I will describe how to use RESTEasy interceptors to log incoming requests into a REST API.

I am currently using RESTEasy to expose HealthCare web services for consumption by mobiles applications, and there is a need to log transactions for auditing purpose, including for HIPAA compliance.

The first step is to specify in your web.xml file, that you are going to use a new interceptor - (e.g. named LogInterceptor):

<web-app>
   ...  
   <context-param>
      <param-name>resteasy.providers</param-name>
      <param-value>com.acme.api.rest.service.LogInterceptor</param-value>
   </context-param>
   ...
</web-app>

Then you create the corresponding java class for LogInterceptor:

package com.acme.api.rest.service;
  
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.ext.Provider;
import javax.ws.rs.WebApplicationException;

 
import org.jboss.resteasy.annotations.interception.ServerInterceptor;
import org.jboss.resteasy.core.ResourceMethod;
import org.jboss.resteasy.core.ServerResponse;
import org.jboss.resteasy.spi.HttpRequest;
import org.jboss.resteasy.spi.interception.PreProcessInterceptor;
import org.jboss.resteasy.spi.Failure;

...
 
@Provider
@ServerInterceptor
public class LogInterceptor implements PreProcessInterceptor {
 
 // An handler to the Transaction log
 private static final Logger translog = Logger.getLogger(JNDIMessageLoggingHandler.class);

 // Getting the request as a context
 @Context HttpServletRequest request;

 @Override
 public ServerResponse preProcess(HttpRequest arg0, ResourceMethod method) throws Failure, WebApplicationException {
  final TransactionLogEntry transactionLogEntry = new TransactionLogEntry(Long.toString(Thread.currentThread().getId()),
                         System.currentTimeMillis(), 
                         getClientIP(request), 
                         request.getRequestURL().toString());
      translog.info(transactionLogEntry);
 }  
 
}

In this example, the TransactionLogEntry constructor takes :

a transaction ID
a timestamp
the client that initiated the request (e.g. request.getRemoteAddr()+":"+request.getRemotePort())
the request URL

but you can also log additional information such as the body content of POST requests (storing XML or JSON content).

X-HTTP header method override and REST APIs

2012-03-23T11:32:00.007-07:00

In a previous article, I was explaining how to extract HTTP headers. In this one, I will explain why the use of specific custom HTTP headers such as X-HTTP methods override can be very handy while developing and promoting a REST API.

When deploying REST API based web services, you may encounter access limitations on both the server and client sides.

1) X-HTTP methods override and server side

On the server side, the access to your REST based web application (I am using JBOSS) might be done via a proxy web server that does not support certain HTTP operations such as DELETE or PUT for security reasons.

For example if you are using Lotus Domino as redirector for your HTTP requests, be aware that by default Lotus Domino does not enable PUT and DELETE to go through.

Such requests will lead to HTTP 405 error:

Http Status Code: 405

Reason: Request method is not allowed by the server

By the way, if you really intend to allow PUT and DELETE on your Domino proxy web server, you need to add the following line to your notes.ini file:

HTTPEnableMethods=PUT,DELETE

However if you really need to have your proxy server filtering DELETE and PUT operations, then you will have to offer these operations via POST operations and ask your clients to add specific X-HTTP method override field in the header of their requests.

2) X-HTTP methods override and client side

The application consuming your web service might also have some constraints, for example restricting forms to only use GET or POST.

For these reasons, web infrastructure and solutions providers have proposed to use customized HTTP header fields:

X-HTTP-Method (Microsoft)
X-HTTP-Method-Override (Google/GData)
X-METHOD-OVERRIDE (IBM)

If you want to support all of these variations, I would suggest to implement them as case insensitive in your REST API.

I personally use JBoss RestEasy to develop a REST API for mobile health care applications, and it was quite straightforward to add the additional level of flexibility to my existing PUT and POST operations.

Note that if you want to use these methods to enforce either a PUT or a DELETE method, be aware that the RFC 2616 - HTTP 1.1 section 9.1.1 describes the GET operation as safe.

9.1.1 Safe Methods

   Implementors should be aware that the software represents the user in
   their interactions over the Internet, and should be careful to allow
   the user to be aware of any actions they might take which may have an
   unexpected significance to themselves or others.

   In particular, the convention has been established that the GET and
   HEAD methods SHOULD NOT have the significance of taking an action
   other than retrieval. These methods ought to be considered "safe".
   This allows user agents to represent other methods, such as POST, PUT
   and DELETE, in a special way, so that the user is made aware of the
   fact that a possibly unsafe action is being requested.

In other words, if you are tempted to use a GET to simulate a PUT or DELETE, don't do it.
Use a POST instead. Thank you to my colleague Ravi to point this to me!

X-HTTP methods override and PUT based operations

If your PUT operation does not have a corresponding DELETE counter-part,
you could just use the POST as a PUT and not even add a X-HHTP-Method override.

Both POST and PUT requests will end up being bound to the same method:

 @PUT
 @POST
 @Path("/users/{userId}/order/{orderNum}")
 @Produces("application/json")
 @GZIP
 public Response putPostUserOrder(@Context HttpServletRequest request, 
               @PathParam("userId") String userId,
               @PathParam("orderNum") String orderNum)

If you still need to use a X-HTTP-Method override, what you need to do is to filter those specific POST requests.

boolean bProceed = true;
if (request.getMethod().compareToIgnoreCase(POST) == 0) {
    String methodOverride = getHttpMethodOverride(request);
    if ((methodOverride == null) || (methodOverride.compareToIgnoreCase(PUT) != 0)) 
        bProceed = false;
}

private String getHttpMethodOverride(HttpServletRequest request){
    String headerValue = request.getHeader("x-http-method-override");
    if (headerValue != null)
      return headerValue;
    else 
      return(request.getHeader("x-method-override"));  
}

In the example above, I have only implemented two customized X-HTTP headers, but you can add all of them if necessary.

X-HTTP methods override and DELETE based operations

For the DELETE operation, even if you don't have a PUT counter part, it is preferable to use a X-HTTP method override with DELETE to be semantically consistent (a PUT and POST are typically using to add or modify a resource, not removing it).

 
 @POST
 @Path("/users/{userId}/order/{orderNum}")
 @Produces("application/json")
 @GZIP
 public Response postDeleteUserOrder(@Context HttpServletRequest request, 
               @PathParam("userId") String userId,
               @PathParam("orderNum") String orderNum)

boolean bDelete = false;
if (request.getMethod().compareToIgnoreCase(POST) == 0) {
 String methodOverride = getHttpMethodOverride(request);
 if ((methodOverride != null) && (methodOverride.compareToIgnoreCase(DELETE) == 0)) 
  bDelete = true;
}

Of course, if most likely want to still support the regular DELETE, so you also keep the original binding DELETE method:

 @DELETE
 @Path("/users/{userId}/order/{orderNum}")
 @Produces("application/json")
 @GZIP
 public Response deleteUserOrder(@Context HttpServletRequest request, 
               @PathParam("userId") String userId,
               @PathParam("orderNum") String orderNum)

Test harnessing X-HTTP Methods override operations

You can easily test your REST API with cURL as follow:

curl -H "X-HTTP-Method-Override: DELETE" -X POST http://restservice.acme.com/api/users/JJALGHPBIMA/orderNum/e7687673-479d-4d37-8bc0-a3e718aad33f

Should have the same effect as :

curl -X DELETE http://restservice.acme.com/api/users/JJALGHPBIMA/orderNum/e7687673-479d-4d37-8bc0-a3e718aad33f

Maven war plugin configuration section and web.xml

2012-02-24T15:33:00.007-08:00

I am sure you have been in the following situation: you want to mavenize a web application project.

For this, you create a basic dynamic web application in Eclipse:

You then import the application you want to build:

After the import is done, you create a pom file.

You then update your eclipse configuration files via 'mvn clean eclipse:eclipse'

Finally you try to build your web application (war file) via 'mvn clean install'

However you get a bad surprise: First you are getting a BUILD ERROR:

Error assembling WAR: webxml attribute is required (or pre-existing WEB-INF/web.xml if executing in update mode)

... and even though you seem to have created a war file, it only contains empty META-INF, WEB-INF and classes folders:

The problem is that your web.xml file is not picked up by your maven build, because by default maven expects to find your web.xml inside src/main/resources.

One option is to refactor your project and move your web.xml under src/main/resources/WEB-INF.

A better option is to modify your pom file and add a maven war plugin configuration section to your build/plugins section.

In my case, I am specifying that my web.xml file is located under a WebContent folder, relative to the Pom file:

   
   <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-war-plugin</artifactId>
      <version>2.1.1</version>
      <!-- <configuration> section added to pick up the WEB-INF/web.xml inside WebContent -->
      <configuration>
         <webResources>
            <resource>
               <directory>WebContent</directory>
            </resource>
         </webResources>
      </configuration>
   </plugin>

When done, you just need to rebuild your web application (war file) via 'mvn clean install' and you should then obtain a BUILD SUCCESSFUL with the war file content you were expecting!

How to extract HTTP header fields in a REST API

2011-12-30T14:35:00.000-08:00

To be able to extract HTTP headers fields from incoming requests accessing a REST API is particularly useful when trying to log the transactions that are coming through the REST based service.

In this example, I use Java based JBoss RESTEasy together with @Context java annotation to extract the header information.

One of the REST API operation is /version that returns the current version of the API in a JSON format.The interface operation is defined as follow:


     import javax.ws.rs.core.HttpHeaders;

     /**
     * Get the current version of the REST API.
     */
     @GET
     @Path("/version")
     @Produces("application/json")
     @GZIP
     public Response getVersion(@Context HttpHeaders headers);

The @Context annotation allows you to map request HTTP headers to the method invocation.

One way to safely extract all available header parameters is to loop through the headers.The method getRequestHeaders from javax.ws.rs.core.HttpHeaders returns the values of HTTP request headers. The returned map is case-insensitive and is read-only.

   if (headers != null) {
       for (String header : headers.getRequestHeaders().keySet()) {
          System.out.println("Header:"+header+
                             "Value:"+headers.getRequestHeader(header));
       }
   }

When querying the REST API via a browser:

  http://www.acme.com/api/version

you obtain a minimum set of headers fields:


   Header:cache-control Value:[max-age=0]
   Header:connection Value:[keep-alive]
   Header:accept-language Value:[en-us,en;q=0.5]
   Header:host Value:[www.acme.com]
   Header:accept Value:[text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8]
   Header:user-agent Value:[Mozilla/5.0 (Windows NT 6.1; WOW64; rv:8.0)    
   Gecko/20100101 Firefox/8.0]
   Header:accept-encoding Value:[gzip, deflate]
   Header:session-id Value:[d636369c]
   Header:accept-charset Value:[ISO-8859-1,utf-8;q=0.7,*;q=0.7]

To be able to extract a specific header field (e.g. Host), you can use the getRequestHeader function:

 public Response getVersion(@Context HttpHeaders headers) {
     if (headers != null) {
        List<String> hostHeader = headers.getRequestHeader("host");
        if (hostHeader != null) {
           for (String host : hostHeader) {
              LOG.debug("Host:"+host);
           }
        }
     } 
  
     // Get the version
     final Version current_version = new Version();
     final ObjectMapper mapper = new ObjectMapper();
     final JsonNode rootNode = mapper.createObjectNode();
     ((ObjectNode) rootNode).putPOJO(Version.XML_ROOT_ELEMENT, current_version);
     
     final ResponseBuilder builder = Response.ok(rootNode);
     return builder.build();
   }

If you are using a test harness tools like cURL, you can also easily add additional HTTP header fields
(e.g. the email address of the user making the request or the referer) and test the logging functionality of your REST API:

curl -H "From: user@example.com" http://www.acme.com/api/version

curl -H "Referer: http://consumer.service.acme.com" http://www.acme.com/api/version

The headers can also be obtained through the HttpServletRequest object.
This can be done using the @Context HttpServletRequest annotation and can provide additional information about the incoming request:

public Response getVersion(@Context HttpServletRequest request) {
   LOG.debug("Host:"+request.getHeader("host"));
   LOG.debug("Request-URL:"+request.getRequestURL());
   ...
}

Since HttpServletRequest extends ServletRequest you also getting useful methods providing information on the Internet Protocol (IP) address, host and port of the client or last proxy that initiated the request.

public Response getVersion(@Context HttpServletRequest request) {
   LOG.debug("Remote-IP:"+request.getRemoteAddr());
   LOG.debug("Remote-Host:"+request.getRemoteHost());
   LOG.debug("Remote-Port:"+request.getRemotePort());
   ...
}

cURL setup and OpenSSL

2011-11-28T15:29:00.000-08:00

In a previous post I was explaining how to use cURL to quickly test REST web services. If your web service has to be secure, you are probably using Transport Layer Security (TLS) - the new Secure Sockets Layer (SSL) cryptographic protocol.

To be able to use TLS/SSL with cURL, you will need to have some SSL libraries/DLL such as OpenSSL installed. If you did not install OpenSSL, you will most likely get the following error when trying to use cURL:

"The program can't start because LIBEAY32.dll is missing from your computer. Try to reinstall the program to fix this problem."

To fix this, you can either install the OpenSSL on your machine, or if you just want to install the minimum, you can just copy the following DLLs from OpenSSL (I am using OpenSSL 1.0.0c) to your cURL folder:

libeay32.dll
ssleay32.dll

By the way, you can download cURL for most of the OS and platforms and usually SSL and non SSL versions are available for each OS (see current windows versions below):

Combining IHE transactions : Orchestration or Choreography?

2011-10-28T14:33:00.000-07:00

Integrating the Healthcare Enterprise (IHE) has gained tremendous momentum in the past few years. Started as a Healthcare Information and Management Systems Society (HIMSS) and Radiological Society of North America (RSNA) workshop in October 1998 with only 15 participants including AGFA, Cerner, Fuji, GE, HP, Philips, Siemens, the IHE initiative has more than 400 members worldwide. It is composed of healthcare professional associations, government agencies, Health Information Exchanges (HIE), healthcare providers, IT and consulting companies, trade, educational, standard and research organizations. IHE provides a standards based-interoperable framework to share and exchange information between healthcare organizations across networks.

Combined with the latest technology and well established standards (HL7, DICOM, IDC9/10, LOINC, W3C), clinical data can then be securely and privately accessed and transmitted locally between network endpoints (e.g. within the same hospital between the practices and a lab). IHE profiles can also be used across Health Information Exchanges (HIE) of Regional Health Information Organization (RHIO), or a state level (e.g. an individual state in the US, Canada or Europe), or at the federal level (e.g. the US Nationwide Health Information Network or NwHIN). As a result, there is a strong need to integrate and combine individual IHE profiles end-points to form “hub of hubs” or “network of networks” to support health information exchange between the participating nodes entities.

Because IHE transactions are most likely to be offered as web services, combining those transactions can be done following Service Oriented Architecture (SOA) and Service Oriented Computing (SOC) principles.

Conventional middleware distributed system infrastructures (e.g. JMS) are generally not sufficient or flexible enough to mediate, transform, federate and route messages from and to web services.

Enterprise Application Integration (EAI) goes one step ahead, trying to separate the applications from the web services end-points. EAI usually employs a centralize service broker for this, a set of connectors and an independent data model. Services can then send and subscribe to receive messages to and from the broker. However, this very centralized approach requires a large amount of up front development and business process design for the connectors, as well as high cost of maintenance in general. Enterprise Service Buses (ESB) is an infrastructure that leverages EAI principles.

Orchestration

Like EAI, orchestration uses a centralized approach. Web services orchestration is realized through Business Process Execution Language (BPEL) that describe the collaboration and interaction between the web service participants.

Business workflows, states, actions, events, control flows and exception handling can be specified. Messages can be received and sent directly from and to WSDL ports. Results received asynchronously from web services can be combined to create new messages. Usually BPEL workflows are created and updated with visual design tools.

There is often an overlap between orchestration engines and Enterprise Services Buses (ESB). Vendors now also offer BPEL design on top of more generic EAI mechanisms enabling true orchestration for ESBs.

Choreography

Choreography is more distributed and collaborative in nature and uses the Web Service Choreography Interface (WSCI) specification and the WSDL description files to represent the flow of messages exchanged between the Web services involved.

Choreography seems more flexible than orchestration since it does not rely on a central element that could become a bottle neck and seems to offer more complex interaction potential between web services. However, choreography has some drawbacks including the necessity for all web services to be aware of overall business process workflow. WSCI itself does not specify the definition and the implementation of the mechanism to implement the message exchange.

In addition to this, performance can be an issue if high volume message transactions between the end-points peers are not handled properly.

Moreover, there is no clear responsibility for the overall workflow leading to legal issues related to monitoring and maintenance.

Orchestration vs Choreography

Orchestration also has the advantage to be a much more mature integration technology than choreography. For these reasons, most of the state-wide health information exchange networks in the US employ a Service-Oriented Architectural (SOA) model that is implemented through an Enterprise Service Bus (ESB) orchestration.

In addition to this, web service orchestration offers much more than just technical benefits:

Organizational: standardization, narrow gap between business analysts and developers;
Managerial: risk reduction, lower costs, more flexibility;
Strategic: IT resilience, delivery time reduction, less technology lock-in;
Technical: portability, reuse, interoperability of tools, less complex code, better maintainability;
Operational: efficiency, automation, higher level tasks management.

When deployed on high performance platforms such as SOA software appliances, orchestration solutions are easy to test, extend and maintain.

More on this topic to be published as part of the following paper: Andry F., Wan L., HEALTH INFORMATION EXCHANGE NETWORK INTEROPERABILITY THROUGH IHE TRANSACTIONS ORCHESTRATION, 5th International Conference on Health Informatics (HEALTHINF 2012).

cURL tests harness and TLS

2011-09-23T10:18:00.000-07:00

In a previous post, I have explained how to use cURL to test harness REST based Web services. One thing I did not described was how to add Transport Layer Security (TLS) in your tests. In other words, how to successfully test REST Web services over HTTPS?

The cURL manual describes a certain number of options that can be used. One of the most convenient option is -k or --insecure. It allows curl to perform "insecure" SSL connections and transfers. All SSL connections are attempted to be made secure by using the CA certificate bundle installed by default. So if you SSL connection does not require client side authentication it is a very quick way to test your web service over SSL:

curl -k https://www.acme.com/api/version

Another useful option can be used if in conjunction to SSL, you need to compress your payload via GZIP for example to optimize the transfer of large messages. In this case, you will use the option -H or --header that will help you specify custom headers to your request:

curl -H "Accept-Encoding: gzip,deflate" -k https://www.acme.com/api/users/list

Notice in that case that the -k or --insecure option is always placed just in front of URL.

Of course, other headers such as the one described previously can be combined:

curl -c ./cookies.txt --data-binary @login_password.json -H "Content-Type: application/json" -H "Accept-Encoding: gzip,deflate" -k https://www.acme.com/api/users/token

Medication Adherence - How technology can help?

2011-08-31T15:10:00.000-07:00

Looking for ideas to reduce the rise of health care cost? Easy! Ask patients to swallow their medication!

According to recent studies, the lack of prescription medication adherence cost between $250 and $300 billion annually, including $100 billion in hospitalization. For example, it is estimated that in the US 89,000 deaths annually are due to non adherence to anti-hypertensive treatments. This problem is particularly acute for patients with coexisting conditions who take a variety of medications sometimes prescribed by different physicians.

Obviously doctors and pharmacists have a critical role to encourage patients and caregivers to administrate medication correctly and rigorously.

Cost is not necessarily the main factor: even when drugs are free, adherence rate is 60% in the US and only %50 in developed countries. In other words, improvements in co-payments structures will only partially improve adherence. Another area of possible improvement will be the use of fee-for-service model.

Another way to improve medication adherence is the proper use of specific technologies:

Here are some suggestions:

the integration of practice EMRs systems and pharmacies via HIE solutions (a lot of practices are still using paper).

accurate and Electronic Health records (EMRs, and PHRs) that help verify drug, herbs, supplements interactions and countraindications. The meaningful use guidelines go in this direction.

wider use of medication home delivery (recognized as a way to save cost by introducing better competition)

electronic monitoring systems coupled with personalized counseling has shown improvement in medication adherence rates to patients

online incentive programs (e.g. provided by the employers) to promote prevention, quality of life and best practices in therapy. It is recognized that financial incentives and other rewards when well designed and targeted can improve adherence (smaller and higher reward frequency is usually more efficient than big and sporadic rewards).

advances in personalized medicine can help taylored medication intake and increase medication adherence

screening and assessment tools (e.g. patients with chronic conditions could be screened for depression leading to poor medication adherence).

new high-tech integrated devices including:

Home devices such as the well known high-tech Japanese toilets which provide urine analysis, blood pressure, weight and body temperature
Radio Frequency Identification (RFID) based wireless sensor device can help track drug taking compliance
Wireless pills organizers designed to simplify medication management and improve adherence
Personalized wearable sensors such as the latest electronic temporary tattoo

With the amount of money at stake, I am sure there is a large number of companies, including start-ups, who are working hard on this problem. So stay tune!

Finally, we have to keep in mind, that other factors including lifestyle, psychological issues and health literacy play an important role as well. And these are not negligible!

How to test secure web services with soapUI - part #2

2011-07-29T11:59:00.000-07:00

In a previous article I described how to specify signature and encryption for outgoing Secured Web Services request.

1. SAML

In this second article I will talk about SAML and incoming Secure Web Service responses.

If you are using SAML 1.X then you just need to add a SAML 1.X assertion in the corresponding window.
You may have to add a timestamp as follow:

In this example, we specify 10,000 milliseconds (10 seconds) for the life time of the Timestamp:

SAML 1.X assertions are copied and pasted in the SAML tab:

Of course, if you combine signature and encryption with SAML 1.X. You can those to the configuration tabs as well.

For SAML 2.0, the only option you have for this version of soapUI is to add it manually to the WSSE section of your SOAP request:

2. Incoming Secure Web Service
Responses

Setting up incoming secure Web services responses encrypted and/or signed is easier than for outgoing request:

1) Make sure that you have Keystores / Certificates tab set - You probably have done that earlier as described in part #1 of this article.
You verify the signature with public key contained in the server's sender certificate/store and your private key to decrypt what the other server sends you.

2) Create an incoming WSS configuration (e.g. my_config_from_server_A) that will decrypt the incoming SOAP requests coming from server A:

You specify that you want to use your keystore to decrypt the message and the server's certificate/store to verify the signature of server A
(theses should appear in the drop box for each field):

3) Last, you want to specify that you are using the incoming configuration for each request:

Enjoy!

Problem initializing the class javax.crypto.SunJCE_b with soapUI ?

2011-06-27T11:18:00.000-07:00

Last week, I have decided to download and install the lastest soapUI PRO version 4.0 from Eviware.
I have been using soapUI for some time to test secure SOAP Web services using SSL/TLS as well as encrypting and signing the SOAP payload.

However when I tried to use my existing projects I end-up with the following errors in my soapUI log:

Wed Jun 22 11:43:05 PDT 2011:ERROR:java.lang.NoClassDefFoundError: Could not initialize class javax.crypto.SunJCE_b
   java.lang.NoClassDefFoundError: Could not initialize class javax.crypto.SunJCE_b
    at javax.crypto.KeyGenerator.a(DashoA13*..)
    at javax.crypto.KeyGenerator.(DashoA13*..)
    at javax.crypto.KeyGenerator.getInstance(DashoA13*..)
    at org.apache.ws.security.message.WSSecEncrypt.getKeyGenerator(WSSecEncrypt.java:701)
    at org.apache.ws.security.message.WSSecEncrypt.prepare(WSSecEncrypt.java:228)
    at org.apache.ws.security.message.WSSecEncrypt.build(WSSecEncrypt.java:291)
    at com.eviware.soapui.impl.wsdl.support.wss.entries.AddEncryptionEntry.process(AddEncryptionEntry.java:311)
    at com.eviware.soapui.impl.wsdl.support.wss.OutgoingWss.processOutgoing(OutgoingWss.java:157)
    at com.eviware.soapui.impl.wsdl.submit.filters.WssRequestFilter.filterWsdlRequest(WssRequestFilter.java:58)
    at com.eviware.soapui.impl.wsdl.submit.filters.AbstractRequestFilter.filterAbstractHttpRequest(AbstractRequestFilter.java:37)
    at com.eviware.soapui.impl.wsdl.submit.filters.AbstractRequestFilter.filterRequest(AbstractRequestFilter.java:31)
    at com.eviware.soapui.impl.wsdl.submit.transports.http.HttpClientRequestTransport.sendRequest(HttpClientRequestTransport.java:133)
    at com.eviware.soapui.impl.wsdl.WsdlSubmit.run(WsdlSubmit.java:123)
    at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source)
    at java.util.concurrent.FutureTask$Sync.innerRun(Unknown Source)
    at java.util.concurrent.FutureTask.run(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    at java.lang.Thread.run(Unknown Source)

A quick search on the web told me to check if my some of my security setup in my JRE was properly configured.
For this it was recommended to check the security directory under the lib folder (.\Java\jre6\lib\security):

I also checked the content of the content of the jar file ./Java/jre6/lib/jce.jar which should contain the missing class in question: javax.crypto.SunJCE_b

However everything looked fine. Even though my JRE was almost up-to-date, I finally managed to fix this issue by upgrading my java JRE to the latest version!