JMS (Transaction ???) problem, consumer receives all messages at once.

Question

Hallo, I have an application which implements asynch communication between the web and business layer using JMS.
On a page a user can upload files, which are processed by the backend. For large files this can be a long running process, thats why we use JMS to send the file asynchronously and use JMS to update progress information on the page.
The application works fine on JBoss 6 with HornetMQ.
After porting to Weblogic I see consistently a strange phenomenon. The update messages from the processing backend logic are send as expected. But the receiver does not receive one message after another but receives all the messsages almost at once after only the producer has sent the last message.
For me this is totally unexpected behavior and of course our progress bar on the page does not work properly, but merely jumps from 0 to 100% after the data has been processed.
It looks like the consumer waits until the producer has finished its transaction. But how can this be possibly? I have learned that transaction never span producer - messagesystem - consumer.
Example Code:
Producer:
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.log4j.Logger;
import com.sun.tools.ws.wsdl.document.jaxws.Exception;
import dsde.core.aspects.DsdeException;
import dsde.core.aspects.ExceptionHandler;
import dsde.core.entity.Data;
@Stateless
@Interceptors(ExceptionHandler.class)
public class ParserBean implements Parser {
     private Logger log = Logger.getLogger(this.getClass());
     @EJB
     private DataDAO dataDAO;
     //Weblogic
     @Resource(mappedName="jms.BackQueue")
     //Jboss
     //@Resource(mappedName="queue/dsdeBackQueue")
     private Destination backQueue;
     //Weblogic
     @Resource(mappedName="jms.dsdeConnectionFactory")
     //JBoss
     //@Resource(mappedName="XAConnectionFactory")
     private ConnectionFactory connectionFactory;
     private Connection connection;
     @Override
     public void parse(String text, String description, String sessionId) throws DsdeException{
          double percentDone = 0;
          double j = 0.0;
          //Simuliere was langdauerndes, schwieriges
          for (int i=0; i < text.length(); i++) {
               j = i;
               percentDone = j / text.length() * 100;
               try {
                    Thread.sleep(1000);
               } catch (InterruptedException e) {
                    log.error(e);
               if (i % 2 == 0) {
                    //periodisch das Frontend mit dem Fortschritt updaten
                    sendFeedback((int)percentDone, sessionId);
          //Zum Schluss noch senden dass wir fertig sind
          //Sonst wird der Send Button nicht wieder aktiv
          percentDone=100;
          sendFeedback((int)percentDone, sessionId);
          //Jetzt wird noch richtig geparsed :-)
          String[] words = text.split(" ");
          //Entity konstruieren
          Data data = new Data(description, words);
          //Das Ergebnis in die Datenbank schreiben
          dataDAO.saveData(data);
     private void sendFeedback(int percentDone, String sessionId) {
          Session session = null;
          try {
               session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
               MessageProducer producer = session.createProducer(backQueue);
               producer.setTimeToLive(50000);
               producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
               TextMessage message = session.createTextMessage();
               message.setJMSCorrelationID(sessionId);
               message.setText("" + percentDone);
               producer.send(message);
               log.info("ParserBean has sent " + percentDone);
          } catch (JMSException e) {
               log.error(e);
          } finally {
               if (session != null) {
                    try {
                         session.close();
                    } catch (JMSException e) {
                         log.error(e);
     @PostConstruct
     public void init(){
          try {
               connection = connectionFactory.createConnection();
          } catch (JMSException e) {
               log.error(e);
     @PreDestroy
     public void close() {
          try {
               connection.close();
          } catch (JMSException e) {
               log.error(e);
}Consumer:
import javax.annotation.ManagedBean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.http.HttpSession;
import org.apache.log4j.Logger;
@ManagedBean
@SessionScoped
public class FeedbackReceiverBean implements MessageListener {
     private Logger log = Logger.getLogger(this.getClass());
     //jndi names of managed objects
     private String connectionFactoryName;
     private String queueName;
     private Connection connection;
     private Session session;
     private int percent;
     private boolean disabled;
     public boolean isDisabled() {
          return disabled;
     public void setDisabled(boolean disabled) {
          this.disabled = disabled;
     public int getPercent() {
          return percent;
     public void setPercent(int percent) {
          this.percent = percent;
     public void setConnectionFactoryName(String connectionFactoryName) {
          this.connectionFactoryName = connectionFactoryName;
     public void setQueueName(String queueName) {
          this.queueName = queueName;
     @PostConstruct
     public void init() throws NamingException, JMSException {
          FacesContext facesContext = FacesContext.getCurrentInstance();
          HttpSession httpSession = (HttpSession) facesContext.getExternalContext().getSession(false);
          String sessionId = httpSession.getId();
          Context context = new InitialContext();
          ConnectionFactory connectionFactory = (ConnectionFactory) context.lookup(this.connectionFactoryName);
          Queue queue = (Queue) context.lookup(this.queueName);
          this.connection = connectionFactory.createConnection();
          this.session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
          String filter = "JMSCorrelationID = '" + sessionId + "'";
          MessageConsumer consumer = session.createConsumer(queue, filter);
          consumer.setMessageListener(this);
          connection.start();
     @PreDestroy
     public void close() throws JMSException {
          this.session.close();
          this.connection.close();
     @Override
     public void onMessage(Message message) {
          if (message instanceof TextMessage) {
               TextMessage textMessage = (TextMessage) message;
               try {
                    this.percent = Integer.parseInt(textMessage.getText());
                    if (percent >= 100) {
                         this.disabled = false;
                    log.info("Prozent " + percent);
               } catch (JMSException e) {
                    log.error(e);
          else {
               log.error(message.toString() + " is no TextMessage");
     public void disable() {
          this.disabled = true;
}Configuration:
<?xml version='1.0' encoding='UTF-8'?>
<weblogic-jms xmlns="http://xmlns.oracle.com/weblogic/weblogic-jms" xmlns:sec="http://xmlns.oracle.com/weblogic/security" xmlns:wls="http://xmlns.oracle.com/weblogic/security/wls" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.oracle.com/weblogic/weblogic-jms http://xmlns.oracle.com/weblogic/weblogic-jms/1.1/weblogic-jms.xsd">
  <connection-factory name="dsdeConnectionFcatory">
    <default-targeting-enabled>true</default-targeting-enabled>
    <jndi-name>jms/dsdeConnectionFactory</jndi-name>
    <default-delivery-params>
      <default-delivery-mode>Persistent</default-delivery-mode>
      <default-time-to-deliver>0</default-time-to-deliver>
      <default-time-to-live>100</default-time-to-live>
      <default-priority>4</default-priority>
      <default-redelivery-delay>0</default-redelivery-delay>
      <send-timeout>10</send-timeout>
      <default-compression-threshold>2147483647</default-compression-threshold>
    </default-delivery-params>
    <client-params>
      <client-id-policy>Restricted</client-id-policy>
      <subscription-sharing-policy>Exclusive</subscription-sharing-policy>
      <messages-maximum>10</messages-maximum>
    </client-params>
    <transaction-params>
      <xa-connection-factory-enabled>true</xa-connection-factory-enabled>
    </transaction-params>
    <security-params>
      <attach-jmsx-user-id>false</attach-jmsx-user-id>
    </security-params>
  </connection-factory>
  <queue name="dsdeQueue">
    <sub-deployment-name>dsdeQueue</sub-deployment-name>
    <jndi-name>jms/dsdeQueue</jndi-name>
  </queue>
  <queue name="dsdeFeedbackQueue">
    <sub-deployment-name>dsdeFeedbackQueue</sub-deployment-name>
    <jndi-name>jms/dsdeFeedbackQueue</jndi-name>
  </queue>
  <queue name="dsdeBackQueue">
    <sub-deployment-name>dsdeBackQueue</sub-deployment-name>
    <jndi-name>jms/BackQueue</jndi-name>
  </queue>
</weblogic-jms>Any help would be greatly appreciated.
Thanks,
Hans

Answer 1

Thanks for posting your analysis!
I think your solution is probably best.
FYI: Your JMS session was never a "transacted" session. It's definitely confusing, but the term "transacted session" has a special meaning in JMS, it actually refers to a session that is not XA/JTA aware and instead maintains an internal local transaction that's scoped only to the current JMS session's operations. A transacted session is created by passing "true" to the first parameter of createSession, and such a session's local transaction is committed by calling session.commit() (which starts a new transaction). To further add to the confusion, I think that JEE servers are actually obligated to ignore requests to set the transacted flag to true -- WebLogic does this trick by secretly wrapping access to the JMS API when applications lookup JMS connection factories via a resource reference.
Regards,
Tom