2

Background

I'm writing a medical record app for a friend who is a Doctor. I was told to write a listener in the app that awaits HL7 messages. That way a hospital can send out HL7 messages and my listener will catch them. So I came to the HAPI site and viewed this example. What I understand from it is that it's creating a server to listen for a message.

I'm developing this in Eclipse using JSF 2.0 on Tomcat 7.0. Where does one normally put this kind of listener in a project with JSF? I've tried searching online for this answer and found nothing!

My question

I know this code goes inside a class. When the class gets called the socket will be "turned on" and it's going to wait for a response. So I want to call this class as soon as the project is deployed. How is that done? How do I call that class only once (when the app is starting) in order to turn on the listener?

Any and all help is greatly appreciated! And if I'm not being clear on something let me know!

Paul Bellora
  • 54,340
  • 18
  • 130
  • 181
Myy
  • 18,107
  • 11
  • 37
  • 57
  • 1
    http://healthcareit.stackexchange.com/ could be another place to ask your question. – Pierre Jan 06 '12 at 23:17
  • How many types of HL7 messages you want to process? Have you considered buying a product off-the-shelf? – Bhushan Jan 06 '12 at 23:23
  • Thanks Pierre, I didn't know of that site. – Myy Jan 06 '12 at 23:54
  • @Bhushan, just 1 type, ORU_R01. my question is more of a "if the listener is on all the time, where in a project does it go" maybe I'm not being very clear. like if I folow the code in the example, it creates the listener in line 97. and then closes it in line 147, but I want mine to always be open. sodo these types of java classes just go anywhere? – Myy Jan 07 '12 at 00:03

5 Answers5

4

You don't normally get port listeners running inside an application hosted in Tomcat. You're usually best to keep the two things separated. In the main, web servers aren't meant to run separate threads of execution outside of their control.

You could consider using something like Spring Integration, JBossESB or Apache Camel to receive the messages and process them into a database, file folder (or whatever) that your Tomcat hosted web application then allowed you to manipulate. The ESB container could be hosted in the same JVM process as Tomcat but I wouldn't take that approach myself - I'd have a separate one doing the message processing and another running the webapp.

If you really wanted a "single application" you could consider creating a Java application that kicked off a listener as per the example you have, then started up an embedded version of Tomcat.

If you really really wanted to run it inside Tomcat, as part of web application itself, you could create a class which did the listening and get it loaded into the Application context of the web application. You can do this by adding an instance of it into the appl context within an autoloaded servlet - use <load-on-startup>1</load-on-startup> within the servlet definition. You'd code the servlet to check if there was already an instance in context before adding a new one (on the off-chance it was ever manually invoked), or go down the Spring container route to manage this object as a singleton.

* EDIT: 20120114T004300Z *

Apache Camel is an example of a routing engine that might be used by an Enterprise Service Bus (ESB) such as Apache ServiceMix which allows multiple applications to interoperate by exchanging messages. You'd only use a fraction of the functionality availability for this app by the sounds of it. For what you're doing you might just be able to use Camel capability embedded in Spring, for example.

In essence, the ESB runs "adapters" (or endpoints) - one types of which would by the socket "listener" you talk about here, or might be watching a folder for files to arrive, or polling a database table for rows to appear, or waiting on a JMS queue, etc. The transport (the means by which the "message" (in your case the HL7 file) arrives becomes abstracted away from the functionality of the application itself. The adapter puts the message onto a channel which can be configure to transform the message en-route. Camel actually ships with a HL7 component which can understand the HL7 file format and unmarshal it into a HL7 model. (It also gives you the listener/adapter you need). You'd then set up routing in the ESB to pass that model into a "consumer" Java class that does whatever you need to do with it.

If you're dealing with "standard" transports, protocols and message types most of the file receipt, parsing, and routing is just handled by declarative configuration of the ESB rather than coding.

Your Tomcat webapp can run completely autonomously to this message handling. As mentioned, there are various deployment options as to how exactly you'd do this - including loading Camel inside a Spring container hosted in Tomcat by your webapp if you want to.

Apologies if this is a bit woffley. Take some time to read around the subject on the web, given that HL7 is a standard you'll probably find a lot of code/components already out there that might save you a lot of time in re-implementing the basic file handling so you can concentrate on the value-add webapp for your friend.

Trevor Tippins
  • 2,827
  • 14
  • 10
  • I believe I've heard of Apache Camel, what is it exactly.? so I don't HAVE to have it in the same place?. I kinda get what you're saying, so I would can use this "apache camel" to listen for the messages and put them in the db, AND my app doesn't really know about it, all it does it show me the info if it's there ( in the db) did I get that correct? – Myy Jan 13 '12 at 01:01
2

A "Listener" is just a class which listens on an open port. In Java, this is mostly done through the Socket API, although you may find a library that better suits your purpose.

The Java Tutorial has some examples here: http://docs.oracle.com/javase/tutorial/networking/sockets/index.html

In this case, you'd be writing a server (the listening half of a client-server arrangement), whereas the Hospital system sending the message would play the role of client.

Once you're listening on the port, then HL7 messages arrive as plain text onto that socket's inputstream. You can either hand-parse the message (viable if you're only interested in one or two details from a message) or if you're planning on handling dozens of types of messages you can look into one of the HL7 parsing libraries out there.

Keep in mind though, that different implementors of HL7 messages can sometimes send data in subtly different arrangements. (Many users treat HL7 as a 'recommendation' rather than a 'standard', unfortunately!) If you're planning on supporting lots of different feeds from lots of different providers, you'd be much better off using a middleware layer like MirthConnect to handle the parsing and translation of messages into something your application is designed to understand.

Erica
  • 2,251
  • 16
  • 21
  • HI Erica, so I followed http://www.java-tips.org/java-tutorials/tutorials/introduction-to-servlet-listener-using-eclipse-5.html <----This tutorial on how to add a listener to my Web App. – Myy Jan 11 '12 at 23:06
  • it pretty much just tells me to add the listener tag to my xml, and then create a class that implements ServletContextListener. with a public void contextInitialized(ServletContextEvent arg0) Funtion in it. Do I have to create the SimpleServer from my first example and ADD it here in order to keep the socket open ( listening for incoming messages) until the app is redeployed (basically always listening). – Myy Jan 11 '12 at 23:10
  • 1
    Myy, you're heading in the wrong direction. A ServletContextListener is something listening for changes in your servlet environment, like deploying a new servlet. You want a *socket* listener. Completely different things. – Erica Jan 12 '12 at 00:00
  • Oh, I'm sorry =( , I thought that was the way I created a class to call the socket. I'm getting how that works though.... A socket is in this example http://hl7api.sourceforge.net/xref/ca/uhn/hl7v2/app/SimpleServer.html The simpleServer uses a socket to open a connection in line 80, so it waits for a message to be sent. and according to that, it loops until a message is caught. am I understanding that correctly? – Myy Jan 12 '12 at 05:51
  • so I'm getting how sockets work now. I'm looking at tutorials on youtube and stuff. but I see the classes they use are those classes with the Main() which you run and stop at any time. my Question is on a JSF project which I deploy on a server, how do I call a class that opens up a port( using a socket) when the app is deployed. I'm sorry if I'm being unclear. LMK and I'll try to rephrase. – Myy Jan 12 '12 at 06:07
  • +1 for 'recommendation' rather than a 'standard' - all too true. – Paul Bellora May 04 '13 at 00:50
1

Over a year old so you probably figured it all out, but an Enterprise Service Bus (ESB) is a type of middleware (when you think of software, there is back-end i.e. Database/Analytics/Admin Tools and front-end i.e. App/WebApp/GUI displayed to and interacted with end-user), middleware sits in between and helps perform integration or separation/coordination of tasks. Apache ServiceMix (an ESB which contains Apache Camel routing engine) is probably what you want and can be used to implement a number of different Enterprise Integration Patterns such as "Message Routing" (the one you want).

Apache Camel has a built-in HL7 v2 Message parser (uses HAPI) which is the Tab-Separated variant of HL7: http://camel.apache.org/hl7.html

For HL7 v3 messages which are in XML format you can use the toolkits available here under v3 utilities: http://www.hl7.org/participate/toolsandresources.cfm?ref=nav

There are both server (message listening and reading) and client (message creation and sending) examples.

bcmoney
  • 2,889
  • 1
  • 24
  • 30
0

"Listener" is usually an event listener in Java.

In the example you posted a link to, you have a server class, which handles the business of opening a network socket and waiting for messages to arrive.

The Application objects are the event listeners. These are added to an internal collection of the server class (in this case, with additional parameters that tell the server which listeners to route which classes of HL7 message to).

Each Application class must implement a particular interface - this constitutes the event listener. The SimpleServer class will call the methods of this interface ; processMessage() ; in order to perform actions based on message content, you write a class that implements this interface, and pass instances of it to the server class. In the processMessage() method, you perform all the required actions.

Since you can register multiple listeners, you can implement a number of actions, e.g. you could have two listeners for ADT A01 messages (admit patient) ; one that booked them in, and one that assigned them a bed.

Adrian
  • 2,244
  • 18
  • 20
  • hey Adrian, I followed the tutorial here http://www.java-tips.org/java-tutorials/tutorials/introduction-to-servlet-listener-using-eclipse-5.html – Myy Jan 11 '12 at 23:12
  • It basically tellme to add some listener tags in my xml, and then create a class that implements ServletContextListener.Does that mean I have to add the SimpleServerclass ( which uses Sockets) in the Initialize funcion of that class so that it runs once I run my app? – Myy Jan 11 '12 at 23:14
  • nvm, according to erica that listener has nothing to do with the listener I need. Would you happen to have a link to a good example I can follow on how to add the correct type of listener to a JSF project? – Myy Jan 12 '12 at 05:54
0

I would suggest looking at Mirth Connect http://www.mirthcorp.com/community/mirth-connect as your HL7 message integration engine. Internally it makes use of HAPI.

Vineet Bhatia
  • 2,469
  • 4
  • 30
  • 28
  • yes I saw mirth and it's pretty cool, I might end up using that but I want to try and intergrate the listerner for the messages to my system. because all it's going to do is basically receieve lab reports. so Mirth is my plan B because it's a stand alone app anyways right? – Myy Jan 07 '12 at 20:55