title: This method is not applicable inside the app server when trying to set a listener for a JMS queue
body: <p>I am trying JMS 2.0 so I can decide if it is worth applying in my project. I could successfully create a send/receive application.</p>
  
  <p>Now I would like to have listeners that will receive the message as soon as it is available on the queue (my final goal is to have different listeners to the same queue, each with a different message selector.</p>
  
  <p>Currently I have this class:</p>
  
  <pre><code>package learning.jms;
  
  
  import java.io.Serializable;
  
  import javax.annotation.PostConstruct;
  import javax.annotation.Resource;
  import javax.enterprise.context.RequestScoped;
  import javax.enterprise.context.SessionScoped;
  import javax.faces.application.FacesMessage;
  import javax.faces.context.FacesContext;
  import javax.inject.Inject;
  import javax.inject.Named;
  import javax.jms.JMSConnectionFactory;
  import javax.jms.JMSConsumer;
  import javax.jms.JMSContext;
  import javax.jms.JMSException;
  import javax.jms.JMSRuntimeException;
  import javax.jms.Message;
  import javax.jms.MessageListener;
  import javax.jms.Queue;
  
  @Named(value="senderBean")
  @SessionScoped
  public class SenderBean implements Serializable {
  
      /**
       * 
       */
      private static final long serialVersionUID = 1L;
  
      @Resource(mappedName="queues/myQueue")
      private transient Queue myQueue;
  
      @Inject
      @JMSConnectionFactory("java:/DefaultJMSConnectionFactory")
      private transient JMSContext context;
  
      private String messageText;
  
      private int nextType = 3;
      private transient JMSConsumer consumer;
      private transient JMSConsumer consumer2;
      private transient JMSConsumer consumer3;
  
      public SenderBean() {
      }
  
      @PostConstruct
      public void setUp(){
  
      }
  
      public String getMessageText() {
          return messageText;
      }
  
      public void setMessageText(String messageText) {
          this.messageText = messageText;
      }
  
      public void sendJMSMessageToMyQueue() {
          try {
  
              consumer = context.createConsumer(myQueue, "type=1");
              consumer.setMessageListener(new ListenerTypeOne());
  
  //          consumer2 = context.createConsumer(myQueue, "type=2");
  //          consumer2.setMessageListener(new ListenerTypeTwo());
  //          
  //          consumer3 = context.createConsumer(myQueue, "type=3");
  //          consumer3.setMessageListener(new ListenerTypeThree());
  
             String text = "Message from producer: " + messageText;
             Message m1 = context.createTextMessage(text);
             m1.setIntProperty("type", nextType);
  
             System.out.println("producer sending msg type " + nextType + "value: " + text);
  
             nextType = (nextType++%3)+1;
  
  
             context.createProducer().send(myQueue, m1);
  
             FacesMessage facesMessage =
                     new FacesMessage("Sent message: " + text);
             FacesContext.getCurrentInstance().addMessage(null, facesMessage);
         } catch (JMSRuntimeException | JMSException t) {
              System.out.println(t.toString());
         }
     }
  
      private class ListenerTypeOne implements MessageListener{
  
          @Override
          public void onMessage(Message msg) {
              try {
                  System.out.println("Msg received by typeOne:" + msg.getBody(String.class));
              } catch (JMSException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
          }
      }
  
      private class ListenerTypeTwo implements MessageListener{
  
          @Override
          public void onMessage(Message msg) {
              try {
                  System.out.println("Msg received by typeTwo:" + msg.getBody(String.class));
              } catch (JMSException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
  
          }
      }
  
      private class ListenerTypeThree implements MessageListener{
  
          @Override
          public void onMessage(Message msg) {
              try {
                  System.out.println("Msg received by typeThree:" + msg.getBody(String.class));
              } catch (JMSException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
  
          }
      }
  }
  </code></pre>
  
  <p>I commented out two consumers, so I could focus on making one work. 
  I keep getting the following exception on the setMessageListener line:</p>
  
  <pre><code> javax.jms.IllegalStateException: This method is not applicable inside the application server. See the J2EE spec, e.g. J2EE1.4 Section 6.6
      at org.hornetq.ra.HornetQRASession.checkStrict(HornetQRASession.java:1647)
      at org.hornetq.ra.HornetQRAMessageConsumer.setMessageListener(HornetQRAMessageConsumer.java:124)
      at org.hornetq.jms.client.HornetQJMSConsumer.setMessageListener(HornetQJMSConsumer.java:68)
  </code></pre>
  
  <p>I have no idea what could be causing this and my searches are not giving me any extra information.
  I guess it could be something related to the fact that one componen should have no more than one active session. In this case, how could I create multiple listeners to listen to the queue?</p>
  
  <p>(if important: I am using Wildfly 8)</p>
  
  <p><strong>EDIT</strong>
  I've extracted the listener creation to a separate bean and still teh same error:</p>
  
  <pre><code>package learning.jms;
  
  
  import javax.annotation.PostConstruct;
  import javax.annotation.Resource;
  import javax.enterprise.context.ApplicationScoped;
  import javax.inject.Inject;
  import javax.jms.JMSConnectionFactory;
  import javax.jms.JMSConsumer;
  import javax.jms.JMSContext;
  import javax.jms.JMSException;
  import javax.jms.Message;
  import javax.jms.MessageListener;
  import javax.jms.Queue;
  
  
  @ApplicationScoped
  public class ListenerOne {
      @Inject
      @JMSConnectionFactory("java:/DefaultJMSConnectionFactory")
      private JMSContext context;
  
      @Resource(mappedName="queues/myQueue")
      private Queue myQueue;
  
  
      private JMSConsumer consumer;
  
      public void setUp() {
          consumer = context.createConsumer(myQueue, "type=1");
          consumer.setMessageListener(new ListenerTypeOne());
  
  
          System.out.println("working");
      }
  
      private class ListenerTypeOne implements MessageListener{
  
          @Override
          public void onMessage(Message msg) {
              try {
                  System.out.println("Msg received by typeOne:" + msg.getBody(String.class));
              } catch (JMSException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
          }
      }
  }
  </code></pre>