@Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
     throws ServletException, IOException {
   resp.setContentType("text/html");
   PrintWriter out = resp.getWriter();
   Connection connection = null;
   out.write("<h1>Produce JMS ObjectMessages</h1>");
   try {
     connection = connectionFactory.createConnection();
     Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
     MessageProducer producer = session.createProducer(queue);
     ObjectMessage message = session.createObjectMessage();
     MyResource resource = new MyResource("This is my resource");
     message.setObject(resource);
     producer.send(message);
     out.write("<p>Send JMS Message with object: " + resource + "</p>");
   } catch (JMSException e) {
     e.printStackTrace();
     out.write("<h2>A problem occurred during the delivery of this message</h2>");
     out.write("</br>");
     out.write(
         "<p><i>Go your the JBoss Application Server console or Server log to see the error stack trace</i></p>");
   } finally {
     if (connection != null) {
       try {
         connection.close();
       } catch (JMSException e) {
         e.printStackTrace();
       }
     }
     if (out != null) {
       out.close();
     }
   }
 }
Example #2
0
 public static synchronized void resetInstance() {
   if (jmsProducer != null) {
     if (jmsProducer.topicConnection != null) {
       try {
         jmsProducer.topicConnection.stop();
       } catch (JMSException ex) {
         ex.printStackTrace();
       }
     }
     if (jmsProducer.producer != null) {
       try {
         jmsProducer.producer.close();
       } catch (JMSException ex) {
         ex.printStackTrace();
       }
     }
     if (jmsProducer.session != null) {
       try {
         jmsProducer.session.close();
       } catch (JMSException ex) {
         ex.printStackTrace();
       }
     }
     if (jmsProducer.topicConnection != null) {
       try {
         jmsProducer.topicConnection.close();
       } catch (JMSException ex) {
         ex.printStackTrace();
       }
     }
   }
   jmsProducer = null;
 }
Example #3
0
 public void stop() {
   try {
     session.close();
   } catch (JMSException e) {
     e.printStackTrace();
   }
   try {
     conn.close();
   } catch (JMSException e) {
     e.printStackTrace();
   }
 }
  public void receiveMessage() {
    Properties prop = new Properties();
    prop.put(InitialContext.INITIAL_CONTEXT_FACTORY, "org.exolab.jms.jndi.InitialContextFactory");
    prop.put(InitialContext.PROVIDER_URL, "tcp://192.168.122.1:3035/");

    try {
      context = new InitialContext(prop);
      factory = (ConnectionFactory) context.lookup("ConnectionFactory");
      destination = (Destination) context.lookup("queue1");

      connection = factory.createConnection();
      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      consumer = session.createConsumer(destination);
      connection.start();

      Message message = consumer.receive();
      if (message instanceof ObjectMessage) {
        ObjectMessage object = (ObjectMessage) message;
        System.out.println("Received: " + object.getObject());
      }

    } catch (NamingException e) {
      e.printStackTrace();
    } catch (JMSException e) {
      e.printStackTrace();
    }

    try {
      if (consumer != null) consumer.close();
    } catch (JMSException e) {
      e.printStackTrace();
    }

    try {
      if (session != null) session.close();
    } catch (JMSException e) {
      e.printStackTrace();
    }

    try {
      if (connection != null) connection.close();
    } catch (JMSException e) {
      e.printStackTrace();
    }

    try {
      if (context != null) context.close();
    } catch (NamingException e) {
      e.printStackTrace();
    }
  }
  public void onMessage(final Message message) {
    try {
      // Step 9. We know the client is sending a text message so we cast
      TextMessage textMessage = (TextMessage) message;

      // Step 10. get the text from the message.
      String text = textMessage.getText();

      System.out.println("message " + text + " received");

      if (!textMessage.getJMSRedelivered()) {
        // Step 11. On first delivery get the transaction, take a look, and throw an exception
        Transaction tx = tm.getTransaction();

        if (tx != null) {
          System.out.println("something is wrong, there should be no global transaction: " + tx);
        } else {
          System.out.println(
              "there is no global transaction, although the message delivery is using a local transaction");
          System.out.println("let's throw an exception and see what happens");
          throw new RuntimeException("DOH!");
        }
      } else {
        // Step 12. Print the message
        System.out.println(
            "The message was redelivered since the message delivery used a local transaction");
      }

    } catch (JMSException e) {
      e.printStackTrace();
    } catch (SystemException e) {
      e.printStackTrace();
    }
  }
  @Override
  public void blogracyContentReceived(BlogracyContent message) {
    if (message == null) return;

    TextMessage response;
    try {
      response = session.createTextMessage();

      JSONObject record = new JSONObject();
      record.put("request", "contentReceived");
      record.put("senderUserId", message.getSenderUserId());
      record.put("contentRecipientUserId", message.getContentRecipientUserId());

      JSONObject content = new JSONObject(message.getContent());
      record.put("contentData", content);
      record.put("contentId", content.getJSONObject("object").getString("id"));

      response.setText(record.toString());

      producer.send(outgoingQueue, response);
    } catch (JMSException e) {
      e.printStackTrace();
    } catch (JSONException e) {
      e.printStackTrace();
    }
  }
Example #7
0
 public void start() {
   try {
     conn.start();
   } catch (JMSException e) {
     e.printStackTrace();
   }
 }
  public void init(
      Connection connection,
      String queue,
      boolean isTopic,
      MessageListener mlisten,
      boolean isActive) {
    try {
      // Session: 一个发送或接收消息的线程
      session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
      if (isTopic) {
        destination = session.createTopic(queue);
      } else {
        destination = session.createQueue(queue);
      }

      consumer = session.createConsumer(destination);
      if (isActive) {
        System.out.println(queue);
        LogSys.nodeLogger.info("创建一个主动方式获取消息的Receiver:" + queue);
      } else {
        if (mlisten == null) consumer.setMessageListener(this);
        else consumer.setMessageListener(mlisten);
      }
    } catch (JMSException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Example #9
0
  public QLender(String queuecf, String requestQueue) {
    try {
      // Connect to the provider and get the JMS connection
      Context ctx = new InitialContext();
      QueueConnectionFactory qFactory = (QueueConnectionFactory) ctx.lookup(queuecf);
      qConnect = qFactory.createQueueConnection();

      // Create the JMS Session
      qSession = qConnect.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);

      // Lookup the request queue
      requestQ = (Queue) ctx.lookup(requestQueue);

      // Now that setup is complete, start the Connection
      qConnect.start();

      // Create the message listener
      QueueReceiver qReceiver = qSession.createReceiver(requestQ);
      qReceiver.setMessageListener(this);

      System.out.println("Waiting for loan requests...");

    } catch (JMSException jmse) {
      jmse.printStackTrace();
      System.exit(1);
    } catch (NamingException jne) {
      jne.printStackTrace();
      System.exit(1);
    }
  }
    public void onMessage(Message message) {
      if (!started) {
        startLatch.countDown();
        started = true;
      }
      try {
        int foo = message.getIntProperty("foo");
        if (foo != count) {
          e = new Exception("received out of order expected " + count + " received " + foo);
          failed = true;
          conn.close();
        }
        count++;
      } catch (JMSException e) {

        this.e = e;
        failed = true;
        try {
          conn.close();
        } catch (JMSException e1) {
          e1
              .printStackTrace(); // To change body of catch statement use File | Settings | File
                                  // Templates.
        }
      }
    }
Example #11
0
  /** @see MessageListener#onMessage(Message) */
  public void onMessage(Message message) {

    TextMessage tmsg = null;
    tmsg = (TextMessage) message;
    String parameter0 = null;
    String parameter1 = null;
    System.out.println("<sms module>");

    // parsing message into opcode, and parameters
    String preParse;
    try {
      preParse = tmsg.getText();
      String[] postParse = preParse.split("[|]+");
      parameter0 = postParse[0];
      parameter1 = postParse[1];

    } catch (JMSException e1) {
      e1.printStackTrace();
    }

    try {
      // TODO
      sendSMS(parameter0, parameter1);
    } catch (Exception e) {

      e.printStackTrace();
    }
  }
  public void onMessage(Message inMessage) {
    TextMessage msg = null;

    try {
      if (inMessage instanceof TextMessage) {
        msg = (TextMessage) inMessage;
        System.out.println("MESSAGE BEAN: Message received: " + msg.getText());
        long sleepTime = msg.getLongProperty("sleeptime");
        System.out.println("Sleeping for : " + sleepTime + " milli seconds ");
        Thread.sleep(sleepTime);
        queueConnection = queueConnectionFactory.createQueueConnection();
        queueSession = queueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
        queueSender = queueSession.createSender(queue);
        TextMessage message = queueSession.createTextMessage();

        message.setText("REPLIED:" + msg.getText());
        message.setIntProperty("replyid", msg.getIntProperty("id"));
        System.out.println("Sending message: " + message.getText());
        queueSender.send(message);
      } else {
        System.out.println("Message of wrong type: " + inMessage.getClass().getName());
      }
    } catch (JMSException e) {
      e.printStackTrace();
    } catch (Throwable te) {
      te.printStackTrace();
    } finally {
      try {
        queueSession.close();
        queueConnection.close();
      } catch (Exception e) {
      }
    }
  } // onMessage
Example #13
0
  public static void main(String[] args) {
    //	File file = new File("c:/Experiment/h2-2_MS_1_004.img.bz2");
    File file = new File("c:/Experiment/baa5d5/high.mtz");
    String serverLocation = "http://localhost:8161/fileserver/";
    String filename = "";
    String entryType = "ENTRY_CREATE";
    String ID = "c:/Experiment/5d5.mtz";

    URL url = null;

    // Generate checksum for the file here

    byte[] fileContents;
    try {
      fileContents = FileUtil.getBytesFromFile(file);
      filename = "5d5.mtz";
      // FileUtil.getFileName("c:/Experiment/h2-2_MS_1_002.bz2");
      url = new URL(serverLocation + filename);
      MD5ChecksumProcessor c = new MD5ChecksumProcessor();
      String checksum = c.generateChecksum(file);
      String domain = "crystallography";
      ADQueueWriterImpl qu = new ADQueueWriterImpl();

      // upload a file to a webserver
      FileServerClient client = new FileServerClient(url);
      //	boolean uploaded = client.upload(fileContents);

      // If upload is true send a blob message with this file url
      // if (uploaded=true){
      // qu.sendBlobMessage(url,ID,domain,checksum,entryType,"12/10/2010 12:22:22");
      try {
        qu.sendByteArrayMessage(
            fileContents, ID, checksum, domain, "baa5d5", entryType, "12/10/2010 12:22:22");
      } catch (XMLStreamException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
      //	}
      // qu.sendMessage(fileContents, ID, entryType, "");

      // qu.sendBlobMessage("c:/Experiment/hello123.xml", "123.xml");

      qu.disconnect();
    } catch (JMSException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      // } catch (XMLStreamException e) {
      // TODO Auto-generated catch block
      //	e.printStackTrace();
    } catch (FactoryConfigurationError e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (ChecksumProcessorException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  /** Constructor del encargado de enviar mensajes JMS. */
  public RespuestaConsultaValue() {
    try {
      final Properties env = new Properties();
      env.put("org.jboss.ejb.client.scoped.context", true);
      env.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");
      env.put("endpoint.name", "endpoint-client");

      ictx = new InitialContext(env);

      Object tmp = ictx.lookup("ConnectionFactory");
      QueueConnectionFactory qcf = (QueueConnectionFactory) tmp;
      conn = qcf.createQueueConnection();
      this.cola = (Queue) ictx.lookup("queue/test");

      queueSession = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);

      conn.start();

    } catch (JMSException e) {
      e.printStackTrace();
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static final void printMessageHeaders(Message pMessge, Object pHandler) {
    StringWriter stringWriter = new StringWriter();

    PrintWriter writer = new PrintWriter(stringWriter);

    try {
      writer.println("===================================================");
      writer.println("MDB Event Handler class=[" + pHandler.getClass().getName() + "]");
      writer.println("");
      writer.println("JMS Message Id: " + pMessge.getJMSMessageID());

      for (Enumeration em = pMessge.getPropertyNames(); em.hasMoreElements(); ) {
        String property = (String) em.nextElement();
        writer.println(
            "JMS Prop=[" + property + "] value=[" + pMessge.getStringProperty(property) + "]");
      }

      writer.println("===================================================");
    } catch (JMSException e) {
      e.printStackTrace();
    }

    writer.flush();
    System.out.println(stringWriter.toString());
  }
Example #16
0
  private int receiveUntilEmpty(Session session, Queue queue) {
    Message message = null;
    int count = 0;
    do {
      try {
        message = receiveMessage(session, queue);
        if (message != null) {
          // JCA queue returns a message of the ObjectMessage type
          Object messageText =
              (message instanceof TextMessage
                  ? ((TextMessage) message).getText()
                  : ((ObjectMessage) message).getObject());
          System.out.println("===== Received message: " + messageText + " =====");
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
      count++;
    } while (message != null);

    if (count != 0) {
      try {
        System.out.println(
            "===== Received " + count + " messages from queue " + queue.getQueueName() + " =====");
      } catch (JMSException e) {
        e.printStackTrace();
      }
    }
    return count;
  }
  /**
   * Send a command via JMS.
   *
   * <p>Note: Opens and closes the connection per invocation of this method which, when run outside
   * a JavaEE container, is not very efficient.
   *
   * @param command
   * @throws JMSException
   */
  public void sendCommandMessage(Command command) throws JMSException {
    Connection connection = null;
    Session session = null;
    try {
      connection = connectionFactory.createConnection();
      session = connection.createSession(TRANSACTIONAL, Session.AUTO_ACKNOWLEDGE);

      // Construct a JMS "TextMessage"
      final TextMessage newMessage = session.createTextMessage();
      newMessage.setStringProperty("issuer", command.getIssuer());
      newMessage.setStringProperty("type", command.getType());
      newMessage.setText(command.getPayload());

      // Send the message
      final MessageProducer producer = session.createProducer(this.commandQueue);
      producer.send(newMessage);

      if (TRANSACTIONAL) {
        // JavaEE containers would manage this
        session.commit();
      }
    } finally {
      if (connection != null) {
        try {
          if (session != null) {
            session.close();
          }
          connection.stop();
          connection.close();
        } catch (JMSException e) {
          e.printStackTrace();
        }
      }
    }
  }
 private void closeReceiver() {
   try {
     connection.close();
   } catch (JMSException e) {
     e.printStackTrace(System.err);
   }
 }
  void processTask(ETask task, ObjectMessage msg, EntityManager em) {
    EMethod method;
    EModel model;
    Collection<EBounds> bounds;
    TaskMessage tm;

    System.out.println("Processing task [id=" + String.valueOf(task.getId()) + "]...");

    method = task.getMethod();
    model = task.getModel();
    bounds = getBoundsForModel(model, em);

    try {
      tm = (TaskMessage) msg.getObject();
      if (method.getIdent().equals(EMethod.fba)) {
        FbaMethod.run(task, model, bounds);
      } else if (method.getIdent().equals(EMethod.fva)) {
        FvaMethod.run(task, model, bounds, (MultipleReactionsTaskMessage) tm);
      } else if (method.getIdent().equals(EMethod.rscan)) {
        RscanMethod.run(task, model, bounds, (MultipleReactionsTaskMessage) tm);
      } else if (method.getIdent().equals(EMethod.kgene)) {
        KgeneMethod.run(task, model, bounds);
      }
      msg.acknowledge();
    } catch (AmkfbaException e) {
      AcornLogger.logError("AmkfbaException: " + e.getMessage());
      markAsBroken(task, em);
    } catch (JMSException e) {
      e.printStackTrace(System.err);
      throw new Error("JMSException, aborting...");
    }
  }
  /**
   * Message listener interface.
   *
   * @param msg message
   */
  public void onMessage(Message msg) {
    try {
      String msgText;
      if (msg instanceof TextMessage) {
        msgText = ((TextMessage) msg).getText();
      } else {
        msgText = msg.toString();
      }

      // System.out.println("Message Received: "+ msgText );
      // ClientTools clientTools = new ClientTools();

      // ClientTools.getRequestAsFile(msgText);
      // DataTools dataTools = new DataTools();
      NonCimDataTools nonCimDataTools = new NonCimDataTools();

      if (!nonCimDataTools.deleteOperation(msgText)) {
        // ClientTools.getDataAsFile(msgText);
        nonCimDataTools.rdfToConsole(msgText);
      }
      // System.out.println("OK");

      if (msgText.equalsIgnoreCase("quit")) {
        synchronized (this) {
          quit = true;
          this.notifyAll(); // Notify main thread to quit
        }
      }
    } catch (JMSException jmse) {
      jmse.printStackTrace();
    }
  }
  public DigitalLibraryServer() {
    try {
      Properties properties = new Properties();
      properties.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory");
      properties.put(Context.URL_PKG_PREFIXES, "org.jnp.interfaces");
      properties.put(Context.PROVIDER_URL, "localhost");

      InitialContext jndi = new InitialContext(properties);
      ConnectionFactory conFactory = (ConnectionFactory) jndi.lookup("XAConnectionFactory");
      connection = conFactory.createConnection();

      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      try {
        counterTopic = (Topic) jndi.lookup("counterTopic");
      } catch (NamingException NE1) {
        System.out.println("NamingException: " + NE1 + " : Continuing anyway...");
      }

      if (null == counterTopic) {
        counterTopic = session.createTopic("counterTopic");
        jndi.bind("counterTopic", counterTopic);
      }

      consumer = session.createConsumer(counterTopic);
      consumer.setMessageListener(this);
      System.out.println("Server started waiting for client requests");
      connection.start();
    } catch (NamingException NE) {
      System.out.println("Naming Exception: " + NE);
    } catch (JMSException JMSE) {
      System.out.println("JMS Exception: " + JMSE);
      JMSE.printStackTrace();
    }
  }
Example #22
0
  public void sendMessage(Order order) {
    ConnectionFactory factory = new ActiveMQConnectionFactory("failover://tcp://localhost:61616");
    Queue queue = new ActiveMQQueue("sequence");
    Connection conn = null;
    Session sen = null;
    MessageProducer producer = null;
    TextMessage msg = null;
    JSONMapper mapper = new JSONMapper();

    Destination des = null;
    try {
      conn = factory.createConnection();
      sen = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      producer = sen.createProducer(queue);
      conn.start();
      String str = mapper.writeObjectAsString(order);
      System.out.println(str);
      msg = sen.createTextMessage(str);
      producer.send(msg);
      producer.close();
      sen.close();
      conn.close();
    } catch (JMSException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Example #23
0
  @Override
  public void onMessage(Message message) {
    if (!(message instanceof ObjectMessage)) {
      return;
    }

    try {
      Object objectInMessage = ((ObjectMessage) message).getObject();
      if (!(objectInMessage instanceof LectureWrapperDTO)) {
        return;
      }

      final String messageAction = message.getStringProperty("action");
      if (messageAction == null) {
        return;
      }
      LectureWrapperDTO lectureWrapperDTO = (LectureWrapperDTO) objectInMessage;

      if (messageAction.equals(ISchedulerListener.InfoType.CREATED.toString())) {
        schedulerListener.notify(ISchedulerListener.InfoType.CREATED, lectureWrapperDTO);
      } else if (messageAction.equals(ISchedulerListener.InfoType.INFO.toString())) {
        schedulerListener.notify(ISchedulerListener.InfoType.INFO, lectureWrapperDTO);
      } else if (messageAction.equals(ISchedulerListener.InfoType.DENIED.toString())) {
        schedulerListener.notify(ISchedulerListener.InfoType.DENIED, lectureWrapperDTO);
      } else if (messageAction.equals(ISchedulerListener.InfoType.STREAMED.toString())) {
        schedulerListener.notify(ISchedulerListener.InfoType.STREAMED, lectureWrapperDTO);
      }
    } catch (JMSException e) {
      e.printStackTrace();
    }
  }
Example #24
0
 private void publishCIPendingEvents() {
   // logger.info("start reading" + eventType);
   isRunning = true;
   lastRun = System.currentTimeMillis();
   List<CMSEvent> events = ciEventReader.getEvents();
   while (events.size() > 0) {
     logger.info("Got " + events.size() + " ci events; Using CIEventPublisher");
     for (CMSEvent event : events) {
       String action = event.getHeaders().get("action");
       try {
         if (event.getPayload() != null || "delete".equals(action)) {
           eventPublisher.publishCIEvents(event);
         } else {
           logger.info("Event payload found null for " + event.getHeaders());
         }
         ciEventReader.removeEvent(event.getEventId());
       } catch (JMSException e) {
         e.printStackTrace();
         logger.error(e.getMessage(), e);
         // stopPublishing();
         return;
       }
     }
     events = ciEventReader.getEvents();
   }
   // System.out.println("Done;");
 }
Example #25
0
 private void publishControllerPendingEvents() {
   isRunning = true;
   lastRun = System.currentTimeMillis();
   List<CMSEvent> events = controllerEventReader.getEvents();
   while (events.size() > 0) {
     logger.info("Got " + events.size() + " controller events; Using ControllerEventPublisher");
     for (CMSEvent event : events) {
       try {
         if (event.getPayload() != null) {
           eventPublisher.publishControllerEvents(event);
         } else {
           logger.info("Event payload found null for " + event.getHeaders());
         }
         controllerEventReader.removeEvent(event.getEventId());
       } catch (JMSException e) {
         e.printStackTrace();
         logger.error(e.getMessage(), e);
         // stopPublishing();
         return;
       }
     }
     events = controllerEventReader.getEvents();
   }
   // System.out.println("Done;");
 }
  /**
   * @see MessageListener#onMessage(Message)
   *     <p>This method expects a MapMessage containing information about a flight that has been
   *     added to the database. This method will print out the information about the flight.
   */
  public void onMessage(Message message) {
    try {
      if (message instanceof MapMessage) {
        MapMessage msg = (MapMessage) message;

        StringBuffer sb = new StringBuffer();

        sb.append("Flight #: " + msg.getString("flightId") + "\n");
        sb.append("Flight Date: " + msg.getString("flightDate") + "\n");
        sb.append("Departure Airport: " + msg.getString("departureAirport") + "\n");
        sb.append("Destination Airport: " + msg.getString("destinationAirport") + "\n");
        sb.append("Number of Seats: " + msg.getInt("numSeats") + "\n");
        sb.append("Seat Cost: $" + msg.getDouble("cost") + "\n");
        sb.append("Airplane #: " + msg.getString("airplaneId") + "\n");
        sb.append("*************************************************** \n\n");

        System.out.println(
            "\n**" + getClass().getSimpleName() + ": Flight Added!\n" + sb.toString());

      } else {
        System.out.println(
            getClass().getSimpleName()
                + " - Error: The message provided was not of type MapMessage!");
      }
    } catch (JMSException e) {
      System.out.println(
          getClass().getSimpleName() + ": Error occuredwhen attempting to read the MapMessage");
      e.printStackTrace();
    }
  }
 @Override
 public void onMessage(Message message) {
   try {
     System.out.println("QueueReceiver1接收到消息:" + ((TextMessage) message).getText());
   } catch (JMSException e) {
     e.printStackTrace();
   }
 }
 public Topic getTopic(Session session) {
   try {
     return session.createTopic(JMS_TOPIC);
   } catch (JMSException e) {
     e.printStackTrace();
   }
   return null;
 }
 public Queue getQueue(Session session) {
   try {
     return session.createQueue(JMS_QUEUE);
   } catch (JMSException e) {
     e.printStackTrace();
   }
   return null;
 }
 public void stop() {
   try {
     jmsService.removeMessageListener(this);
   } catch (JMSException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }