/* (non-Javadoc) * @see org.ikasan.spec.management.ManagedResource#startManagedResource() */ public void startManagedResource() { ConnectionFactory _connectionFactory = null; try { if (this.configuration.isRemoteJNDILookup()) { Context context = getInitialContext(); if (this.configuration.getConnectionFactoryName() == null) { throw new RuntimeException( "ConnectionFactory name cannot be 'null' when using remoteJNDILookup"); } _connectionFactory = (ConnectionFactory) context.lookup(this.configuration.getConnectionFactoryName()); if (this.configuration.getDestinationName() == null) { throw new RuntimeException( "DestinationName name cannot be 'null' when using remoteJNDILookup"); } this.destination = (Destination) context.lookup(this.configuration.getDestinationName()); } else { if (this.connectionFactory == null) { throw new RuntimeException( "You must specify the remoteJNDILookup as true or provide a ConnectionFactory instance for this class."); } _connectionFactory = this.connectionFactory; } if (this.configuration.getUsername() != null && this.configuration.getUsername().trim().length() > 0) { connection = _connectionFactory.createConnection( this.configuration.getUsername(), this.configuration.getPassword()); } else { connection = _connectionFactory.createConnection(); } this.session = connection.createSession( this.configuration.isTransacted(), this.configuration.getAcknowledgement()); if (this.destination == null) { if (destinationResolver == null) { throw new RuntimeException( "destination and destinationResolver are both 'null'. No means of resolving a destination."); } this.destination = this.destinationResolver.getDestination(); } } catch (JMSException e) { throw new EndpointException(e); } catch (NamingException e) { throw new RuntimeException(e); } }
/* * Initiate the snapshot by sending a Marker message to one of the Players (Player0) * Any Player could have been used to initiate the snapshot. */ private void sendInitSnapshot() { try { // Gather necessary JMS resources Context ctx = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/myConnectionFactory"); Queue q = (Queue) ctx.lookup("jms/PITplayer0"); Connection con = cf.createConnection(); Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer writer = session.createProducer(q); /* * As part of the snapshot algorithm, players need to record * what other Players they receive markers from. * "-1" indicates to the PITplayer0 that this marker is coming from * the monitor, not another Player. */ Marker m = new Marker(-1); ObjectMessage msg = session.createObjectMessage(m); System.out.println("Initiating Snapshot"); writer.send(msg); con.close(); } catch (JMSException e) { System.out.println("JMS Exception thrown" + e); } catch (Throwable e) { System.out.println("Throwable thrown" + e); } }
public UserMessageService(String brokerURL, String queueName) throws JMSException { this.queueName = queueName; ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL); this.con = factory.createConnection(); session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); this.producer = session.createProducer(null); }
public static void main(String[] args) { try { // Gets the JgetTopicName()NDI context Context jndiContext = new InitialContext(); // Looks up the administered objects ConnectionFactory connectionFactory = (ConnectionFactory) jndiContext.lookup("jms/javaee6/ConnectionFactory"); Queue queue = (Queue) jndiContext.lookup("jms/javaee6/Queue"); // Creates the needed artifacts to connect to the queue Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(queue); connection.start(); // Loops to receive the messages System.out.println("\nInfinite loop. Waiting for a message..."); while (true) { TextMessage message = (TextMessage) consumer.receive(); System.out.println("Message received: " + message.getText()); } } catch (Exception e) { e.printStackTrace(); } }
/** * Creates and configures a new instance. * * @param dataDirectory root directory where persistent messages are stored * @param useLibAio true to use libaio, false if not installed. See <a * href="http://docs.jboss.org/hornetq/2.2.5.Final/user-manual/en/html/libaio.html">Libaio * Native Libraries</a> * @param injector Google Guice injector. Used to inject dependency members into commands if * needed. * @param queueConfigs vararg of QueueConfig> instances. */ public HornetNest( String dataDirectory, boolean useLibAio, Injector injector, QueueConfig... queueConfigs) { jmsServer = new EmbeddedJMS(); config = new ConfigurationImpl(); jmsConfig = new JMSConfigurationImpl(); try { configureLocations(dataDirectory); configureAcceptor(); configureConnectionFactory(); configurePaging(); config.setJournalType(useLibAio ? JournalType.ASYNCIO : JournalType.NIO); configureQueues(queueConfigs); config.setThreadPoolMaxSize(-1); config.setScheduledThreadPoolMaxSize(10); jmsServer.setConfiguration(config); jmsServer.setJmsConfiguration(jmsConfig); jmsServer.start(); ConnectionFactory connectionFactory = (ConnectionFactory) jmsServer.lookup("/cf"); if (connectionFactory == null) { throw new HornetNestException( "Failed to start EmbeddedJMS due to previous errors. Please, see earlier output from HornetQ."); } consumerConnection = connectionFactory.createConnection(); producerConnection = connectionFactory.createConnection(); configureListeners(injector, queueConfigs); } catch (HornetNestException e) { throw e; } catch (Exception e) { throw new HornetNestException("Failed to start EmbeddedJMS", e); } }
public static void main(String[] args) { try { Context ctx = new InitialContext(); ConnectionFactory factory = (ConnectionFactory) ctx.lookup("ConnectionFactory"); Queue queue = (Queue) ctx.lookup("inbound"); Connection con = factory.createConnection(); final Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); final MessageConsumer consumer = session.createConsumer(queue); consumer.setMessageListener( new MessageListener() { @Override public void onMessage(Message message) { final String type; try { type = message.getStringProperty("type"); if (type != null && type.equals("xml")) { System.out.println(((TextMessage) message).getText()); } } catch (JMSException e) { e.printStackTrace(); } } }); con.start(); } catch (Exception e) { e.printStackTrace(); } }
private static void createTable() throws Exception { try { Configuration configuration = HBaseConfiguration.create(); HBaseAdmin.checkHBaseAvailable(configuration); Connection connection = ConnectionFactory.createConnection(configuration); // Instantiating HbaseAdmin class Admin admin = connection.getAdmin(); // Instantiating table descriptor class HTableDescriptor stockTableDesc = new HTableDescriptor(TableName.valueOf(Constants.STOCK_DATES_TABLE)); // Adding column families to table descriptor HColumnDescriptor stock_0414 = new HColumnDescriptor(Constants.STOCK_DATES_CF); stockTableDesc.addFamily(stock_0414); // Execute the table through admin if (!admin.tableExists(stockTableDesc.getTableName())) { admin.createTable(stockTableDesc); System.out.println("Stock table created !!!"); } // Load hbase-site.xml HBaseConfiguration.addHbaseResources(configuration); } catch (ServiceException e) { log.error("Error occurred while creating HBase tables", e); throw new Exception("Error occurred while creating HBase tables", e); } }
/** * Establishes a connection to a registry. * * @param queryUrl the URL of the query registry * @param publishUrl the URL of the publish registry */ public void makeConnection(String queryUrl, String publishUrl) { Context context = null; ConnectionFactory factory = null; /* * Define connection configuration properties. * To publish, you need both the query URL and the * publish URL. */ Properties props = new Properties(); props.setProperty("javax.xml.registry.queryManagerURL", queryUrl); props.setProperty("javax.xml.registry.lifeCycleManagerURL", publishUrl); try { // Create the connection, passing it the // configuration properties context = new InitialContext(); factory = (ConnectionFactory) context.lookup("java:comp/env/eis/JAXR"); factory.setProperties(props); connection = factory.createConnection(); System.out.println("Created connection to registry"); } catch (Exception e) { e.printStackTrace(); if (connection != null) { try { connection.close(); } catch (JAXRException je) { } } } }
/** * Initializes the qpid connection with a jndiName of cow, and a host and port taken from the * cow-server.properties file. */ public void init() { String connectionFactorylocation = "amqp://*****:*****@clientid/test?brokerlist='tcp://" + host + ":" + port + "'"; String destinationType = "topic"; String jndiName = "cow"; String destinationName = "myTopic"; try { properties = new Properties(); properties.setProperty( Context.INITIAL_CONTEXT_FACTORY, "org.apache.qpid.jndi.PropertiesFileInitialContextFactory"); properties.setProperty("connectionfactory.amqpConnectionFactory", connectionFactorylocation); properties.setProperty(destinationType + "." + jndiName, destinationName); context = new InitialContext(properties); ConnectionFactory connectionFactory = (ConnectionFactory) context.lookup("amqpConnectionFactory"); Connection connection = connectionFactory.createConnection(); connection.start(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = (Destination) context.lookup(jndiName); messageProducer = session.createProducer(destination); initialized = true; } catch (Exception e) { log.debug(e.getMessage()); initialized = false; } }
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(); } }
@Test public void testReceiveMessageTimeout() throws JMSException { JmsMessageReceiver receiver = new JmsMessageReceiver(); receiver.setConnectionFactory(connectionFactory); receiver.setDestination(destination); reset(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); expect(connectionFactory.createConnection()).andReturn(connection).once(); expect(connection.createSession(anyBoolean(), anyInt())).andReturn(session).once(); expect(session.getTransacted()).andReturn(false).once(); expect(session.getAcknowledgeMode()).andReturn(Session.AUTO_ACKNOWLEDGE).once(); expect(session.createConsumer(destination, null)).andReturn(messageConsumer).once(); expect(messageConsumer.receive(5000L)).andReturn(null).once(); connection.start(); expectLastCall().once(); replay(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); try { receiver.receive(); } catch (ActionTimeoutException e) { Assert.assertTrue( e.getMessage().startsWith("Action timed out while receiving JMS message on")); return; } Assert.fail( "Missing " + CitrusRuntimeException.class + " because of receiveing message timeout"); }
private void createAndStartConnection(String userName, String password, String url) throws JMSException { ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(userName, password, url); connection = (ActiveMQConnection) connectionFactory.createConnection(); connection.start(); LOG.info("Connected successfully to {}", url); }
public static void main(String[] args) throws JMSException { AsyncSimpleConsumer asyncConsumer = new AsyncSimpleConsumer(); ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); Connection connection = connectionFactory.createConnection(); connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue(subject); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(asyncConsumer); connection.setExceptionListener(asyncConsumer); try { while (true) { if (AsyncSimpleConsumer.catchExit) { break; } Thread.sleep(1000); } } catch (InterruptedException e) { System.out.println("Sleep interrupted"); } connection.close(); }
@Override public void run() { waitForReady(); try { Thread.sleep(new Random().nextInt(200) + 100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } Connection connection = ConnectionFactory.createConnection(brokerIP); session = connection.createSession(); String topicHierarchy = topicHierarchies[id]; Subscriber subscriber = session.createHierarchicalTopicSubscriber(topicHierarchy); System.out.println("create subscriber: " + topicHierarchy); messageReceiver = new TestMessageReceiver(); subscriber.registerMessageReceiver(messageReceiver); while (!messageReceiver.shutdown) { try { Thread.sleep(5000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } done(); }
public static void main(String[] args) throws JMSException { // Getting JMS connection from the server ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); Connection connection = connectionFactory.createConnection(); connection.start(); // Creating session for seding messages Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Getting the queue 'JMSBEGINQUEUE' Destination destination = session.createQueue(subject); // MessageConsumer is used for receiving (consuming) messages MessageConsumer consumer = session.createConsumer(destination); // Here we receive the message. // By default this call is blocking, which means it will wait // for a message to arrive on the queue. Message message = consumer.receive(); // There are many types of Message and TextMessage // is just one of them. Producer sent us a TextMessage // so we must cast to it to get access to its .getText() // method. if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage) message; System.out.println("Received message '" + textMessage.getText() + "'"); } connection.close(); }
private void sendTextMessage(String msg) throws Exception { try (Connection connection = cf.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer publisher = session.createProducer(queue); ) { connection.start(); TextMessage message = session.createTextMessage(msg); publisher.send(message); } }
public static void main(String args[]) { Connection connection = null; try { // JNDI lookup of JMS Connection Factory and JMS Destination Context context = new InitialContext(); ConnectionFactory factory = (ConnectionFactory) context.lookup(CONNECTION_FACTORY_NAME); Destination destination = (Destination) context.lookup(DESTINATION_NAME); connection = factory.createConnection(); connection.start(); Session session = connection.createSession(NON_TRANSACTED, Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(destination); LOG.info( "Start consuming messages from " + destination.toString() + " with " + MESSAGE_TIMEOUT_MILLISECONDS + "ms timeout"); // Synchronous message consumer int i = 1; while (true) { Message message = consumer.receive(MESSAGE_TIMEOUT_MILLISECONDS); if (message != null) { if (message instanceof TextMessage) { String text = ((TextMessage) message).getText(); LOG.info("Got " + (i++) + ". message: " + text); } } else { break; } } consumer.close(); session.close(); } catch (Throwable t) { LOG.error("Error receiving message", t); } finally { // Cleanup code // In general, you should always close producers, consumers, // sessions, and connections in reverse order of creation. // For this simple example, a JMS connection.close will // clean up all other resources. if (connection != null) { try { connection.close(); } catch (JMSException e) { LOG.error("Error closing connection", e); } } } }
protected synchronized Connection getConnection() { if (this.connection == null) { try { Connection connection = ConnectionFactory.createConnection(getConf()); setConnection(connection); } catch (IOException e) { LOG.fatal("Failed to establish connection.", e); } } return connection; }
public static void verifyMobRowCount( final HBaseTestingUtility util, final TableName tableName, long expectedRows) throws IOException { Table table = ConnectionFactory.createConnection(util.getConfiguration()).getTable(tableName); try { assertEquals(expectedRows, countMobRows(table)); } finally { table.close(); } }
@Override public void start() { try { connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); messageConsumer = session.createConsumer(schedulerQueue); messageConsumer.setMessageListener(this); connection.start(); } catch (JMSException e) { e.printStackTrace(); } }
public void initialise() throws IOException { Configuration conf = HBaseConfiguration.create(); conf.addResource(new Path(clientConfig)); conf.addResource(new Path("/etc/hadoop/conf/core-site.xml")); UserGroupInformation.setConfiguration(conf); UserGroupInformation.loginUserFromKeytab(user, keytabLocation); System.out.println(conf.toString()); connection = ConnectionFactory.createConnection(conf); }
/** Connects to a named queue. */ public JMSQueue(ConnectionFactory connectionFactory, Destination queue) throws Exception { _connection = connectionFactory.createConnection(); _session = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE); if (queue == null) _destination = _session.createTemporaryQueue(); else _destination = queue; _consumer = _session.createConsumer(_destination); _producer = _session.createProducer(_destination); _connection.start(); }
public HBaseUtils( String quorum, boolean useKerberos, String keyTabUsername, String kerberosEnv, String keyTabFileLocation, int regions) throws IOException { this.regions = regions; conf.set("hbase.zookeeper.quorum", quorum); if (useKerberos) { conf.set("hadoop.security.authentication", "Kerberos"); conf.set("hbase.security.authentication", "Kerberos"); conf.set("hbase.master.kerberos.principal", "hbase/_HOST@" + kerberosEnv + ".YOURDOMAIN.COM"); conf.set( "hbase.regionserver.kerberos.principal", "hbase/_HOST@" + kerberosEnv + ".YOURDOMAIN.COM"); conf.set("hbase.client.keyvalue.maxsize", "-1"); UserGroupInformation.setConfiguration(conf); try { UserGroupInformation.loginUserFromKeytab( keyTabUsername + "@" + kerberosEnv + ".YOURDOMAIN.COM", keyTabFileLocation); valid = true; } catch (IOException e) { e.printStackTrace(); valid = false; } kerberosRefresher.scheduleAtFixedRate( () -> { try { UserGroupInformation ugi = UserGroupInformation.getLoginUser(); if (ugi == null) { Logger.error("KERBEROS GOT LOGGED OUT"); UserGroupInformation.loginUserFromKeytab( keyTabUsername + "@" + kerberosEnv + ".YOURDOMAIN.COM", keyTabFileLocation); } else { ugi.checkTGTAndReloginFromKeytab(); } } catch (IOException e) { e.printStackTrace(); } }, KERBEROS_EXPIRATION_HOURS, KERBEROS_EXPIRATION_HOURS, TimeUnit.HOURS); } else { valid = true; conf.set(HConstants.ZOOKEEPER_ZNODE_PARENT, "/hbase-unsecure"); } connection = ConnectionFactory.createConnection(conf); }
public static void main(String[] args) throws JMSException { String uri = "failover://tcp://103.224.81.184:61616"; ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(uri); Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); Topic topic = session.createTopic("topic1"); MessageProducer producer = session.createProducer(topic); TextMessage textMessage = session.createTextMessage("HelloWorld4"); producer.send(textMessage); connection.start(); producer.close(); session.close(); connection.close(); }
@SuppressWarnings({"unchecked", "static-access"}) public static synchronized void initConnectionPool() throws SQLException, ClassNotFoundException { ConnectionPool.getConnectionPool().destoryConnectionPool(); @SuppressWarnings("rawtypes") Vector temp = ConnectionPool.getConnectionPool().getConnectionPoolBuffer(); ConnectionFactory connectionFactory = ConnectionFactory.getDefaultFactory(); for (int i = 0; i < MAX_CONNECTION; i++) { Connection connection = connectionFactory.createConnection("mysql"); temp.addElement(new ConnectionInfo(connection, System.currentTimeMillis())); System.out.println("New Connection Created.." + connection); } }
// TextMessage message; // 构造ConnectionFactory实例对象,此处采用ActiveMq的实现jar public ActiveMQSender(String broker) { try { connectionFactory = new ActiveMQConnectionFactory( ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, broker); // 构造从工厂得到连接对象 connection = connectionFactory.createConnection(); // 启动 connection.start(); /** ********************************** */ } catch (Exception e) { e.printStackTrace(); } finally { } }
@SuppressWarnings("deprecation") @Before public void setUp() throws Exception { HTableDescriptor desc = new HTableDescriptor(tableName); HColumnDescriptor hcd = new HColumnDescriptor(family); hcd.setMobEnabled(true); hcd.setMobThreshold(3L); hcd.setMaxVersions(4); desc.addFamily(hcd); admin = TEST_UTIL.getHBaseAdmin(); admin.createTable(desc); table = ConnectionFactory.createConnection(TEST_UTIL.getConfiguration()) .getBufferedMutator(TableName.valueOf(tableName)); }
protected Connection acceptConnection(ServerSocketChannel listener) { SocketChannel channel = null; try { channel = listener.accept(); if (channel == null) { if (log.isDebugEnabled()) { log.debug("Psych! Got ACCEPT_READY, but no connection."); } return null; } if (!(channel instanceof SelectableChannel)) { try { log.warn( "Provided with un-selectable socket as result of accept(), can't " + "cope [channel=" + channel + "]."); } catch (Error err) { log.warn("Un-selectable channel also couldn't be printed."); } // stick a fork in the socket channel.socket().close(); return null; } Connection connection = connFactory.createConnection(channel, System.currentTimeMillis()); if (connection instanceof AuthingableConnection) { ((AuthingableConnection) connection).setAuthenticator(this.getAuthenticator()); ((AuthingableConnection) connection).beforeAuthing(); } if (manager != null) { manager.postRegisterNetEventHandler(connection, SelectionKey.OP_READ); } else { this.postRegisterNetEventHandler(connection, SelectionKey.OP_READ); } return connection; } catch (Exception e) { if (channel != null) { try { channel.socket().close(); } catch (IOException ioe) { log.warn("Failed closing aborted connection: " + ioe); } } return null; } }
public void handleRequest(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { PrintWriter out = res.getWriter(); ConnectionFactory cf; Destination dest; try { Context initCtx = new InitialContext(); Context envCtx = (Context) initCtx.lookup("java:comp/env"); cf = (ConnectionFactory) envCtx.lookup("jms/connectionFactory"); dest = (Destination) envCtx.lookup(QUEUE_NAME); } catch (NamingException e) { throw new RuntimeException(e); } Connection connection = null; try { connection = cf.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(dest); TextMessage message = session.createTextMessage(); for (int i = 0; i < NUM_MSGS; i++) { message.setText("This is message " + (i + 1)); log.info("Sending message: " + message.getText()); producer.send(message); } producer.send(session.createTextMessage()); } catch (JMSException e) { throw new RuntimeException(e); } finally { if (connection != null) { try { connection.close(); } catch (JMSException e) { } } } out.write("<p>Wrote " + NUM_MSGS + " to queue " + QUEUE_NAME + " followed by a blank.</p>"); out.close(); }
@Test public void testWithMessageSelectorAndCustomTimeout() throws JMSException { JmsMessageReceiver receiver = new JmsMessageReceiver(); receiver.setConnectionFactory(connectionFactory); receiver.setDestination(destination); receiver.setReceiveTimeout(10000L); Map<String, Object> controlHeaders = new HashMap<String, Object>(); final Message<String> controlMessage = MessageBuilder.withPayload("<TestRequest><Message>Hello World!</Message></TestRequest>") .copyHeaders(controlHeaders) .build(); Map<String, String> headers = new HashMap<String, String>(); reset(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); expect(connectionFactory.createConnection()).andReturn(connection).once(); expect(connection.createSession(anyBoolean(), anyInt())).andReturn(session).once(); expect(session.getTransacted()).andReturn(false).once(); expect(session.getAcknowledgeMode()).andReturn(Session.AUTO_ACKNOWLEDGE).once(); expect(session.createConsumer(destination, "Operation = 'sayHello'")) .andReturn(messageConsumer) .once(); connection.start(); expectLastCall().once(); expect(messageConsumer.receive(10000L)) .andReturn( new TextMessageImpl( "<TestRequest><Message>Hello World!</Message></TestRequest>", headers)) .once(); replay(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); Message<?> receivedMessage = receiver.receiveSelected("Operation = 'sayHello'"); Assert.assertEquals(receivedMessage.getPayload(), controlMessage.getPayload()); verify(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); }