org.apache.activemq.artemis.jms.client.ActiveMQJMSConnectionFactory Java Examples

@Test
public void testArtemisJMSClient() throws Exception {
   // setup connection
   ConnectionFactory cf = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   try (Connection connection = cf.createConnection()) {
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      connection.start();
      Queue queue = ActiveMQJMSClient.createQueue("artemisJMSClientFeatureITQueue");
      MessageProducer producer = session.createProducer(queue);
      // send message
      String textMessage = "This is a text message";
      TextMessage message = session.createTextMessage(textMessage);
      producer.send(message);

      // receive message and assert
      MessageConsumer messageConsumer = session.createConsumer(queue);
      TextMessage messageReceived = (TextMessage) messageConsumer.receive(100);
      assertEquals(textMessage, messageReceived.getText());
   }
}
 

private Connection createCoreConnection(String connectionString, String username, String password, String clientId, boolean start) throws JMSException {
   ActiveMQJMSConnectionFactory factory = new ActiveMQJMSConnectionFactory(connectionString);

   Connection connection = trackJMSConnection(factory.createConnection(username, password));

   connection.setExceptionListener(new ExceptionListener() {
      @Override
      public void onException(JMSException exception) {
         exception.printStackTrace();
      }
   });

   if (clientId != null && !clientId.isEmpty()) {
      connection.setClientID(clientId);
   }

   if (start) {
      connection.start();
   }

   return connection;
}
 

private void jmsSendMessage(Serializable value, String destName, boolean isQueue) throws JMSException {
   ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   String jmsDest;
   if (isQueue) {
      jmsDest = QUEUE_QUALIFIED_PREFIX + destName;
   } else {
      jmsDest = TOPIC_QUALIFIED_PREFIX + destName;
   }
   Destination destination = ActiveMQDestination.fromPrefixedName(jmsDest);

   Connection conn = factory.createConnection();
   try {
      Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = session.createProducer(destination);
      ObjectMessage message = session.createObjectMessage();
      message.setStringProperty(HttpHeaderProperty.CONTENT_TYPE, "application/xml");
      message.setObject(value);
      producer.send(message);
   } finally {
      conn.close();
   }
}
 

public static void main(String[] args) throws Exception {
   System.out.println("Receive Setup...");
   ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   Destination destination = ActiveMQDestination.fromPrefixedName("queue://orders");

   try (Connection conn = factory.createConnection()) {
      Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageConsumer consumer = session.createConsumer(destination);
      consumer.setMessageListener(new MessageListener() {
         @Override
         public void onMessage(Message message) {
            System.out.println("Received Message: ");
            Order order = Jms.getEntity(message, Order.class);
            System.out.println(order);
         }
      });
      conn.start();
      Thread.sleep(1000000);
   }
}
 

public static void main(String[] args) throws Exception {
   ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   Destination destination = ActiveMQDestination.fromPrefixedName("queue://shipping");

   try (Connection conn = factory.createConnection()) {
      Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageConsumer consumer = session.createConsumer(destination);
      consumer.setMessageListener(new MessageListener() {
         @Override
         public void onMessage(Message message) {
            System.out.println("Received Message: ");
            Order order = Jms.getEntity(message, Order.class);
            System.out.println(order);
         }
      });
      conn.start();
      Thread.sleep(1000000);
   }
}
 

@Before
public void init() {
    factory = new ActiveMQJMSConnectionFactory(
            "tcp://localhost:61616",
            null, null);
    jms = factory.createContext();
}
 

@Test
public void testJGroupsKeyValue() throws Exception {
   ActiveMQConnectionFactory factory = parser.newObject(new URI("jgroups://channel-name?properties=param=value;param2=value2&test=33"), null);

   Assert.assertTrue(ActiveMQJMSConnectionFactory.class.getName().equals(factory.getClass().getName()));
   JGroupsPropertiesBroadcastEndpointFactory broadcastEndpointFactory = (JGroupsPropertiesBroadcastEndpointFactory) factory.getDiscoveryGroupConfiguration().getBroadcastEndpointFactory();
   Assert.assertEquals(broadcastEndpointFactory.getProperties(), "param=value;param2=value2");
   Assert.assertEquals(broadcastEndpointFactory.getChannelName(), "channel-name");
}
 

@Test
public void testJGroupsFile() throws Exception {
   ActiveMQConnectionFactory factory = parser.newObject(new URI("jgroups://channel-name?file=/path/to/some/file/channel-file.xml&test=33"), null);

   Assert.assertTrue(ActiveMQJMSConnectionFactory.class.getName().equals(factory.getClass().getName()));
   JGroupsFileBroadcastEndpointFactory broadcastEndpointFactory = (JGroupsFileBroadcastEndpointFactory) factory.getDiscoveryGroupConfiguration().getBroadcastEndpointFactory();
   Assert.assertEquals(broadcastEndpointFactory.getFile(), "/path/to/some/file/channel-file.xml");
   Assert.assertEquals(broadcastEndpointFactory.getChannelName(), "channel-name");
}
 

private static ConnectionFactory createConnectionFactory() {

      ActiveMQJMSConnectionFactory cf = (ActiveMQJMSConnectionFactory) ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(InVMConnectorFactory.class.getName()));
      // Note! We disable automatic reconnection on the session factory. The bridge needs to do the reconnection
      cf.setReconnectAttempts(0);
      cf.setBlockOnNonDurableSend(true);
      cf.setBlockOnDurableSend(true);
      return cf;
   }
 

@Override
@Before
public void setUp() throws Exception {
   super.setUp();

   ic = getInitialContext();

   // All jms tests should use a specific cg which has blockOnAcknowledge = true and
   // both np and p messages are sent synchronously
   cf = new ActiveMQJMSConnectionFactory("tcp://127.0.0.1:61616?blockOnAcknowledge=true&blockOnDurableSend=true&blockOnNonDurableSend=true");
   queueCf = new ActiveMQQueueConnectionFactory("tcp://127.0.0.1:61616?blockOnAcknowledge=true&blockOnDurableSend=true&blockOnNonDurableSend=true");
   topicCf = new ActiveMQTopicConnectionFactory("tcp://127.0.0.1:61616?blockOnAcknowledge=true&blockOnDurableSend=true&blockOnNonDurableSend=true");

   assertRemainingMessages(0);
}
 

public static ConnectionFactory createFactory(final String connectorFactory,
                                              final long connectionTTL,
                                              final long clientFailureCheckPeriod) throws JMSException {
   ActiveMQJMSConnectionFactory cf = (ActiveMQJMSConnectionFactory) ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(connectorFactory));

   cf.setBlockOnNonDurableSend(true);
   cf.setBlockOnDurableSend(true);
   cf.setBlockOnAcknowledge(true);
   cf.setConnectionTTL(connectionTTL);
   cf.setClientFailureCheckPeriod(clientFailureCheckPeriod);

   return cf;
}
 

public static Connection createConnection(final String connectorFactory) throws JMSException {
   ActiveMQJMSConnectionFactory cf = (ActiveMQJMSConnectionFactory) ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(connectorFactory));

   cf.setBlockOnNonDurableSend(true);
   cf.setBlockOnDurableSend(true);
   cf.setBlockOnAcknowledge(true);

   return cf.createConnection();
}
 

@Override
protected ConnectionFactory getCF() throws Exception {
   ActiveMQJMSConnectionFactory cf1 = (ActiveMQJMSConnectionFactory) ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(INVM_CONNECTOR_FACTORY));

   cf1.setAutoGroup(true);

   return cf1;
}
 

@Override
protected ConnectionFactory getCF() throws Exception {
   ActiveMQJMSConnectionFactory cf = (ActiveMQJMSConnectionFactory) ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, new TransportConfiguration(INVM_CONNECTOR_FACTORY));

   cf.setGroupID("wibble");

   return cf;
}
 

public static void main(String[] args) throws Exception {
   ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   Destination destination = ActiveMQDestination.fromPrefixedName("queue://orders");

   try (Connection conn = factory.createConnection()) {
      Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = session.createProducer(destination);
      ObjectMessage message = session.createObjectMessage();

      Order order = new Order("Bill", "$199.99", "iPhone4");
      message.setObject(order);
      producer.send(message);
   }
}
 

@BeforeClass
public static void setup() throws Exception {
   connectionFactory = new ActiveMQJMSConnectionFactory(manager.getQueueManager().getServerLocator());
   log.debug("Queue name: " + prefixedTopicName);
   TopicDeployment deployment = new TopicDeployment();
   deployment.setDuplicatesAllowed(true);
   deployment.setDurableSend(false);
   deployment.setName(topicName);
   manager.getTopicManager().deploy(deployment);
}
 

public static void main(String[] args) throws Exception {
   ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616");
   Destination destination = ActiveMQDestination.fromPrefixedName("queue://orders");

   try (Connection conn = factory.createConnection()) {
      Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = session.createProducer(destination);
      ObjectMessage message = session.createObjectMessage();

      Order order = new Order("Bill", "$199.99", "iPhone4");
      message.setObject(order);
      producer.send(message);
   }
}
 

@Before
public void init() {
    factory = new ActiveMQJMSConnectionFactory(
            "tcp://localhost:61616",
            null, null);
    jms = factory.createContext();
    json = JsonbBuilder.create();
    executor = Executors.newFixedThreadPool(3);
}
 

@Produces
@Named("bar")
ConnectionFactory factory() {
    return new ActiveMQJMSConnectionFactory(
            "tcp://localhost:61618", // Wrong on purpose
            null, null);
}
 

@Produces
@ApplicationScoped
@DefaultBean
public ConnectionFactory connectionFactory() {
    return new ActiveMQJMSConnectionFactory(config.url,
            config.username.orElse(null), config.password.orElse(null));
}
 

@Produces
@Named("foo")
ConnectionFactory factory() {
    return new ActiveMQJMSConnectionFactory(
            "tcp://localhost:61616",
            null, null);
}
 

@Before
public void init() {
    factory = new ActiveMQJMSConnectionFactory(
            "tcp://localhost:61616",
            null, null);
    jms = factory.createContext();
}
 

ArtemisJmsTestRule(TestName testName) {
  super(testName);
  factory = new ActiveMQJMSConnectionFactory("vm://0");
  factory.setProducerMaxRate(1); // to allow tests to use production order
}
 

@Test
public void testInvalidCFType() throws Exception {
   ActiveMQConnectionFactory factory = parser.newObject(new URI("udp://localhost:3030?ha=true&type=QUEUE_XA_CFInvalid"), null);

   Assert.assertTrue(ActiveMQJMSConnectionFactory.class.getName().equals(factory.getClass().getName()));
}
 

@Test
public void testNoCF() throws Exception {
   ActiveMQConnectionFactory factory = parser.newObject(new URI("tcp://localhost:3030?ha=true"), null);

   Assert.assertTrue(ActiveMQJMSConnectionFactory.class.getName().equals(factory.getClass().getName()));
}
 

@Test
public void testCF() throws Exception {
   ActiveMQConnectionFactory factory = parser.newObject(new URI("tcp://localhost:3030?ha=true&type=CF"), null);

   Assert.assertTrue(ActiveMQJMSConnectionFactory.class.getName().equals(factory.getClass().getName()));
}
 

@Test
public void testStartWithSpecificTCCL() throws Exception {
   MockContextClassLoader mockTccl = setMockTCCL();
   try {
      final AtomicReference<Connection> sourceConn = new AtomicReference<>();
      ActiveMQJMSConnectionFactory failingSourceCF = new ActiveMQJMSConnectionFactory(false, new TransportConfiguration(InVMConnectorFactory.class.getName())) {
         private static final long serialVersionUID = -8866390811966688830L;

         @Override
         public Connection createConnection() throws JMSException {
            sourceConn.set(super.createConnection());
            return sourceConn.get();
         }
      };
      // Note! We disable automatic reconnection on the session factory. The bridge needs to do the reconnection
      failingSourceCF.setReconnectAttempts(0);
      failingSourceCF.setBlockOnNonDurableSend(true);
      failingSourceCF.setBlockOnDurableSend(true);

      ConnectionFactoryFactory sourceCFF = JMSBridgeImplTest.newTCCLAwareConnectionFactoryFactory(failingSourceCF);
      ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
      DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
      DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
      TransactionManager tm = JMSBridgeImplTest.newTransactionManager();

      JMSBridgeImpl bridge = new JMSBridgeImpl();
      Assert.assertNotNull(bridge);

      bridge.setSourceConnectionFactoryFactory(sourceCFF);
      bridge.setSourceDestinationFactory(sourceDF);
      bridge.setTargetConnectionFactoryFactory(targetCFF);
      bridge.setTargetDestinationFactory(targetDF);
      bridge.setFailureRetryInterval(10);
      bridge.setMaxRetries(2);
      bridge.setMaxBatchSize(1);
      bridge.setMaxBatchTime(-1);
      bridge.setTransactionManager(tm);
      bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);

      Assert.assertFalse(bridge.isStarted());
      bridge.start();
      Assert.assertTrue(bridge.isStarted());

      unsetMockTCCL(mockTccl);
      tcclClassFound.set(false);

      sourceConn.get().getExceptionListener().onException(new JMSException("exception on the source"));
      Thread.sleep(4 * bridge.getFailureRetryInterval());
      // reconnection must have succeeded
      Assert.assertTrue(bridge.isStarted());

      bridge.stop();
      Assert.assertFalse(bridge.isStarted());
      assertTrue(tcclClassFound.get());
   } finally {
      if (mockTccl != null)
         unsetMockTCCL(mockTccl);
   }
}
 

@Test
public void testExceptionOnSourceAndRetryFails() throws Exception {
   final AtomicReference<Connection> sourceConn = new AtomicReference<>();
   ActiveMQJMSConnectionFactory failingSourceCF = new ActiveMQJMSConnectionFactory(false, new TransportConfiguration(INVM_CONNECTOR_FACTORY)) {
      private static final long serialVersionUID = 8216804886099984645L;
      boolean firstTime = true;

      @Override
      public Connection createConnection() throws JMSException {
         if (firstTime) {
            firstTime = false;
            sourceConn.set(super.createConnection());
            return sourceConn.get();
         } else {
            throw new JMSException("exception while retrying to connect");
         }
      }
   };
   // Note! We disable automatic reconnection on the session factory. The bridge needs to do the reconnection
   failingSourceCF.setReconnectAttempts(0);
   failingSourceCF.setBlockOnNonDurableSend(true);
   failingSourceCF.setBlockOnDurableSend(true);

   ConnectionFactoryFactory sourceCFF = JMSBridgeImplTest.newConnectionFactoryFactory(failingSourceCF);
   ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
   DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
   DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
   TransactionManager tm = JMSBridgeImplTest.newTransactionManager();

   JMSBridgeImpl bridge = new JMSBridgeImpl();
   Assert.assertNotNull(bridge);

   bridge.setSourceConnectionFactoryFactory(sourceCFF);
   bridge.setSourceDestinationFactory(sourceDF);
   bridge.setTargetConnectionFactoryFactory(targetCFF);
   bridge.setTargetDestinationFactory(targetDF);
   bridge.setFailureRetryInterval(100);
   bridge.setMaxRetries(1);
   bridge.setMaxBatchSize(1);
   bridge.setMaxBatchTime(-1);
   bridge.setTransactionManager(tm);
   bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);

   Assert.assertFalse(bridge.isStarted());
   bridge.start();
   Assert.assertTrue(bridge.isStarted());

   sourceConn.get().getExceptionListener().onException(new JMSException("exception on the source"));
   Thread.sleep(4 * bridge.getFailureRetryInterval());
   // reconnection must have failed
   Assert.assertFalse(bridge.isStarted());

}
 

@Test
public void testExceptionOnSourceAndRetrySucceeds() throws Exception {
   final AtomicReference<Connection> sourceConn = new AtomicReference<>();
   ActiveMQJMSConnectionFactory failingSourceCF = new ActiveMQJMSConnectionFactory(false, new TransportConfiguration(InVMConnectorFactory.class.getName())) {
      private static final long serialVersionUID = -8866390811966688830L;

      @Override
      public Connection createConnection() throws JMSException {
         sourceConn.set(super.createConnection());
         return sourceConn.get();
      }
   };
   // Note! We disable automatic reconnection on the session factory. The bridge needs to do the reconnection
   failingSourceCF.setReconnectAttempts(0);
   failingSourceCF.setBlockOnNonDurableSend(true);
   failingSourceCF.setBlockOnDurableSend(true);

   ConnectionFactoryFactory sourceCFF = JMSBridgeImplTest.newConnectionFactoryFactory(failingSourceCF);
   ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
   DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
   DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
   TransactionManager tm = JMSBridgeImplTest.newTransactionManager();

   JMSBridgeImpl bridge = new JMSBridgeImpl();
   Assert.assertNotNull(bridge);

   bridge.setSourceConnectionFactoryFactory(sourceCFF);
   bridge.setSourceDestinationFactory(sourceDF);
   bridge.setTargetConnectionFactoryFactory(targetCFF);
   bridge.setTargetDestinationFactory(targetDF);
   bridge.setFailureRetryInterval(10);
   bridge.setMaxRetries(2);
   bridge.setMaxBatchSize(1);
   bridge.setMaxBatchTime(-1);
   bridge.setTransactionManager(tm);
   bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);

   Assert.assertFalse(bridge.isStarted());
   bridge.start();
   Assert.assertTrue(bridge.isStarted());

   sourceConn.get().getExceptionListener().onException(new JMSException("exception on the source"));
   Thread.sleep(4 * bridge.getFailureRetryInterval());
   // reconnection must have succeeded
   Assert.assertTrue(bridge.isStarted());

   bridge.stop();
   Assert.assertFalse(bridge.isStarted());
}
 

@Test
public void testStartWithFailureThenSuccess() throws Exception {
   ActiveMQJMSConnectionFactory failingSourceCF = new ActiveMQJMSConnectionFactory(false, new TransportConfiguration(InVMConnectorFactory.class.getName())) {
      private static final long serialVersionUID = 4657153922210359725L;
      boolean firstTime = true;

      @Override
      public Connection createConnection() throws JMSException {
         if (firstTime) {
            firstTime = false;
            throw new JMSException("unable to create a conn");
         } else {
            return super.createConnection();
         }
      }
   };
   // Note! We disable automatic reconnection on the session factory. The bridge needs to do the reconnection
   failingSourceCF.setReconnectAttempts(0);
   failingSourceCF.setBlockOnNonDurableSend(true);
   failingSourceCF.setBlockOnDurableSend(true);

   ConnectionFactoryFactory sourceCFF = JMSBridgeImplTest.newConnectionFactoryFactory(failingSourceCF);
   ConnectionFactoryFactory targetCFF = JMSBridgeImplTest.newConnectionFactoryFactory(JMSBridgeImplTest.createConnectionFactory());
   DestinationFactory sourceDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.SOURCE));
   DestinationFactory targetDF = JMSBridgeImplTest.newDestinationFactory(ActiveMQJMSClient.createQueue(JMSBridgeImplTest.TARGET));
   TransactionManager tm = JMSBridgeImplTest.newTransactionManager();

   JMSBridgeImpl bridge = new JMSBridgeImpl();

   bridge.setSourceConnectionFactoryFactory(sourceCFF);
   bridge.setSourceDestinationFactory(sourceDF);
   bridge.setTargetConnectionFactoryFactory(targetCFF);
   bridge.setTargetDestinationFactory(targetDF);
   // retry after 10 ms
   bridge.setFailureRetryInterval(10);
   // retry only once
   bridge.setMaxRetries(1);
   bridge.setMaxBatchSize(1);
   bridge.setMaxBatchTime(-1);
   bridge.setTransactionManager(tm);
   bridge.setQualityOfServiceMode(QualityOfServiceMode.AT_MOST_ONCE);

   Assert.assertFalse(bridge.isStarted());
   bridge.start();

   Thread.sleep(500);
   Assert.assertTrue(bridge.isStarted());
   Assert.assertFalse(bridge.isFailed());

   bridge.stop();
}