org.springframework.jms.connection.SingleConnectionFactory Java Examples

@Override
public void stop() {
  if (running) {
    running = false;
    try {
      LOGGER.debug("Shutting down ProcessCommunicationManager bean and associated JMS connections.");
      if (processOutConnectionFactory instanceof SingleConnectionFactory) {
        ((SingleConnectionFactory) processOutConnectionFactory).destroy();
      }
    } catch (Exception e) {
      LOGGER.error("Exception caught when trying to shutdown the server->DAQ JMS connections:", e);
      e.printStackTrace(System.err);
    }
  }
}
 

public Connection createConnection() throws JMSException {
    if (BatchedMessageListenerContainer.this.sharedConnectionEnabled()) {
        Connection sharedCon = BatchedMessageListenerContainer.this.getSharedConnection();
        return new SingleConnectionFactory(sharedCon).createConnection();
    } else {
        return BatchedMessageListenerContainer.this.createConnection();
    }
}
 

@Bean
@ConditionalOnMissingBean
public ConnectionFactory connectionFactory() {
    if (configurer != null) {
        return configurer.connectionFactory();
    }

    return new SingleConnectionFactory();
}
 

private void initializeSingleConnectionFactory() throws Exception {
    boolean reconnectOnException = mqPropertyEntity.getBoolean(ThunderConstant.MQ_RECONNECT_ON_EXCEPTION_ATTRIBUTE_NAME);

    SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory();
    singleConnectionFactory.setReconnectOnException(reconnectOnException);

    connectionFactory = singleConnectionFactory;
}
 

@Override
public Connection createConnection() throws JMSException {
	if (AbstractPollingMessageListenerContainer.this.sharedConnectionEnabled()) {
		Connection sharedCon = AbstractPollingMessageListenerContainer.this.getSharedConnection();
		return new SingleConnectionFactory(sharedCon).createConnection();
	}
	else {
		return AbstractPollingMessageListenerContainer.this.createConnection();
	}
}
 

/**
 * Constructor.
 * @param clientJmsContainer JMS container used in client module
 * @param clientExecutor thread pool used by container
 * @param singleConnectionFactory client request connection factory
 *
 */
@Autowired
public ClientModuleLifecycle(@Qualifier("clientRequestJmsContainer") final DefaultMessageListenerContainer clientJmsContainer,
                                  @Qualifier("clientExecutor") final ThreadPoolExecutor clientExecutor,
                                  @Qualifier("clientSingleConnectionFactory") final SingleConnectionFactory singleConnectionFactory,
                                  @Qualifier("adminRequestJmsContainer") final DefaultMessageListenerContainer adminJmsContainer,
                                  @Qualifier("adminSingleConnectionFactory") final SingleConnectionFactory adminSingleConnectionFactory) {
  super();
  this.clientJmsContainer = clientJmsContainer;
  this.clientExecutor = clientExecutor;
  this.singleConnectionFactory = singleConnectionFactory;
  this.adminConnectionFactory = adminSingleConnectionFactory;
  this.adminJmsContainer = adminJmsContainer;
}
 

/**
 * 队列模板
 *
 * @param singleConnectionFactory 连接工厂
 * @return 队列模板
 */
@Bean(name = "jmsTemplate")
public JmsTemplate jmsTemplate(@Qualifier("connectionFactory") SingleConnectionFactory singleConnectionFactory) {
    JmsTemplate notifyJmsTemplate = new JmsTemplate();
    notifyJmsTemplate.setConnectionFactory(singleConnectionFactory);
    notifyJmsTemplate.setDefaultDestinationName(orderQueryDestinationName);
    return notifyJmsTemplate;
}
 

/**
 * 消息监听容器
 *
 * @param singleConnectionFactory    连接工厂
 * @param orderQueryQueueDestination 消息目的地
 * @param pollingMessageListener     监听器实现
 * @return 消息监听容器
 */
@Bean(name = "orderQueryQueueMessageListenerContainer")
public DefaultMessageListenerContainer orderQueryQueueMessageListenerContainer(@Qualifier("connectionFactory") SingleConnectionFactory singleConnectionFactory, @Qualifier("orderQueryQueueDestination") ActiveMQQueue orderQueryQueueDestination, @Qualifier("pollingMessageListener") PollingMessageListener pollingMessageListener) {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(singleConnectionFactory);
    messageListenerContainer.setDestination(orderQueryQueueDestination);
    messageListenerContainer.setMessageListener(pollingMessageListener);
    return messageListenerContainer;
}
 

/**
 * 消息监听容器
 *
 * @param singleConnectionFactory             连接工厂
 * @param tradeQueueDestination               消息目的地
 * @param consumerSessionAwareMessageListener 监听器实现
 * @return 消息监听容器
 */
@Bean(name = "tradeQueueMessageListenerContainer")
public DefaultMessageListenerContainer tradeQueueMessageListenerContainer(@Qualifier("connectionFactory") SingleConnectionFactory singleConnectionFactory, @Qualifier("tradeQueueDestination") ActiveMQQueue tradeQueueDestination, @Qualifier("consumerSessionAwareMessageListener") ConsumerSessionAwareMessageListener consumerSessionAwareMessageListener) {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(singleConnectionFactory);
    messageListenerContainer.setMessageListener(consumerSessionAwareMessageListener);
    messageListenerContainer.setDestination(tradeQueueDestination);
    return messageListenerContainer;
}
 

@Override
public Connection createConnection() throws JMSException {
	if (AbstractPollingMessageListenerContainer.this.sharedConnectionEnabled()) {
		Connection sharedCon = AbstractPollingMessageListenerContainer.this.getSharedConnection();
		return new SingleConnectionFactory(sharedCon).createConnection();
	}
	else {
		return AbstractPollingMessageListenerContainer.this.createConnection();
	}
}
 

@Override
public Connection createConnection() throws JMSException {
	if (AbstractPollingMessageListenerContainer.this.sharedConnectionEnabled()) {
		Connection sharedCon = AbstractPollingMessageListenerContainer.this.getSharedConnection();
		return new SingleConnectionFactory(sharedCon).createConnection();
	}
	else {
		return AbstractPollingMessageListenerContainer.this.createConnection();
	}
}
 

@Bean
public SingleConnectionFactory adminSingleConnectionFactory() {
  return new SingleConnectionFactory(adminActiveMQConnectionFactory());
}
 

@Bean
public SingleConnectionFactory clientSingleConnectionFactory() {
  return new SingleConnectionFactory(clientActiveMQConnectionFactory());
}
 

@Bean
public SingleConnectionFactory heartbeatSingleConnectionFactory() {
  return new SingleConnectionFactory(heartbeatConnectionFactory());
}
 

@Bean
public SingleConnectionFactory processOutConnectionFactory() {
  return new SingleConnectionFactory(daqOutActiveMQConnectionFactory());
}
 

@Bean
public SingleConnectionFactory singleConnectionFactory() {
  return new SingleConnectionFactory(activeMQConnectionFactory());
}
 

@Bean
public SingleConnectionFactory filterConnectionFactory() {
  return new SingleConnectionFactory(filterActiveMQConnectionFactory());
}
 

@Bean
public SingleConnectionFactory secondSingleConnectionFactory() {
  return new SingleConnectionFactory(secondActiveMQConnectionFactory());
}
 

@Override
public ConnectionFactory connectionFactory() {
    return new SingleConnectionFactory();
}
 

/**
 * <p>
 * Use provided clientId for non shared durable consumers, if not set
 * always a different value as defined in {@link AbstractJMSProcessor#setClientId(ProcessContext, SingleConnectionFactory)}.
 * </p>
 * See {@link Session#createDurableConsumer(javax.jms.Topic, String, String, boolean)},
 * in special following part: <i>An unshared durable subscription is
 * identified by a name specified by the client and by the client identifier,
 * which must be set. An application which subsequently wishes to create
 * a consumer on that unshared durable subscription must use the same
 * client identifier.</i>
 */
@Override
protected void setClientId(ProcessContext context, SingleConnectionFactory cachingFactory) {
    if (isDurableSubscriber(context) && !isShared(context)) {
        cachingFactory.setClientId(getClientId(context));
    } else {
        super.setClientId(context, cachingFactory);
    }
}
 

/**
 * Set clientId for JMS connections when <tt>clientId</tt> is not null.
 * It is overridden by {@code}ConsumeJMS{@code} when durable subscriptions
 * is configured on the processor.
 * @param context context.
 * @param connectionFactory the connection factory.
 * @since NIFI-6915
 */
protected void setClientId(ProcessContext context, final SingleConnectionFactory connectionFactory) {
    String clientId = getClientId(context);
    if (clientId != null) {
        clientId = clientId + "-" + clientIdCounter.getAndIncrement();
        connectionFactory.setClientId(clientId);
    }
}