Java PooledConnectionFactory.setIdleTimeout方法代码示例

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
/**
 * Inits the.
 *
 * @throws JMSException the jMS exception
 */
public void init() throws JMSException {
    Properties properties = new Properties();
    try {
        properties.load(this.getClass().getResourceAsStream("/sink.properties"));
    } catch (IOException e) {
        logger.error("got: " + e.getMessage());
    }

    user = properties.getProperty("amq.user");
    password = System.getenv("KLOOPZ_AMQ_PASS");


    if (password == null) {
        throw new JMSException("missing KLOOPZ_AMQ_PASS env var");
    }

    AMQConnectorURI connectStringGenerator = new AMQConnectorURI();
    connectStringGenerator.setHost("opsmq");
    connectStringGenerator.setProtocol("tcp");
    connectStringGenerator.setPort(61616);
    connectStringGenerator.setTransport("failover");
    connectStringGenerator.setDnsResolve(true);
    connectStringGenerator.setKeepAlive(true);
    HashMap<String, String> transportOptions = new HashMap<>();
    transportOptions.put("initialReconnectDelay", "1000");
    transportOptions.put("startupMaxReconnectAttempts", mqConnectionStartupRetries);
    transportOptions.put("timeout", mqConnectionTimeout);
    transportOptions.put("useExponentialBackOff", "false");
    connectStringGenerator.setTransportOptions(transportOptions);
    url = connectStringGenerator.build();

    showParameters();

    // Create the connection.
    ActiveMQConnectionFactory amqConnectionFactory = new ActiveMQConnectionFactory(user, password, url);
    amqConnectionFactory.setUseAsyncSend(true);
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(amqConnectionFactory);
    pooledConnectionFactory.setMaxConnections(amqConnectionPoolSize);
    pooledConnectionFactory.setIdleTimeout(10000);

    for (int i = 0; i < poolsize; i++) {
        JmsTemplate producerTemplate = new JmsTemplate(pooledConnectionFactory);
        producerTemplate.setSessionTransacted(false);
        int shard = i + 1;
        Destination perfin = new org.apache.activemq.command.ActiveMQQueue(queueBase + "-" + shard);
        producerTemplate.setDefaultDestination(perfin);
        producerTemplate.setDeliveryPersistent(false);
        producers[i] = producerTemplate;
    }


}
 

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
@Bean(destroyMethod = "stop")
@ConditionalOnProperty(prefix = "spring.activemq.pool", name = "enabled", havingValue = "true", matchIfMissing = false)
@ConfigurationProperties("spring.activemq.pool.configuration")
public PooledConnectionFactory pooledJmsConnectionFactory(
		ActiveMQProperties properties) {
	PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(
			new ActiveMQConnectionFactoryFactory(properties)
					.createConnectionFactory(ActiveMQConnectionFactory.class));

	ActiveMQProperties.Pool pool = properties.getPool();
	pooledConnectionFactory.setMaxConnections(pool.getMaxConnections());
	pooledConnectionFactory.setIdleTimeout(pool.getIdleTimeout());
	pooledConnectionFactory.setExpiryTimeout(pool.getExpiryTimeout());
	return pooledConnectionFactory;
}
 

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
/**
 * Creates the JMS connection factory without registering it.
 * 
 * @param repo  the component repository, only used to register secondary items like lifecycle, not null
 * @return the JMS connection factory, not null
 */
protected ConnectionFactory createConnectionFactory(ComponentRepository repo) {
  ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(getClientBrokerUri());
  connectionFactory.setWatchTopicAdvisories(false);
  PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(connectionFactory);
  pooledConnectionFactory.setIdleTimeout(0);
  return pooledConnectionFactory;
}
 

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
public void addMQPool(String url, String username, String password) {
	connectionPool = new PooledConnectionFactory(url);
	connectionPool.setMaxConnections(maxTotal);
	connectionPool.setMaximumActiveSessionPerConnection(maxIdle);
	connectionPool.setIdleTimeout(maxWaitMillis);
	this.username = username;
	this.password = password;
}
 

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
private void startConsumer(){
  ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(brokerUrl);
  pooledConnectionFactory = new PooledConnectionFactory(factory);
  pooledConnectionFactory.setReconnectOnException(true);
  pooledConnectionFactory.setMaximumActiveSessionPerConnection(10); // 10
  pooledConnectionFactory.setMaxConnections(10); // 10
  pooledConnectionFactory.setIdleTimeout(300000); // 管理连接池中的连接，5分钟超时   300000
  pooledConnectionFactory.setUseAnonymousProducers(false);
  pooledConnectionFactory.start();
  Thread t = new Thread(){
    @Override
    public void run() {
      // consumer
      Connection conn ;
      Session sess;
      MessageConsumer consumer;
      try {
        while(!shutdown){
          conn = pooledConnectionFactory.createConnection();
          conn.start();
          sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
          Destination dest = sess.createQueue("_eds_"+queueName);
          consumer = sess.createConsumer(dest);
          Message msg = consumer.receive();

          if(msg != null){
            System.out.println("received => "+msg);
            msgReceived.incrementAndGet();
          }
          consumer.close();
          sess.close();
          conn.close();
          System.out.println("receiving => "+msg);
        }
      } catch (JMSException e) {
        e.printStackTrace();
      }

    }
  };
  t.start();
}
 

import org.apache.activemq.pool.PooledConnectionFactory; //导入方法依赖的package包/类
/**
 * 从连接池中取得连接，如果连接池为null，则初始化连接池
 * <p>
 * 由于连接池中取得的连接会自动回收，因此该连接不能用于Consumer，池连接主要用于Producer
 * 
 * @return Connection
 * @throws JMSException
 */
private Connection getPooledConnection() throws JMSException {
	if (null == producerPooledFactory) {
		// 初始化连接池工厂并设置参数
		synchronized (this) {
			if (serverUrl == null || serverUrl.trim().equals("")) {
				throw new FwRuntimeException("未设置服务器地址serverUrl");
			}

			if (brokerForProduct == null) {
				StringBuilder brokerUrlSb = new StringBuilder();
				brokerUrlSb.append("failover:(");
				String[] hostArr = serverUrl.split(",");
				for (String host : hostArr) {
					brokerUrlSb.append("tcp://" + host + "?connectionTimeout=" + connectTimeout).append(",");
				}
				// 删除最后多出来的,号
				brokerUrlSb.deleteCharAt(brokerUrlSb.length() - 1);
				brokerUrlSb.append(")?timeout=" + operateTimeout);
				brokerForProduct = brokerUrlSb.toString();
			}

			if (producerPooledFactory == null) {
				ActiveMQConnectionFactory connectionFactory = FwMqServiceHelper.createConnectionFactory(
						brokerForProduct, userName, password);

				PooledConnectionFactory pcf = new PooledConnectionFactory(connectionFactory);
				// 设置连接池尺寸
				pcf.setMaxConnections(maximumConnections);
				// 设置每个连接的最多Session数
				pcf.setMaximumActive(maximumActive);
				// 设置连接闲置超时回收时间
				pcf.setIdleTimeout(idleTimeout);

				producerPooledFactory = pcf;
			}

			initMqHealthMBean();// 注册MBean
		}
	}
	return producerPooledFactory.createConnection();
}