/** * Create a JMS Connection via this template's ConnectionFactory. * @return the new JMS Connection * @throws javax.jms.JMSException if thrown by JMS API methods */ protected Connection doCreateConnection() throws JMSException { ConnectionFactory cf = getTargetConnectionFactory(); if (Boolean.FALSE.equals(this.pubSubMode) && cf instanceof QueueConnectionFactory) { return ((QueueConnectionFactory) cf).createQueueConnection(); } else if (Boolean.TRUE.equals(this.pubSubMode) && cf instanceof TopicConnectionFactory) { return ((TopicConnectionFactory) cf).createTopicConnection(); } else { return obtainTargetConnectionFactory().createConnection(); } }
@Test public void testWithQueueConnectionFactoryAndJms11Usage() throws JMSException { QueueConnectionFactory cf = mock(QueueConnectionFactory.class); QueueConnection con = mock(QueueConnection.class); given(cf.createConnection()).willReturn(con); SingleConnectionFactory scf = new SingleConnectionFactory(cf); Connection con1 = scf.createConnection(); Connection con2 = scf.createConnection(); con1.start(); con2.start(); con1.close(); con2.close(); scf.destroy(); // should trigger actual close verify(con).start(); verify(con).stop(); verify(con).close(); verifyNoMoreInteractions(con); }
public void lookupJMSConnectionFactory() throws TestFailureException{ try{ try{ InitialContext ctx = new InitialContext(); Assert.assertNotNull("The InitialContext is null", ctx); Object obj = ctx.lookup("java:comp/env/jms"); Assert.assertNotNull("The JMS ConnectionFactory is null", obj); Assert.assertTrue("Not an instance of ConnectionFactory", obj instanceof ConnectionFactory); ConnectionFactory connectionFactory = (ConnectionFactory) obj; testJmsConnection(connectionFactory.createConnection()); obj = ctx.lookup("java:comp/env/TopicCF"); Assert.assertNotNull("The JMS TopicConnectionFactory is null", obj); Assert.assertTrue("Not an instance of TopicConnectionFactory", obj instanceof TopicConnectionFactory); TopicConnectionFactory topicConnectionFactory = (TopicConnectionFactory) obj; testJmsConnection(topicConnectionFactory.createConnection()); obj = ctx.lookup("java:comp/env/QueueCF"); Assert.assertNotNull("The JMS QueueConnectionFactory is null", obj); Assert.assertTrue("Not an instance of QueueConnectionFactory", obj instanceof QueueConnectionFactory); QueueConnectionFactory queueConnectionFactory = (QueueConnectionFactory) obj; testJmsConnection(queueConnectionFactory.createConnection()); } catch (Exception e){ e.printStackTrace(); Assert.fail("Received Exception "+e.getClass()+ " : "+e.getMessage()); } } catch (AssertionFailedError afe){ throw new TestFailureException(afe); } }
public InboundQueueSender(String providerURL) throws JMSException, NamingException { Hashtable<String, Object> env = new Hashtable<>(); env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory"); env.put(Context.PROVIDER_URL, providerURL); env.put(Context.SECURITY_PRINCIPAL, "guest"); env.put(Context.SECURITY_CREDENTIALS, "pass"); InitialContext iniCtx = new InitialContext(env); QueueConnectionFactory qcf = (QueueConnectionFactory) iniCtx.lookup("jms/RemoteConnectionFactory"); conn = qcf.createQueueConnection("guest", "pass"); Queue queB = (Queue) iniCtx.lookup(SEND_QUEUE); session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); sender = session.createSender(queB); conn.start(); }
public void start() throws Exception { InitialContext ctx = new InitialContext(); QueueConnectionFactory qcf = (QueueConnectionFactory)ctx.lookup("java:/ConnectionFactory"); conn = qcf.createQueueConnection(); conn.start(); queue = (Queue)ctx.lookup("queue/test"); session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); // Set the async listener QueueReceiver recv = session.createReceiver(queue); recv.setMessageListener(new ExampeMessageListener()); }
public JMSQueueSink(String qcfBindingName, String queueBindingName, String username, String password) { try { Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory"); env.put(Context.PROVIDER_URL, "tcp://localhost:61616"); Context ctx = new InitialContext(env); QueueConnectionFactory queueConnectionFactory; queueConnectionFactory = (QueueConnectionFactory) lookup(ctx, qcfBindingName); System.out.println("Queue Cnx Factory found"); Queue queue = (Queue) ctx.lookup(queueBindingName); System.out.println("Queue found: " + queue.getQueueName()); QueueConnection queueConnection = queueConnectionFactory .createQueueConnection(username, password); System.out.println("Queue Connection created"); QueueSession queueSession = queueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); MessageConsumer queueConsumer = queueSession.createConsumer(queue); queueConsumer.setMessageListener(this); queueConnection.start(); System.out.println("Queue Connection started"); } catch (Exception e) { logger.error("Could not read JMS message.", e); } }
public static void main(String[] args) throws Exception { // get the initial context InitialContext ctx = new InitialContext(); // lookup the queue object Queue queue = (Queue) ctx.lookup("queue/queue0"); // lookup the queue connection factory QueueConnectionFactory connFactory = (QueueConnectionFactory) ctx. lookup("queue/connectionFactory"); // create a queue connection QueueConnection queueConn = connFactory.createQueueConnection(); // create a queue session QueueSession queueSession = queueConn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); // create a queue browser QueueBrowser queueBrowser = queueSession.createBrowser(queue); // start the connection queueConn.start(); // browse the messages Enumeration e = queueBrowser.getEnumeration(); int numMsgs = 0; // count number of messages while (e.hasMoreElements()) { Message message = (Message) e.nextElement(); numMsgs++; } System.out.println(queue + " has " + numMsgs + " messages"); // close the queue connection queueConn.close(); }
Properties props = new Properties(); props.setProperty(Context.INITIAL_CONTEXT_FACTORY,"org.apache.activemq.jndi.ActiveMQInitialContextFactory"); props.setProperty(Context.PROVIDER_URL,"tcp://localhost:61616"); InitialContext ctx = new InitialContext(props); // get the initial context // InitialContext ctx = new InitialContext(); QueueConnectionFactory connFactory = (QueueConnectionFactory) ctx.lookup("ConnectionFactory"); // create a queue connection QueueConnection queueConn = connFactory.createQueueConnection(); queueConn.start(); // lookup the queue object Queue queue = (Queue) ctx.lookup("dynamicQueues/Payment_Check");
private void sendBytesMessage(String destName,byte[] buffer) throws Exception { InitialContext ic = getInitialContext(); QueueConnectionFactory confac = (QueueConnectionFactory) ic.lookup("ConnectionFactory"); QueueConnection connection = confac.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); BytesMessage bm = session.createBytesMessage(); bm.writeBytes(buffer); QueueSender sender = session.createSender((Queue)ic.lookup(destName)); sender.send(bm); sender.close(); session.close(); connection.close(); }
public void lookupJMSConnectionFactory() throws TestFailureException{ try{ try{ testJmsConnection(coonnectionFactory.createConnection()); testJmsConnection(queueCoonnectionFactory.createConnection()); testJmsConnection(topicCoonnectionFactory.createConnection()); } catch (Exception e){ e.printStackTrace(); Assert.fail("Received Exception "+e.getClass()+ " : "+e.getMessage()); } } catch (AssertionFailedError afe){ throw new TestFailureException(afe); } }
public class JMSConnector implements Runnable { public void run() { try { Context context = new InitialContext(); QueueConnectionFactory factory = (QueueConnectionFactory) context.lookup("java:comp/env/jms/ConnectionFactory"); Connection connection = factory.createConnection(); Queue queue = (javax.jms.Queue) context.lookup("java:comp/env/jms/serverQueue"); Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(queue); //This MessageListener will do stuff with the message MessageListenerImpl messageListener = new MessageListenerImpl(); consumer.setMessageListener(messageListener); connection.start(); // Start connection or nothing will happen!!! connection.start(); } catch (JMSException ex) { //TODO } catch (NamingException ex) { //TODO } } }
// Create the connection InitialContext context = new InitialContext(properties); QueueConnectionFactory queueConnFactory = (QueueConnectionFactory) context.lookup("ConnectionFactory"); QueueConnection conn = queueConnFactory.createQueueConnection(); Queue queue = (Queue) context.lookup("/queue/Test"); QueueSession session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); // Start the connection conn.start() // Create a QueueBrowser using the session QueueBrowser queueBrowser = session.createBrowser(queue); Enumeration e = queueBrowser.getEnumeration(); // Iterate through the queue while(e.hasMoreElements()) { Message msg = (Message) e.nextElement(); TextMessage txtMsg = (TextMessage) msg; System.out.println(txtMsg.getText()); }
/** * Test that ConnectionFactory can be cast to QueueConnectionFactory and QueueConnection can be * created. */ @Test public void testQueueConnectionFactory() throws Exception { deployConnectionFactory(0, JMSFactoryType.QUEUE_CF, "CF_QUEUE_XA_FALSE", "/CF_QUEUE_XA_FALSE"); QueueConnectionFactory qcf = (QueueConnectionFactory) ic.lookup("/CF_QUEUE_XA_FALSE"); QueueConnection qc = qcf.createQueueConnection(); qc.close(); undeployConnectionFactory("CF_QUEUE_XA_FALSE"); }
this.queueConnection = queueConnectionFactory.createQueueConnection( userName, password); } else { this.queueConnection = queueConnectionFactory.createQueueConnection(); this.queueSession = queueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); this.queueSender = queueSession.createSender(queue); queueConnection.start();
@Override public QueueConnection createQueueConnection(String username, String password) throws JMSException { ConnectionFactory target = obtainTargetConnectionFactory(); if (target instanceof QueueConnectionFactory) { return ((QueueConnectionFactory) target).createQueueConnection(username, password); } else { Connection con = target.createConnection(username, password); if (!(con instanceof QueueConnection)) { throw new javax.jms.IllegalStateException("'targetConnectionFactory' is not a QueueConnectionFactory"); } return (QueueConnection) con; } }
queueFactory = (QueueConnectionFactory) factory; _queueConnection = queueFactory.createQueueConnection(); _queueSession = _queueConnection.createQueueSession(false, 1); _queueConsumer = _queueSession.createReceiver((Queue) queue); _queueConnection.start(); topicFactory = (TopicConnectionFactory) factory; _topicConnection = topicFactory.createTopicConnection(); _topicSession = _topicConnection.createTopicSession(false, 1); _topicConsumer = _topicSession.createSubscriber((Topic) queue); _connection = factory.createConnection(); _session = _connection.createSession(false, 1); _consumer = _session.createConsumer(queue);
public void setUp() { super.setUp(); try { queueConnection = queueConnectionFactory.createQueueConnection(); queueSession = queueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); topicConnection = topicConnectionFactory.createTopicConnection(); topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); queueConnection.start(); topicConnection.start(); } catch (Exception e) { throw new NestedRuntimeException(e); } }
protected Connection createConnection() throws JMSException { if (isPubSubDomain()) { return ((TopicConnectionFactory) getConnectionFactory()).createTopicConnection(); } else { return ((QueueConnectionFactory) getConnectionFactory()).createQueueConnection(); } }
QueueSession nonTxSession = mock(QueueSession.class); given(cf.createQueueConnection()).willReturn(con); given(con.createQueueSession(true, Session.AUTO_ACKNOWLEDGE)).willReturn(txSession); given(txSession.getTransacted()).willReturn(true); given(con.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE)).willReturn(nonTxSession); con1.start(); QueueConnection con2 = scf.createQueueConnection(); Session session2 = con2.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE); session2.close(); session2 = con2.createSession(true, Session.AUTO_ACKNOWLEDGE); verify(txSession).rollback(); verify(txSession).close(); verify(nonTxSession).close(); verify(con).start();
try { QueueConnectionFactory qcf = AppUtils.getQueueConnectionFactory(); Queue q = AppUtils.getDestination(); QueueConnection qConnection = qcf.createQueueConnection(); QueueSession qSession = qConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); QueueSender qSender = qSession.createSender(q); qConnection.start(); TextMessage msg = qSession.createTextMessage("Hello"); qSender.send(msg); qSender.close(); qConnection.close(); } catch (JMSException e) { // log your error to log file e.printStackTrace(); }