import com.sun.xml.ws.transport.http.servlet.ServletAdapter;
import com.sun.xml.ws.transport.http.servlet.ServletAdapterList;
import com.sun.xml.ws.transport.http.servlet.SpringBindingList;
 
import java.io.IOException;
 
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnectionFactory;
 
 
/**
 * MDP that supports message driven webservice endpoints.
 */
public class MessageEndpoint implements MessageListener {
 
    /**
     * Constructor.
     * 
     * @param bindings
     * @param url
     * @param replyQueueFactory
     * @param replyQueue
     */
    public MessageEndpoint(final SpringBindingList bindings, String url, QueueConnectionFactory replyQueueFactory, Queue replyQueue) {
        ServletAdapterList adapterList = bindings.create();
        for (ServletAdapter adapter: adapterList) {
 
            if (url.equals(adapter.getValidPath())) {
                jmsAdapter = new JMSAdapter(adapter.getEndpoint());
            }
        }
 
        if (jmsAdapter == null) {
            throw new RuntimeException("URL not found in Spring defined endpoints. No adapter could be made to handle messages.");
        }
 
        this.replyQueue = replyQueue;
        this.replyQueueFactory = replyQueueFactory;
    }
 
 
    /** Adapter to handle messages. */
    private static volatile JMSAdapter jmsAdapter;
 
    /** Queue factory for return message. */
    private QueueConnectionFactory replyQueueFactory;
 
    /** Queue for return message. */
    private Queue replyQueue;
 
 
    /**
     * Handle a new message on the queue. Wraps the message in a JMS Connection and call the configured JMS adapter.
     * @param message the message
     */
    public void onMessage(final Message message) {
        try {
            // Hier komt de logica om een connection te maken, de connection weet waar de reply naar toe moet
            JMSConnectionImpl connection = new JMSConnectionImpl(message, replyQueueFactory, replyQueue);
            // Handle the message
            jmsAdapter.handle(connection);
        } catch (JMSException e) {
            throw new RuntimeException("Unexpected jms-error in MDP", e);
        } catch (IOException e) {
            throw new RuntimeException("Unexpected io-error in MDP", e);
        }
    }
}

import com.ibm.mq.jms.JMSC;
import com.ibm.mq.jms.MQQueue;
 
import com.sun.xml.ws.api.message.Packet;
import com.sun.xml.ws.api.server.WSEndpoint;
import com.sun.xml.ws.api.server.WebServiceContextDelegate;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
 
import java.security.Principal;
 
import javax.jms.BytesMessage;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
 
/**
 * Connection is used to store the incoming message and stream it from and
 * act as a holder for the response.
 * 
 */
public class JMSConnectionImpl implements WebServiceContextDelegate {
 
    /** Logger. */
    private static Log log = LogFactory.getLog(JMSConnectionImpl.class);
 
    /** Original ID of request message. */
    private String requestMessageJMSID;
 
    /** Inputstream buffer to stream incoming message. */
    private byte[] inputStreamBuffer;
 
    /** Number of bytes to ignore at start of buffer for inputstream. */
    private int inputStreamRemoveBytes = 0;
 
    /** Outputstream to temporary store outgoing message. */
    private ByteArrayOutputStream outputStream;
 
    /** ConnectionFactory for queue for outgoing message. */
    private QueueConnectionFactory replyQueueFactory;
 
    /** Queue for outgoing message. */
    private Queue replyQueue;
 
    /**
     * Constructor.
     * 
     * @param requestMessage incoming message
     * @param replyQueueFactory connectionfactory for outgoing message
     * @param replyQueue queue for outgoing message
     * @throws JMSException on jms error
     */
    public JMSConnectionImpl(final Message requestMessage, final QueueConnectionFactory replyQueueFactory, final Queue replyQueue) throws JMSException {
        // Prepare outputstream
        outputStream = new ByteArrayOutputStream();
 
        // Store original JMS ID 
        requestMessageJMSID = requestMessage.getJMSCorrelationID();
 
        // Prepare inputstream buffer
        inputStreamBuffer = null;
 
        if (requestMessage instanceof BytesMessage) {
            log.debug( "Received bytes message ..." ) ;
            inputStreamBuffer = new byte[(int)((BytesMessage)requestMessage).getBodyLength()];
            ((BytesMessage)requestMessage).readBytes(inputStreamBuffer);
        } else if (requestMessage instanceof TextMessage) {
            log.debug( "Received text message ..." ) ;
            inputStreamBuffer = ((TextMessage)requestMessage).getText().getBytes();
        } else {
            throw new JMSException("Invalid message format: " + requestMessage.getClass().getName());
        }
        
//        log.debug( "BOM check byte 0: " + inputStreamBuffer[0] );
//        log.debug( "BOM check byte 1: " + inputStreamBuffer[1] );
//        log.debug( "BOM check byte 2: " + inputStreamBuffer[2] );
//        log.debug( "BOM check byte 3: " + inputStreamBuffer[3] );
//        
//
//        // Remove BOM (Byte Order Mark)
//        //
//        // +-----------------------------------------+
//        // | Bytes         | Encoding Form           |
//        // +-----------------------------------------+
//        // | 00 00 FE FF   | UTF-32, big-endian      |
//        // | FF FE 00 00   | UTF-32, little-endian   |
//        // | FE FF         | UTF-16, big-endian      |
//        // | FF FE         | UTF-16, little-endian   |
//        // | EF BB BF      | UTF-8                   |
//        // +-----------------------------------------+
//        if (inputStreamBuffer[0] == (byte)0xEF && inputStreamBuffer[1] == (byte)0xBB && inputStreamBuffer[1] == (byte)0xBF) {
//            inputStreamRemoveBytes = 3;
//            log.debug("Removing first three bytes of stream because of BOM.");
//        } else if ((inputStreamBuffer[0] == (byte)0x00 && inputStreamBuffer[1] == (byte)0x00 && inputStreamBuffer[2] == (byte)0xFE && inputStreamBuffer[3] == (byte)0xFF) || (inputStreamBuffer[0] == (byte)0xFF && inputStreamBuffer[1] == (byte)0xFE && inputStreamBuffer[2] == (byte)0x00 && inputStreamBuffer[3] == (byte)0x00)) {
//            inputStreamRemoveBytes = 4;
//            log.warn("Removing first four bytes of stream because of BOM (untested!).");
//        } else if ((inputStreamBuffer[0] == (byte)0xFE && inputStreamBuffer[1] == (byte)0xFF) || (inputStreamBuffer[0] == (byte)0xFF && inputStreamBuffer[1] == (byte)0xFE)) {
//            inputStreamRemoveBytes = 2;
//            log.warn("Removing first two bytes of stream because of BOM (untested!).");
//        }
//        else {
//            log.debug( "No BOM detected." ) ;
//        }
 
        inputStreamRemoveBytes = new String( inputStreamBuffer ).indexOf( "<?xml") ;
        log.debug("Removing first " + inputStreamRemoveBytes + " of stream because of BOM or useless crap in message.");
 
        if( inputStreamRemoveBytes == -1 ) {
            log.warn( "Message does not contain <?xml something will go wrong" ) ;
            inputStreamRemoveBytes = 0 ;
        }
 
 
        // Log incoming message
        log.debug("Message received on queue:\n" + new String(inputStreamBuffer));
 
        // Configuration for transmission
        this.replyQueueFactory = replyQueueFactory;
        this.replyQueue = replyQueue;
 
        if (this.replyQueue instanceof MQQueue) {
            log.debug("Setting replyQueue target client to non-jms");
            ((MQQueue)this.replyQueue).setTargetClient(JMSC.MQJMS_CLIENT_NONJMS_MQ);
        }
    }
 
    /**
     * Returns a stream to the incoming message.
     * @return A stream to the incoming message.
     */
    public InputStream getInputStream() throws JMSException {
 
        ByteArrayInputStream bais = new ByteArrayInputStream(inputStreamBuffer, inputStreamRemoveBytes, inputStreamBuffer.length - inputStreamRemoveBytes);
        return (bais);
    }
 
    /**
     * Retuns a stream that the outgoing message can be written to.
     * @return A stream that the outgoing message can be written to.
     */
    public OutputStream getOutputStream() {
        return (outputStream);
    }
 
    /**
     * Transmit the outgoing message.
     * 
     * @throws JMSException on jms errors
     * @throws IOException on read/write errors
     */
    public void transmit() throws JMSException, IOException {
        if (outputStream != null) {
            outputStream.flush();
        }
 
        QueueConnection connection = replyQueueFactory.createQueueConnection();
 
        try {
            QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
 
            try {
                //                BytesMessage replyMessage = jmsSession.createBytesMessage();
                //                byte[] content = ((ByteArrayOutputStream)getOutputStream()).toByteArray();
                //                if (content.length > 0) {
                //                    replyMessage.writeBytes(content);
                //                }
 
                TextMessage replyMessage = session.createTextMessage();
                replyMessage.setJMSCorrelationID(requestMessageJMSID);
                replyMessage.setText(new String(outputStream.toByteArray()));
                //                System.out.println( "Reply message id : \n" + replyMessage.getJMSMessageID() );
                //                System.out.println( "Reply message correlation id : \n" + replyMessage.getJMSCorrelationID() );
 
                QueueSender sender = session.createSender(replyQueue);
                try {
                    sender.send(replyMessage);
 
                    log.debug("Message sent via queue: \n" + replyMessage.getText());
                } finally {
                    sender.close();
                }
            } finally {
                session.close();
            }
        } finally {
            connection.close();
        }
    }
 
    /**
     * NOT IMPLEMENTED: for WebServiceContextDelegate. 
     * 
     * @param packet packet
     * @return null
     */
    public Principal getUserPrincipal(final Packet packet) {
        return null;
    }
 
    /**
     * NOT IMPLEMENTED: for WebServiceContextDelegate. 
     * 
     * @param packet packet
     * @param role role
     * @return false
     */
    public boolean isUserInRole(final Packet packet, final String role) {
        return false;
    }
 
    /**
     * NOT IMPLEMENTED: for WebServiceContextDelegate. 
     * 
     * @param packet packet
     * @param wsEndpoint endpoint
     * @return null
     */
    public String getEPRAddress(final Packet packet, final WSEndpoint wsEndpoint) {
        return null;
    }
 
    /**
     * NOT IMPLEMENTED: for WebServiceContextDelegate. 
     * 
     * @param packet packet
     * @param wsEndpoint endpoint
     * @return null
     */
    public String getWSDLAddress(final Packet packet, final WSEndpoint wsEndpoint) {
        return null;
    }
}

import com.sun.xml.ws.api.message.Packet;
import com.sun.xml.ws.api.pipe.Codec;
import com.sun.xml.ws.api.server.TransportBackChannel;
import com.sun.xml.ws.api.server.WSEndpoint;
import com.sun.xml.ws.api.server.WSEndpoint.PipeHead;
 
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
 
import java.io.InputStreamReader;
import java.io.OutputStream;
 
import java.io.PrintStream;
 
import javax.jms.JMSException;
 
 
/**
 * Adapter for JMS transport.
 */
public class JMSAdapter implements TransportBackChannel {
 
    /** The WS endpoint. */
    private WSEndpoint endpoint;
 
    /** Codec used the encode/decode packets. */
    private Codec codec;
 
    /** Handle the call to the endpoint. */
    private PipeHead head;
 
    /**
     * Constructor.
     * @param endpoint the ws endpoint
     */
    public JMSAdapter(final WSEndpoint endpoint) {
        this.endpoint = endpoint;
        codec = endpoint.createCodec();
        head = endpoint.createPipeHead();
    }
 
    /**
     * Handle the request stored in the given JSM connection.
     * 
     * @param connection JMS connection
     * @throws IOException on read/write erros
     * @throws JMSException on jms errors
     */
    public void handle(final JMSConnectionImpl connection) throws IOException, JMSException {
 
        //System.out.println( "Decode request ..." ) ;
 
        try {
            // Decode request
            Packet packet = new Packet();
            codec.decode(connection.getInputStream(), "text/xml", packet);
            //System.out.println( "Request packet: " + packet ) ;
 
            // Handle request
            //System.out.println( "Handle request ..." ) ;
            packet = head.process(packet, connection, this);
            //System.out.println( "Response package: " + packet ) ;
 
            // Encode response
            //System.out.println( "Encode response ... " ) ;
            OutputStream os = connection.getOutputStream();
            codec.encode(packet, os);
            os.close();
        } catch (Exception e) {
            // Create error message, move to dead letter queue
            OutputStream os = connection.getOutputStream();
            PrintStream ps = new PrintStream(os);
            ps.println("Onverwachte fout tijdens transport opgetreden: " + e.getMessage());
 
            BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line = null;
 
            while ((line = br.readLine()) != null) {
                ps.println(line);
            }
 
            os.close();
        }
 
        // Transmit  reponse
        //System.out.println( "Transmit response ... " ) ;
        connection.transmit();
 
        //System.out.println( "Done ..." ) ;
    }
 
    /**
     * NOT USED: Close the connection.
     */
    public void close() {
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byName"
       xmlns:ws= "http://jax-ws.dev.java.net/spring/core"
       xmlns:wss="http://jax-ws.dev.java.net/spring/servlet" 
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
                           http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core.xsd
                           http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet.xsd" >
 
    <!-- Service implementations -->
    <bean name="MyHTTPServiceImpl" class="foo.MyHTTPServiceImpl" />
    <bean name="MyJMSServiceImpl" class="foo.MyJMSServiceImpl" />
       
    <!-- Service mapping -->
    <wss:bindings id="jax-ws.http">
        <wss:bindings>
            <wss:binding url="/someUrl"> <!-- This URL is exposed in web.xml -->
                <wss:service>
                    <ws:service bean="#MyHTTPServiceImpl"
                                serviceName="ns1:MyService"
                                portName="ns1:MyHTTPPort"
                                xmlns:ns1="http://some.namespace/something"
                                >
                    </ws:service>
                </wss:service>
            </wss:binding>
            <!-- Not accessable via web because not exposed in web.xml -->
            <wss:binding url="/someOtherUrl" >
                <wss:service>
                    <ws:service bean="#MyJMSServiceImpl"
                                serviceName="ns1:MyService"
                                portName="ns1:MyJMSPort"
                                xmlns:ns1="http://some.namespace/something"
                                >
                    </ws:service>
                </wss:service>
            </wss:binding>
        </wss:bindings>
    </wss:bindings>
    
    <!-- Queue Connection Factory -->
    <bean id="connectionFactory" class="com.ibm.mq.jms.MQXAQueueConnectionFactory" />
 
    <!-- Request queue -->
    <bean id="vraagQueue" class="com.ibm.mq.jms.MQQueue">
        <property name="baseQueueName" value="requestQueue" />
    </bean>
 
    <!-- Response queue -->
    <bean id="antwoordQueue" class="com.ibm.mq.jms.MQQueue">
        <property name="baseQueueName" value="responseQueue" />
    </bean>
    
    <!-- Endpoint implementation -->
    <bean id="messageEndpoint" class="nl.uwv.generiek.ws.jms.MessageEndpoint" >
        <constructor-arg ref="jax-ws.http" type="com.sun.xml.ws.transport.http.servlet.SpringBindingList" />
        <constructor-arg type="java.lang.String" value="/someOtherUrl" />
        <constructor-arg type="javax.jms.QueueConnectionFactory" ref="connectionFactory" />
        <constructor-arg type="javax.jms.Queue" ref="antwoordQueue" />
    </bean>
    
    <!-- JMS Transaction manager -->
    <bean id="jmsTransactionManager" class="org.springframework.jms.connection.JmsTransactionManager">
        <property name="connectionFactory" ref="connectionFactory" />
    </bean>
    
    <!-- Message listener container, Websphere MQ is JMS 1.02 compliant -->
    <bean id="listenerContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer102">
        <property name="concurrentConsumers" value="5"/>
        <property name="sessionTransacted" value="true" />
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="destination" ref="vraagQueue" />
        <property name="messageListener" ref="messageEndpoint" />
        <property name="receiveTimeout" value="5000" />
        <property name="transactionManager" ref="jmsTransactionManager" />
    </bean>
</beans>