org.messaginghub.pooled.jms.JmsPoolConnectionFactory Java Examples

private JmsPoolConnectionFactory create(ConnectionFactory connectionFactory, JmsPoolConnectionFactoryProperties poolProperties) {

      JmsPoolConnectionFactory pooledConnectionFactory = new JmsPoolConnectionFactory();
      pooledConnectionFactory.setConnectionFactory(connectionFactory);

      pooledConnectionFactory.setBlockIfSessionPoolIsFull(poolProperties.isBlockIfFull());

      if (poolProperties.getBlockIfFullTimeout() != null) {
        pooledConnectionFactory.setBlockIfSessionPoolIsFullTimeout(poolProperties.getBlockIfFullTimeout().toMillis());
      }

      if (poolProperties.getIdleTimeout() != null) {
        pooledConnectionFactory.setConnectionIdleTimeout((int) poolProperties.getIdleTimeout().toMillis());
      }

      pooledConnectionFactory.setMaxConnections(poolProperties.getMaxConnections());
      pooledConnectionFactory.setMaxSessionsPerConnection(poolProperties.getMaxSessionsPerConnection());

      if (poolProperties.getTimeBetweenExpirationCheck() != null) {
        pooledConnectionFactory.setConnectionCheckInterval(poolProperties.getTimeBetweenExpirationCheck().toMillis());
      }

      pooledConnectionFactory.setUseAnonymousProducers(poolProperties.isUseAnonymousProducers());
      return pooledConnectionFactory;
    }
 

public void configurePooledFactory(JmsPoolConnectionFactory factory) {
    factory.setBlockIfSessionPoolIsFull(isBlockIfSessionPoolIsFull());
    if (getBlockIfSessionPoolIsFullTimeout() != null) {
        factory.setBlockIfSessionPoolIsFullTimeout(getBlockIfSessionPoolIsFullTimeout().toMillis());
    }
    if (getConnectionCheckInterval() != null) {
        factory.setConnectionCheckInterval(getConnectionCheckInterval().toMillis());
    }
    if (getConnectionIdleTimeout() != null) {
        factory.setConnectionIdleTimeout((int) getConnectionIdleTimeout().toMillis());
    }
    factory.setExplicitProducerCacheSize(getExplicitProducerCacheSize());
    factory.setMaxConnections(getMaxConnections());
    factory.setMaxSessionsPerConnection(getMaxSessionsPerConnection());
    factory.setUseAnonymousProducers(isUseAnonymousProducers());
    factory.setUseProviderJMSContext(isUseProviderJMSContext());
}
 

@Bean(destroyMethod = "stop")
@ConditionalOnProperty(prefix = "amqphub.amqp10jms.pool", name = "enabled", havingValue = "true", matchIfMissing = false)
public JmsPoolConnectionFactory pooledJmsConnectionFactory(
        AMQP10JMSProperties properties,
        ObjectProvider<List<AMQP10JMSConnectionFactoryCustomizer>> factoryCustomizers) {

    JmsPoolConnectionFactory pooledConnectionFactory = new JmsPoolConnectionFactory();
    pooledConnectionFactory.setConnectionFactory(
        new AMQP10JMSConnectionFactoryFactory(properties, factoryCustomizers.getIfAvailable())
            .createConnectionFactory(JmsConnectionFactory.class));

    AMQP10JMSProperties.Pool pool = properties.getPool();

    pool.configurePooledFactory(pooledConnectionFactory);

    return pooledConnectionFactory;
}
 

@Test(timeout = 60000)
public void testSetClientIDAfterConnectionStart() throws Exception {
    LOG.debug("running testRepeatedSetClientIDCalls()");

    ConnectionFactory cf = createPooledConnectionFactory();
    Connection conn = cf.createConnection();

    // test: try to call setClientID() after start()
    // should result in an exception
    try {
        conn.start();
        conn.setClientID("newID3");
        fail("Calling setClientID() after start() must raise a JMSException.");
    } catch (IllegalStateException ise) {
        LOG.debug("Correctly received " + ise);
    } finally {
        conn.close();
        ((JmsPoolConnectionFactory) cf).stop();
    }

    LOG.debug("Test finished.");
}
 

@Test(timeout = 60000)
public void testSetClientIDTwiceWithDifferentID() throws Exception {
    LOG.debug("running testRepeatedSetClientIDCalls()");

    ConnectionFactory cf = createPooledConnectionFactory();
    Connection conn = cf.createConnection();

    // test: call setClientID() twice with different IDs
    // this should result in an IllegalStateException
    conn.setClientID("newID1");
    try {
        conn.setClientID("newID2");
        fail("calling Connection.setClientID() twice with different clientID must raise an IllegalStateException");
    } catch (IllegalStateException ise) {
        LOG.debug("Correctly received " + ise);
    } finally {
        conn.close();
        ((JmsPoolConnectionFactory) cf).stop();
    }

    LOG.debug("Test finished.");
}
 

@Test(timeout = 60000)
public void testSetClientIDTwiceWithSameID() throws Exception {
    LOG.debug("running testRepeatedSetClientIDCalls()");

    // test: call setClientID("newID") twice
    // this should be tolerated and not result in an exception
    ConnectionFactory cf = createPooledConnectionFactory();
    Connection conn = cf.createConnection();
    conn.setClientID("newID");

    try {
        conn.setClientID("newID");
        conn.start();
        conn.close();
    } catch (IllegalStateException ise) {
        LOG.error("Repeated calls to newID2.setClientID(\"newID\") caused " + ise.getMessage());
        fail("Repeated calls to newID2.setClientID(\"newID\") caused " + ise.getMessage());
    } finally {
        ((JmsPoolConnectionFactory) cf).stop();
    }

    LOG.debug("Test finished.");
}
 

@Test(timeout = 60000)
public void testConnectionsArePooled() throws Exception {
    JmsPoolConnectionFactory cf = createPooledConnectionFactory();
    cf.setMaxConnections(1);

    JmsPoolConnection conn1 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn2 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn3 = (JmsPoolConnection) cf.createConnection();

    assertSame(conn1.getConnection(), conn2.getConnection());
    assertSame(conn1.getConnection(), conn3.getConnection());
    assertSame(conn2.getConnection(), conn3.getConnection());

    assertEquals(1, cf.getNumConnections());

    cf.stop();
}
 

@Test(timeout = 60000)
public void testConnectionsAreRotated() throws Exception {
    JmsPoolConnectionFactory cf = createPooledConnectionFactory();
    cf.setMaxConnections(10);

    Connection previous = null;

    // Front load the pool.
    for (int i = 0; i < 10; ++i) {
        cf.createConnection();
    }

    for (int i = 0; i < 100; ++i) {
        Connection current = ((JmsPoolConnection) cf.createConnection()).getConnection();
        assertNotSame(previous, current);
        previous = current;
    }

    cf.stop();
}
 

@Test(timeout = 60000)
public void testMaxConnectionsAreCreated() throws Exception {
    JmsPoolConnectionFactory cf = createPooledConnectionFactory();
    cf.setMaxConnections(3);

    JmsPoolConnection conn1 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn2 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn3 = (JmsPoolConnection) cf.createConnection();

    assertNotSame(conn1.getConnection(), conn2.getConnection());
    assertNotSame(conn1.getConnection(), conn3.getConnection());
    assertNotSame(conn2.getConnection(), conn3.getConnection());

    assertEquals(3, cf.getNumConnections());

    cf.stop();
}
 

@Test(timeout = 60000)
public void testClearAllConnections() throws Exception {
    JmsPoolConnectionFactory cf = createPooledConnectionFactory();
    cf.setMaxConnections(3);

    JmsPoolConnection conn1 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn2 = (JmsPoolConnection) cf.createConnection();
    JmsPoolConnection conn3 = (JmsPoolConnection) cf.createConnection();

    assertNotSame(conn1.getConnection(), conn2.getConnection());
    assertNotSame(conn1.getConnection(), conn3.getConnection());
    assertNotSame(conn2.getConnection(), conn3.getConnection());

    assertEquals(3, cf.getNumConnections());

    cf.clear();

    assertEquals(0, cf.getNumConnections());

    conn1 = (JmsPoolConnection) cf.createConnection();
    conn2 = (JmsPoolConnection) cf.createConnection();
    conn3 = (JmsPoolConnection) cf.createConnection();

    assertNotSame(conn1.getConnection(), conn2.getConnection());
    assertNotSame(conn1.getConnection(), conn3.getConnection());
    assertNotSame(conn2.getConnection(), conn3.getConnection());

    cf.stop();
}
 

protected JmsPoolConnectionFactory createPooledConnectionFactory() {
    JmsPoolConnectionFactory cf = new JmsPoolConnectionFactory();
    cf.setConnectionFactory(qpidJmsConnectionFactory);
    cf.setMaxConnections(1);
    LOG.debug("ConnectionFactory initialized.");
    return cf;
}
 

@Test(timeout = 60000)
public void testInstanceOf() throws  Exception {
    JmsPoolConnectionFactory pcf = new JmsPoolConnectionFactory();
    assertTrue(pcf instanceof QueueConnectionFactory);
    assertTrue(pcf instanceof TopicConnectionFactory);
    pcf.stop();
}
 

@Before
public void setUp() throws Exception {
    LOG.info("========== start test: " + getTestName() + " ==========");

    factory = new MockJMSConnectionFactory();
    cf = new JmsPoolConnectionFactory();
    cf.setConnectionFactory(factory);
    cf.setMaxConnections(1);
}
 

@Before
public void setUp() throws Exception {
    mock = new MockJMSConnectionFactory();

    // Ensure only one connection for that tests validate that shared connections
    // only destroy their own created temporary destinations.
    cf = new JmsPoolConnectionFactory();
    cf.setConnectionFactory(mock);
    cf.setMaxConnections(1);
}
 

@Test(timeout = 60000)
public void testInstanceOf() throws  Exception {
    JmsPoolConnectionFactory pcf = new JmsPoolConnectionFactory();
    assertTrue(pcf instanceof QueueConnectionFactory);
    assertTrue(pcf instanceof TopicConnectionFactory);
    pcf.stop();
}
 

@Override
@Before
   public void setUp() throws Exception {
       factory = new MockJMSConnectionFactory();
       cf = new JmsPoolConnectionFactory();
       cf.setConnectionFactory(factory);
       cf.setMaxConnections(1);
       cf.setBlockIfSessionPoolIsFull(false);
       cf.setMaxSessionsPerConnection(1);
   }
 

@Bean(destroyMethod = "stop")
@ConditionalOnProperty(prefix = "ibm.mq.pool", name = "enabled", havingValue = "true", matchIfMissing = false)
public JmsPoolConnectionFactory pooledJmsConnectionFactory(MQConfigurationProperties properties,
    ObjectProvider<List<MQConnectionFactoryCustomizer>> factoryCustomizers) {

  MQConnectionFactory connectionFactory = createConnectionFactory(properties, factoryCustomizers);

  return create(connectionFactory, properties.getPool());
}
 

@Test
public void testDefaultsToPoolDefaults() {
    load(EmptyConfiguration.class,
        "amqphub.amqp10jms.pool.enabled=true");

    JmsTemplate jmsTemplate = this.context.getBean(JmsTemplate.class);
    ConnectionFactory connectionFactory =
        this.context.getBean(ConnectionFactory.class);

    assertTrue(connectionFactory instanceof JmsPoolConnectionFactory);
    assertEquals(jmsTemplate.getConnectionFactory(), connectionFactory);

    JmsPoolConnectionFactory pooledFactory = (JmsPoolConnectionFactory) connectionFactory;

    assertTrue(pooledFactory.isBlockIfSessionPoolIsFull());
    assertTrue(pooledFactory.isUseAnonymousProducers());
    assertFalse(pooledFactory.isUseProviderJMSContext());

    assertEquals(1, pooledFactory.getMaxConnections());
    assertEquals(500, pooledFactory.getMaxSessionsPerConnection());
    assertEquals(0, pooledFactory.getExplicitProducerCacheSize());

    assertEquals(30000, pooledFactory.getConnectionIdleTimeout());
    assertEquals(-1, pooledFactory.getConnectionCheckInterval());
    assertEquals(-1, pooledFactory.getBlockIfSessionPoolIsFullTimeout());

    assertTrue(pooledFactory.getConnectionFactory() instanceof JmsConnectionFactory);

    JmsConnectionFactory qpidJmsFactory = (JmsConnectionFactory) pooledFactory.getConnectionFactory();

    assertEquals("amqp://localhost:5672", qpidJmsFactory.getRemoteURI());
    assertNull(qpidJmsFactory.getUsername());
    assertNull(qpidJmsFactory.getPassword());
}
 

@Test
public void testConfiguredJmsPoolConnectionFactory() {
    load(EmptyConfiguration.class,
        "amqphub.amqp10jms.pool.blockIfSessionPoolIsFull=false",
        "amqphub.amqp10jms.pool.useAnonymousProducers=false",
        "amqphub.amqp10jms.pool.useProviderJMSContext=true",
        "amqphub.amqp10jms.pool.maxConnections=2",
        "amqphub.amqp10jms.pool.maxSessionsPerConnection=100",
        "amqphub.amqp10jms.pool.explicitProducerCacheSize=5",
        "amqphub.amqp10jms.pool.connectionIdleTimeout=100",
        "amqphub.amqp10jms.pool.connectionCheckInterval=50",
        "amqphub.amqp10jms.pool.blockIfSessionPoolIsFullTimeout=3000",
        "amqphub.amqp10jms.pool.enabled=true");

    ConnectionFactory connectionFactory =
        this.context.getBean(ConnectionFactory.class);

    assertTrue(connectionFactory instanceof JmsPoolConnectionFactory);

    JmsPoolConnectionFactory pooledFactory = (JmsPoolConnectionFactory) connectionFactory;

    assertFalse(pooledFactory.isBlockIfSessionPoolIsFull());
    assertFalse(pooledFactory.isUseAnonymousProducers());
    assertTrue(pooledFactory.isUseProviderJMSContext());

    assertEquals(2, pooledFactory.getMaxConnections());
    assertEquals(100, pooledFactory.getMaxSessionsPerConnection());
    assertEquals(5, pooledFactory.getExplicitProducerCacheSize());

    assertEquals(100, pooledFactory.getConnectionIdleTimeout());
    assertEquals(50, pooledFactory.getConnectionCheckInterval());
    assertEquals(3000, pooledFactory.getBlockIfSessionPoolIsFullTimeout());

    assertTrue(pooledFactory.getConnectionFactory() instanceof JmsConnectionFactory);
}
 

@Test(timeout = 60000)
public void testFactoryStopStart() throws Exception {
    JmsPoolConnectionFactory cf = createPooledConnectionFactory();
    cf.setMaxConnections(1);

    JmsPoolConnection conn1 = (JmsPoolConnection) cf.createConnection();

    cf.stop();

    assertNull(cf.createConnection());

    cf.start();

    JmsPoolConnection conn2 = (JmsPoolConnection) cf.createConnection();

    assertNotSame(conn1.getConnection(), conn2.getConnection());

    assertEquals(1, cf.getNumConnections());

    cf.stop();
}