Java DefaultMessageListenerContainer.start方法代码示例

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@BeforeClass
public void setUpClass() {
  JmsConnector jmsConnector = ActiveMQTestUtils.createTestJmsConnector();
  
  _factory = new JmsSenderFactory(jmsConnector);
  _mdd = MarketDataDistributorTest.getTestDistributor(_factory);
  
  _collectingReceiver = new CollectingByteArrayMessageReceiver();
  JmsByteArrayMessageDispatcher messageDispatcher = new JmsByteArrayMessageDispatcher(_collectingReceiver);
  
  _container = new DefaultMessageListenerContainer();
  _container.setConnectionFactory(jmsConnector.getConnectionFactory());
  _container.setMessageListener(messageDispatcher);
  _container.setDestinationName(_mdd.getDistributionSpec().getJmsTopic());
  _container.setPubSubDomain(true);
  _container.afterPropertiesSet();
  _container.start();
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
private void start(String beanName){
	if(StringUtils.isEmpty(beanName)){
		return;
	}
	DefaultMessageListenerContainer c = this.applicationContext.
			getBean(beanName,DefaultMessageListenerContainer.class);
	if(c != null)c.start();
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@PostConstruct
public void afterPropertiesSet() throws Exception {
    if (!enabled) {
        return;
    }

    this.buildComposite();

    for (DefaultMessageListenerContainer defaultMessageListenerContainer : defaultMessageListenerContainers) {
        defaultMessageListenerContainer.afterPropertiesSet();
        defaultMessageListenerContainer.start();
    }
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@Test
public void testSpringReceiverXa() throws Exception {
    ConnectionFactory cf = createCF(BROKER_URL);

    DefaultJmsListenerContainerFactory jlcf = new DefaultJmsListenerContainerFactory();
    jlcf.setTransactionManager(ptm);
    jlcf.setSessionTransacted(true);
    jlcf.setConnectionFactory(cf);

    AtomicReference<Message> holder = new AtomicReference<>();

    SimpleJmsListenerEndpoint jle = new SimpleJmsListenerEndpoint();
    jle.setDestination(QUEUE);
    jle.setMessageListener(message -> {
        synchronized (holder) {
            holder.set(message);
            holder.notifyAll();
        }
    });
    DefaultMessageListenerContainer mlc = jlcf.createListenerContainer(jle);
    mlc.initialize();
    mlc.start();

    JmsTemplate jms = new JmsTemplate(cf);
    jms.setDefaultDestinationName(QUEUE);

    synchronized (holder) {
        jms.convertAndSend("Hello");
        holder.wait();
    }
    assertNotNull(holder.get());

}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
public void startListener() {
    MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter();
    messageListenerAdapter.setDelegate(this);
    messageListenerAdapter.setMessageConverter(mqMessageConverter);

    DefaultMessageListenerContainer mqListener = new DefaultMessageListenerContainer();
    mqListener.setConnectionFactory(mqConnectionFactory.getFactory());
    mqListener.setDestinationName(appConfig.getMqQueueName());
    mqListener.setMessageListener(messageListenerAdapter);
    mqListener.setConcurrency("4-8");
    mqListener.setSessionTransacted(true);

    mqListener.initialize();
    mqListener.start();
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
public void registerMessageListener(MessageListener listener,
                                    String destinationName)
{
  log.info("registerMessageListener(" + destinationName + ", " + listener + ")");
  container = new DefaultMessageListenerContainer();
  container.setConnectionFactory(connectionFactory);
  container.setDestinationName(destinationName);
  container.setMessageListener(listener);
  container.setTaskExecutor(taskExecutor);
  container.afterPropertiesSet();
  container.start();
  
  listenerContainerMap.put(listener, container);
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@Override
public void subscribe(final Process process) {
  LOGGER.trace("Subscribing to updates from Process " + process.getId());
  if (!jmsContainers.containsKey(process.getId())) {
    DefaultMessageListenerContainer container = subscribe(process, properties.getJms().getUpdate().getMaxConsumers());
    container.start();
  } else {
    LOGGER.warn("Attempt at creating a JMS listener container for a Process that already has one.");
  }
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@Test(invocationCount = 5, successPercentage = 19)
public void topicConduit() throws Exception {
  String topicName = "JmsByteArrayTransportTest-topicConduit-" + System.getProperty("user.name") + "-" + System.currentTimeMillis();
  ConnectionFactory cf = ActiveMQTestUtils.createTestConnectionFactory();
  JmsTemplate jmsTemplate = new JmsTemplate();
  jmsTemplate.setConnectionFactory(cf);
  jmsTemplate.setPubSubDomain(true);
  
  JmsByteArrayMessageSender messageSender = new JmsByteArrayMessageSender(topicName, jmsTemplate);
  CollectingByteArrayMessageReceiver collectingReceiver = new CollectingByteArrayMessageReceiver();
  JmsByteArrayMessageDispatcher messageDispatcher = new JmsByteArrayMessageDispatcher(collectingReceiver);
  
  DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
  container.setConnectionFactory(cf);
  container.setMessageListener(messageDispatcher);
  container.setDestinationName(topicName);
  container.setPubSubDomain(true);
  container.afterPropertiesSet();
  container.start();

  Random random = new Random();
  byte[] randomBytes = new byte[1024];
  random.nextBytes(randomBytes);
  
  while(!container.isRunning()) {
    Thread.sleep(10l);
  }
  //TODO: this is a hack.  The context doesn't seem to have always set up the consumer completely yet
  Thread.sleep(500l);
  
  messageSender.send(randomBytes);
  long startTime = System.currentTimeMillis();
  while(collectingReceiver.getMessages().isEmpty()) {
    Thread.sleep(10l);
    if ((System.currentTimeMillis() - startTime) > TIMEOUT) {
      fail("Did not receive a message in " + (TIMEOUT / 1000) + " seconds.");
    }
  }
  s_logger.debug ("topicConduit message received {}ms before timeout limit", TIMEOUT - (System.currentTimeMillis () - startTime));
  assertEquals(1, collectingReceiver.getMessages().size());
  byte[] receivedBytes = collectingReceiver.getMessages().get(0);
  assertEquals(randomBytes.length, receivedBytes.length);
  for(int i = 0; i < randomBytes.length; i++) {
    assertEquals(randomBytes[i], receivedBytes[i]);
  }
  
  container.stop();
  container.destroy();
}
 

import org.springframework.jms.listener.DefaultMessageListenerContainer; //导入方法依赖的package包/类
@Test(invocationCount = 5, successPercentage = 19)
public void requestConduit() throws Exception {
  String topicName = "JmsByteArrayTransportTest-requestConduit-" + System.getProperty("user.name") + "-" + System.currentTimeMillis();
  ConnectionFactory cf = ActiveMQTestUtils.createTestConnectionFactory();
  JmsTemplate jmsTemplate = new JmsTemplate();
  jmsTemplate.setConnectionFactory(cf);
  jmsTemplate.setPubSubDomain(true);
  jmsTemplate.setReceiveTimeout(5000l);

  final Random random = new Random();
  final byte[] responseBytes = new byte[512];
  random.nextBytes(responseBytes);
  
  JmsByteArrayRequestSender requestSender = new JmsByteArrayRequestSender(topicName, jmsTemplate);
  JmsByteArrayRequestDispatcher requestDispatcher = new JmsByteArrayRequestDispatcher(new ByteArrayRequestReceiver() {
    @Override
    public byte[] requestReceived(byte[] message) {
      return responseBytes;
    }
  });
  
  DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
  container.setConnectionFactory(cf);
  container.setMessageListener(requestDispatcher);
  container.setDestinationName(topicName);
  container.setPubSubDomain(true);
  container.afterPropertiesSet();
  container.start();

  byte[] randomBytes = new byte[1024];
  random.nextBytes(randomBytes);
  
  while(!container.isRunning()) {
    Thread.sleep(10l);
  }
  
  CollectingByteArrayMessageReceiver collectingReceiver = new CollectingByteArrayMessageReceiver();
  requestSender.sendRequest(randomBytes, collectingReceiver);
  long startTime = System.currentTimeMillis();
  while(collectingReceiver.getMessages().isEmpty()) {
    Thread.sleep(10l);
    if ((System.currentTimeMillis() - startTime) > TIMEOUT) {
      fail("Did not receive a response in " + (TIMEOUT / 1000) + " seconds.");
    }
  }
  s_logger.debug ("requestConduit message received {}ms before timeout limit", TIMEOUT - (System.currentTimeMillis () - startTime));
  assertEquals(1, collectingReceiver.getMessages().size());
  byte[] receivedBytes = collectingReceiver.getMessages().get(0);
  assertEquals(responseBytes.length, receivedBytes.length);
  for(int i = 0; i < responseBytes.length; i++) {
    assertEquals(responseBytes[i], receivedBytes[i]);
  }
  
  container.stop();
  container.destroy();
}