/*
 * http://localhost:8080/AppContext
 */
String host = "localhost";
int port = 8080;
String uri = "/AppContext";

// Create a parser
Parser parser = PipeParser.getInstanceWithNoValidation();

// Create a client
HohClientSimple client = new HohClientSimple(host, port, uri, parser);

// Optionally, if credentials should be sent, they 
// can be provided using a credential callback
IAuthorizationClientCallback authCalback = new SingleCredentialClientCallback("ausername", "somepassword");
client.setAuthorizationCallback(authCalback);

// The ISendable defines the object that provides the actual
// message to send
ADT_A01 adt = new ADT_A01();
adt.initQuickstart("ADT", "A01", "T");
// .. set other values on the message ..

// The MessageSendable provides the message to send 
ISendable sendable = new MessageSendable(adt);

try {
	// sendAndReceive actually sends the message
	IReceivable<Message> receivable = client.sendAndReceiveMessage(sendable);
	
	// receivavle.getRawMessage() provides the response
	Message message = receivable.getMessage();
	System.out.println("Response was:\n" + message.encode());
	
	// IReceivable also stores metadata about the message
	String remoteHostIp = (String) receivable.getMetadata().get(MessageMetadataKeys.REMOTE_HOST_ADDRESS);
	System.out.println("From:\n" + remoteHostIp);
	
	/*
	 * Note that the client may be reused as many times as you like,
	 * by calling sendAndReceiveMessage repeatedly
	 */
	
} catch (DecodeException e) {
	// Thrown if the response can't be read
	e.printStackTrace();
} catch (IOException e) {
	// Thrown if communication fails
	e.printStackTrace();
} catch (EncodeException e) {
	// Thrown if the message can't be encoded (generally a programming bug)
	e.printStackTrace();
}

/**
 * Example servlet implementation which receives HL7 messages
 * and uses HAPI to process them.
 */
public class ExampleHl7OverHttpServletWithOneApplication extends HohServlet {

	/**
	 * Initialise the servlet
	 */
	@Override
	public void init(ServletConfig theConfig) throws ServletException {
		
		/* Servlet should be initialized with an instance of
		 * ReceivingApplication, which handles incoming messages 
		 */
		setApplication(new MyApplication());
		
	}

	/**
	 * The application does the actual processing
	 */
	private class MyApplication implements ReceivingApplication
	{

		/**
		 * processMessage is fired each time a new message 
		 * arrives. 
		 * 
		 * @param theMessage The message which was received
		 * @param theMetadata A map containing additional information about
		 *                    the message, where it came from, etc.  
		 */
		public Message processMessage(Message theMessage, Map<String, Object> theMetadata) throws ReceivingApplicationException, HL7Exception {
			System.out.println("Received message:\n" + theMessage.encode());

			// .. process the message ..
			
			/*
			 * Now reply to the message
			 */
			Message response;
			try {
				response = theMessage.generateACK();
			} catch (IOException e) {
				throw new ReceivingApplicationException(e);
			}
			
			/*
			 * If something goes horribly wrong, you can throw an 
			 * exception and an HTTP 500 error will be generated.
			 * However, it is preferable to return a normal HL7 ACK 
			 * message with an "AE" response code to note an error. 
			 */
			boolean somethingFailed = false;
			if (somethingFailed) {
				throw new ReceivingApplicationException("");
			}

			/*
			 * It is better to return an HL7 message with an AE response
			 * code. This will still be returned by the transport with
			 * an HTTP 500 status code, but an HL7 message will still 
			 * be propagated up. 
			 */
			if (somethingFailed) {
				try {
					response = theMessage.generateACK("AE", new HL7Exception("There was a problem!!"));
				} catch (IOException e) {
					throw new ReceivingApplicationException(e);
				}
			}
			
			return response;
		}

		/**
		 * {@inheritDoc}
		 */
		public boolean canProcess(Message theMessage) {
			return true;
		}
		
	}
	
}

<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
    <servlet>
        <servlet-name>hl7_listener</servlet-name>
        <servlet-class>ca.uhn.hl7v2.examples.hoh.ExampleHl7OverHttpServletWithOneApplication</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hl7_listener</servlet-name>
        <url-pattern>/hl7list</url-pattern>
    </servlet-mapping>
</web-app>

/*
 * Sending a message with HAPI and HL7 over HTTP. First
 * an LLP instance is created. Note that you must tell
 * the LLP class whether it will be used in a client
 * or a server.
 */
DefaultHapiContext ctx = new DefaultHapiContext();

// Create an HoH LLP for the context
LowerLayerProtocol llp = new Hl7OverHttpLowerLayerProtocol(ServerRoleEnum.CLIENT);
ctx.setLowerLayerProtocol(llp);

// Use the LLP in a HapiContext to get a client connection
String host = "localhost";
int port = 8080;
boolean tls = false;
Connection connection = ctx.newClient(host, port, tls);

// Create a message to send
ADT_A01 message = new ADT_A01();
message.initQuickstart("ADT", "A01", "P");
// ... populate message ...

// Send the message
Message response = connection.getInitiator().sendAndReceive(message);

/*
 * Sending a message with HAPI and HL7 over HTTP. First
 * an LLP instance is created. Note that you must tell
 * the LLP class whether it will be used in a client
 * or a server.
 */
LowerLayerProtocol llp;
llp = new Hl7OverHttpLowerLayerProtocol(ServerRoleEnum.SERVER);

/* 
 * Create the server, and pass in the HoH LLP instance
 * 
 * Note that the HoH LLP implementation will not
 * work in two-socket servers
 */
PipeParser parser = PipeParser.getInstanceWithNoValidation();
int port = 8080;
SimpleServer server = new SimpleServer(port, llp, parser);

// Register an application to the server, and start it
// You are now ready to receive HL7 messages!
server.registerApplication("*", "*", new DefaultApplication());
server.start();