Examples of javax.jms.Connection

javax.jms.Connection
@version $Rev: 46019 $ $Date: 2004-09-14 03:56:06 -0600 (Tue, 14 Sep 2004) $


      ServerManagement.deployQueue("Queue", 10000, 1000, 1000);
      
      Queue queue = (Queue)initialContext.lookup("/queue/Queue");
      
      Connection conn = cf.createConnection();


      Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);


      MessageProducer prod = sess.createProducer(queue);


      prod.setDeliveryMode(DeliveryMode.NON_PERSISTENT);


      final int NUM_MESSAGES = 1000;
      
      //send some messages
      
      conn.start();
      MessageConsumer cons = sess.createConsumer(queue);


      produceMessages(sess, prod, 100, cons);
      
      JVMTIInterface jvmti = new JVMTIInterface();
      Map inventory1=jvmti.produceInventory();
      log.info("Producing first snapshot");
      produceMessages(sess, prod, NUM_MESSAGES, cons);
      log.info("Producing second snapshot");
      jvmti.forceReleaseOnSoftReferences();
      jvmti.forceGC();
      Map inventory2 = jvmti.produceInventory();
      
      log.info("inventory1.size=" + inventory1.size());
      log.info("inventory2.size=" + inventory2.size());
      
      assertTrue("Test produced unexpected objects",jvmti.compareInventories(System.out, inventory1,inventory2,null, null, new InventoryDataPoint[] {new InventoryDataPoint(Object.class,10)}));
            
      conn.close();
      
      conn = null;
      
      sess = null;

View Full Code Here


      ServerManagement.deployQueue("Queue", 10000, 1000, 1000);
      
      Queue queue = (Queue)initialContext.lookup("/queue/Queue");
      
      Connection conn = cf.createConnection();


      Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);


      MessageProducer prod = sess.createProducer(queue);


      prod.setDeliveryMode(DeliveryMode.NON_PERSISTENT);


      final int NUM_MESSAGES = 100;
      
      //send some messages
      ArrayList payLoad = new ArrayList();
      for (int i=0;i<100;i++)
      {
         payLoad.add("" + i);
      }
      conn.start();
      MessageConsumer cons1 = sess.createConsumer(queue,"target='1'");
      MessageConsumer cons2 = sess.createConsumer(queue,"target='2'");


      produceMessages(sess, prod, 30, cons1,cons2,payLoad);
      
      JVMTIInterface jvmti = new JVMTIInterface();
      Map inventory1=jvmti.produceInventory();
      log.info("Producing first snapshot");
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      produceMessages(sess, prod, 10, cons1,cons2,payLoad);
      log.info("Producing second snapshot");
      Map inventory2 = jvmti.produceInventory();
      
      log.info("inventory1.size=" + inventory1.size());
      log.info("inventory2.size=" + inventory2.size());
      
      assertTrue("Test produced unexpected objects",jvmti.compareInventories(System.out, inventory1,inventory2,null, null, new InventoryDataPoint[] {new InventoryDataPoint(Object.class,10)}));
      
      conn.close();
      
      conn = null;
      
      sess = null;

View Full Code Here

      
      final int numRelayers = 5;
      
      final int numConsumers = 20;
      
      Connection conn = cf.createConnection();
      
      class Relayer implements MessageListener
      {
         boolean done;
         
         boolean failed;
         
         int count;
         
         MessageProducer prod;
         
         Relayer(MessageProducer prod)
         {
            this.prod = prod;
         }
         
         public void onMessage(Message m)
         {
            try
            {
               //log.info(this + " got message");
               
               //log.info("blah");               
               
               m.clearProperties();
               m.setStringProperty("name", "Tim");
               
               //log.info("set property");
 
               prod.send(m);
               
               //log.info("sent");
               
               count++;
               
               if (count % 100 == 0)
               {
                 // log.info("relayed " + count + " messages");
               }
               
               if (count == numMessages)
               {
                  synchronized (this)
                  {                
                     done = true;
                     notify();
                  }
               }
            }
            catch (JMSException e)
            {
               e.printStackTrace();
               synchronized (this)
               {                  
                  done = true;
                  failed = true;
                  notify();
               }               
            }         
         }
      }
      
      class Consumer implements MessageListener
      {
         boolean failed;
         
         boolean done;
         
         int count;
         
         public void onMessage(Message m)
         {
            count++; 
            
            if (count % 100 == 0)
            {
               //log.info("consumed " + count + " messages");
            }
            
            if (count == numMessages * numRelayers)
            {
               synchronized (this)
               {  
                  done = true;                  
                  notify();
                  //log.info(this + " done");
               }
            }
         }
      }
      
      Relayer[] relayers = new Relayer[numRelayers];
      
      Consumer[] consumers = new Consumer[numConsumers];
      
            
      for (int i = 0; i < numRelayers; i++)
      {
         Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
         
         MessageConsumer cons = sess.createConsumer(topic, "name = 'Watt'");
         //MessageConsumer cons = sess.createConsumer(topic);
         
         MessageProducer prod = sess.createProducer(topic);
         
         relayers[i] = new Relayer(prod);
         
         cons.setMessageListener(relayers[i]);
      }
      
      for (int i = 0; i < numConsumers; i++)
      {
         Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
         
         MessageConsumer cons = sess.createConsumer(topic, "name = 'Tim'");
         
         consumers[i] = new Consumer();
         
         cons.setMessageListener(consumers[i]);
      }
      
      conn.start();
      
      Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      
      MessageProducer prod = sess.createProducer(topic);
      
      prod.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
      
      for (int i = 0; i < numMessages; i++)
      {
         Message m = sess.createMessage();
         
         m.setStringProperty("name", "Watt");
         
         prod.send(m);
         
         if (i % 100 == 0)
         {
            log.info("sent " + i + " messages");
         }
      }
      
      log.info("sent messages");
      
      for (int i = 0; i < numRelayers; i++)
      {
         synchronized (relayers[i])
         {
            if (!relayers[i].done)
            {
               relayers[i].wait();
            }
         }
      }
      
      for (int i = 0; i < numConsumers; i++)
      {
         synchronized (consumers[i])
         {
            if (!consumers[i].done)
            {
               consumers[i].wait();
            }
         }
      }
      
      conn.close();
      
      for (int i = 0; i < numRelayers; i++)
      {
         assertFalse(relayers[i].failed);         
      }

View Full Code Here

   }


   //Check messages have correct type after being resurrected from persistent storage
   public void testPersistedMessageType() throws Exception
   {
      Connection theConn = null;
      Connection theOtherConn = null;


      try
      {
         theConn = cf.createConnection();
         theConn.start();


         //Send some persistent messages to a queue with no receivers
         Session sessSend = theConn.createSession(false, Session.AUTO_ACKNOWLEDGE);


         MessageProducer theProducer = sessSend.createProducer(queue2);
         theProducer.setDeliveryMode(DeliveryMode.PERSISTENT);


         Message m = sessSend.createMessage();
         m.setStringProperty("p1", "aardvark");


         BytesMessage bm = sessSend.createBytesMessage();
         bm.writeObject("aardvark");


         MapMessage mm = sessSend.createMapMessage();
         mm.setString("s1", "aardvark");


         ObjectMessage om = sessSend.createObjectMessage();
         om.setObject("aardvark");


         StreamMessage sm = sessSend.createStreamMessage();
         sm.writeString("aardvark");


         TextMessage tm = sessSend.createTextMessage("aardvark");


         theProducer.send(m);
         theProducer.send(bm);
         theProducer.send(mm);
         theProducer.send(om);
         theProducer.send(sm);
         theProducer.send(tm);


         theConn.close();


         theOtherConn = cf.createConnection();
         theOtherConn.start();


         Session sessReceive = theOtherConn.createSession(false, Session.AUTO_ACKNOWLEDGE);


         MessageConsumer theConsumer = sessReceive.createConsumer(queue2);


         Message m2 = theConsumer.receive(1500);


         log.trace("m2 is " + m2);


         assertNotNull(m2);


         assertEquals("aardvark", m2.getStringProperty("p1"));


         BytesMessage bm2 = (BytesMessage)theConsumer.receive(1500);
         assertEquals("aardvark", bm2.readUTF());


         MapMessage mm2 = (MapMessage)theConsumer.receive(1500);
         assertEquals("aardvark", mm2.getString("s1"));


         ObjectMessage om2 = (ObjectMessage)theConsumer.receive(1500);
         assertEquals("aardvark", (String)om2.getObject());


         StreamMessage sm2 = (StreamMessage)theConsumer.receive(1500);
         assertEquals("aardvark", sm2.readString());
      }
      finally
      {
         if (theConn != null)
         {
            theConn.close();
         }
         if (theOtherConn != null)
         {
            theOtherConn.close();
         }
      }




   }

View Full Code Here


   public void testDurableSubscriptionSimple() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";


      Connection conn1 = null;


      try
      {
         conn1 = cf.createConnection();


         conn1.setClientID(CLIENT_ID1);


         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer prod = sess1.createProducer(topic);
         prod.setDeliveryMode(DeliveryMode.PERSISTENT);


         MessageConsumer durable = sess1.createDurableSubscriber(topic, "mySubscription");


         conn1.start();


         final int NUM_MESSAGES = 50;


         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sess1.createTextMessage("hello");
            prod.send(topic, tm);
         }


         int count = 0;
         while (true)
         {
            TextMessage tm = (TextMessage)durable.receive(1500);
            if (tm == null)
            {
               break;
            }
            count++;
         }


         assertEquals(NUM_MESSAGES, count);


         durable.close();


         sess1.unsubscribe("mySubscription");
      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }
      }


   }

View Full Code Here


   public void testDurableSubscriptionMultipleSubscriptions() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";


      Connection conn1 = null;
      Connection conn2 = null;


      try
      {


         conn1 = cf.createConnection();


         conn1.setClientID(CLIENT_ID1);


         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);


         log.debug("creating first durable subscription");
         sess1.createDurableSubscriber(topic, "mySubscription1");


         log.debug("creating the second durable subscription");
         sess1.createDurableSubscriber(topic, "mySubscription2");


         log.debug("closing conn1");
         conn1.close();


         conn2 = cf.createConnection();
         conn2.setClientID(CLIENT_ID1);


         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer producer = sess2.createProducer(topic);
         producer.setDeliveryMode(DeliveryMode.PERSISTENT);


         final int NUM_MESSAGES = 50;


         log.debug("sending messages");


         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sess2.createTextMessage("hello");
            producer.send(tm);
         }


         log.debug("all " + NUM_MESSAGES + " messages sent");


         sess2.unsubscribe("mySubscription1");


         log.debug("unsubscribed 'mySubscription1'");


         conn2.close();


         Connection conn3 = cf.createConnection();
         conn3.setClientID(CLIENT_ID1);
         conn3.start();
         Session sess3 = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer durable3 = sess3.createDurableSubscriber(topic, "mySubscription2");


         int count = 0;
         while (true)
         {
            TextMessage tm = (TextMessage)durable3.receive(1000);
            if (tm == null)
            {
               break;
            }
            assertEquals("hello", tm.getText());
            count++;
         }


         assertEquals(NUM_MESSAGES, count);


         log.debug("received " + NUM_MESSAGES + " messages");


         MessageConsumer durable4 = sess3.createDurableSubscriber(topic, "mySubscription1");


         Message m = durable4.receive(1000);
         assertNull(m);
         
         conn3.close();


      }
      finally
      {
         if (conn1 != null)

View Full Code Here


   public void testDurableSubscriptionDataRemaining() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";


      Connection conn1 = null;
      Connection conn2 = null;
      Connection conn3 = null;
      Connection conn4 = null;
      Connection conn5 = null;
      Connection conn6 = null;


      Session sess1;
      Session sess3;
      Session sess4;
      Session sess6 = null;


      try
      {


         // Create a durable subscriber on one connection and close it
         conn1 = cf.createConnection();
         conn1.setClientID(CLIENT_ID1);
         sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageConsumer durable = sess1.createDurableSubscriber(topic, "mySubscription");
         conn1.close();




         // Send some messages on another connection and close it
         conn2 = cf.createConnection();
         conn2.setClientID(CLIENT_ID1);
         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer prod2 = sess2.createProducer(topic);
         prod2.setDeliveryMode(DeliveryMode.PERSISTENT);
         final int NUM_MESSAGES = 10;
         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sess2.createTextMessage("hello");
            prod2.send(topic, tm);
         }
         conn2.close();


         // Receive the messages on another connection
         conn3 = cf.createConnection();
         conn3.setClientID(CLIENT_ID1);
         conn3.start();
         sess3 = conn3.createSession(false, Session.AUTO_ACKNOWLEDGE);
         durable = sess3.createDurableSubscriber(topic, "mySubscription");
         int count = 0;
         while (true)
         {
            TextMessage tm = (TextMessage)durable.receive(1000);
            if (tm == null)
            {
               break;
            }
            assertEquals("hello", tm.getText());
            count++;
         }
         assertEquals(NUM_MESSAGES, count);
         conn3.close();


         // Try and receive them again
         conn4 = cf.createConnection();
         conn4.setClientID(CLIENT_ID1);
         conn4.start();
         sess4 = conn4.createSession(false, Session.AUTO_ACKNOWLEDGE);
         durable = sess4.createDurableSubscriber(topic, "mySubscription");


         TextMessage tm = (TextMessage)durable.receive(1000);
         assertNull(tm);
         conn4.close();


         // Send some more messages and unsubscribe
         conn5 = cf.createConnection();
         conn5.setClientID(CLIENT_ID1);
         conn5.start();
         Session sess5 = conn5.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer prod5 = sess5.createProducer(topic);
         prod5.setDeliveryMode(DeliveryMode.PERSISTENT);


         log.debug("sending.1 " + NUM_MESSAGES + " messages");
         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm2 = sess5.createTextMessage("hello");
            prod5.send(topic, tm2);
         }


         log.debug("unsubscribing mySubscription");


         durable.close();
         sess5.unsubscribe("mySubscription");
         log.debug("unsubscribing done");
         conn5.close();


         // Resubscribe with the same name
         conn6 = cf.createConnection();
         conn6.setClientID(CLIENT_ID1);
         conn6.start();
         sess6 = conn6.createSession(false, Session.AUTO_ACKNOWLEDGE);
         durable = sess6.createDurableSubscriber(topic, "mySubscription");


         TextMessage tm3 = (TextMessage)durable.receive(1000);
         assertNull(tm3);


         durable.close();
      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }
         if (conn2 != null)
         {
            conn2.close();
         }
         if (conn3 != null)
         {
            conn3.close();
         }
         if (conn4 != null)
         {
            conn4.close();
         }
         if (conn5 != null)
         {
            conn5.close();
         }
         if (sess6 != null)
         {
            sess6.unsubscribe("mySubscription");
         }
         if (conn6 != null)
         {
            conn6.close();
         }
      }


   }

View Full Code Here


   public void testDurableSubscriptionReconnect() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";


      Connection conn1 = null;
      Connection conn2 = null;


      try
      {
         conn1 = cf.createConnection();
         conn1.setClientID(CLIENT_ID1);


         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer prod = sess1.createProducer(topic);
         prod.setDeliveryMode(DeliveryMode.PERSISTENT);


         log.debug("creating durable subscription");
         MessageConsumer durable = sess1.createDurableSubscriber(topic, "mySubscription");
         log.debug("durable subscription created");


         conn1.start();


         final int NUM_MESSAGES = 2;




         log.debug("sending messages ...");


         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sess1.createTextMessage("hello");
            prod.send(topic, tm);
         }


         final int NUM_TO_RECEIVE = NUM_MESSAGES - 1;


         log.debug("receiving messages ...");


         for (int i = 0; i < NUM_TO_RECEIVE; i++)
         {
            TextMessage tm = (TextMessage)durable.receive(3000);
            assertNotNull(tm);
         }


         // Close the connection
         conn1.close();
         conn1 = null;


         conn2 = cf.createConnection();


         conn2.setClientID(CLIENT_ID1);


         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);


         // Re-subscribe to the subscription


         log.trace("resubscribing");


         MessageConsumer durable2 = sess2.createDurableSubscriber(topic, "mySubscription");


         conn2.start();


         int count = 0;
         while (true)
         {
            TextMessage tm = (TextMessage)durable2.receive(1500);
            if (tm == null)
            {
               break;
            }
            count++;
         }


         log.trace("Received " + count  + " messages");


         assertEquals(NUM_MESSAGES - NUM_TO_RECEIVE, count);


         durable2.close();


         sess2.unsubscribe("mySubscription");
      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }
         if (conn2 != null)
         {
            conn2.close();
         }
      }




   }

View Full Code Here

   public void testDurableSubscriptionReconnectDifferentClientID() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";
      final String CLIENT_ID2 = "test-client-id2";


      Connection conn1 = null;
      Connection conn2 = null;


      try
      {
         conn1 = cf.createConnection();


         conn1.setClientID(CLIENT_ID1);


         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);
         MessageProducer prod = sess1.createProducer(topic);
         prod.setDeliveryMode(DeliveryMode.PERSISTENT);


         MessageConsumer durable = sess1.createDurableSubscriber(topic, "mySubscription");


         conn1.start();


         final int NUM_MESSAGES = 50;




         for (int i = 0; i < NUM_MESSAGES; i++)
         {
            TextMessage tm = sess1.createTextMessage("hello");
            prod.send(topic, tm);
         }


         final int NUM_TO_RECEIVE1 = 22;


         for (int i = 0; i < NUM_TO_RECEIVE1; i++)
         {
            TextMessage tm = (TextMessage)durable.receive(1500);
            if (tm == null)
            {
               fail();
            }
         }


         //Close the connection
         conn1.close();
         conn1 = null;


         conn2 = cf.createConnection();


         conn2.setClientID(CLIENT_ID2);


         Session sess2 = conn2.createSession(false, Session.AUTO_ACKNOWLEDGE);


         //Re-subscribe to the subscription
         MessageConsumer durable2 = sess2.createDurableSubscriber(topic, "mySubscription");


         conn2.start();


         int count = 0;
         while (true)
         {
            TextMessage tm = (TextMessage)durable2.receive(1500);
            if (tm == null)
            {
               break;
            }
            count++;
         }


         assertEquals(0, count);


         durable2.close();


         sess2.unsubscribe("mySubscription");
      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }
         if (conn2 != null)
         {
            conn2.close();
         }
      }


   }

View Full Code Here


   public void testDurableSubscriptionInvalidUnsubscribe() throws Exception
   {
      final String CLIENT_ID1 = "test-client-id1";


      Connection conn1 = null;


      try
      {
         conn1 = cf.createConnection();




         conn1.setClientID(CLIENT_ID1);


         Session sess1 = conn1.createSession(false, Session.AUTO_ACKNOWLEDGE);


         try
         {
            sess1.unsubscribe("non-existent subscription");
            fail();
         }
         catch (JMSException e)
         {
         }
      }
      finally
      {
         if (conn1 != null)
         {
            conn1.close();
         }
      }
   }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.jms.Connection

com.bitsofproof.supernode.api.InMemoryBusTest

com.camunda.fox.jms.OrderJmsService

com.sun.messaging.bridge.service.jms.JMSBridge

com.sun.messaging.bridge.service.jms.SharedConnectionFactory

com.sun.messaging.jmq.admin.jmsspi.JMSAdminImpl

com.sun.messaging.jms.blc.LifecycleManagedBroker

com.sun.messaging.ums.service.CachedConnectionPool

net.lr.karaf.jms.service.JmsServiceTest

org.apache.activemq.ActiveMQXAConnectionFactoryTest

org.apache.activemq.broker.scheduler.JobSchedulerManagementTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.