Java SimpleJmsListenerEndpoint类代码示例

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
/**
 * Test for {@link CustomBean} and an manually endpoint registered
 * with "myCustomEndpointId". The custom endpoint does not provide
 * any factory so it's registered with the default one
 */
public void testCustomConfiguration(ApplicationContext context) {
	JmsListenerContainerTestFactory defaultFactory =
			context.getBean("jmsListenerContainerFactory", JmsListenerContainerTestFactory.class);
	JmsListenerContainerTestFactory customFactory =
			context.getBean("customFactory", JmsListenerContainerTestFactory.class);
	assertEquals(1, defaultFactory.getListenerContainers().size());
	assertEquals(1, customFactory.getListenerContainers().size());
	JmsListenerEndpoint endpoint = defaultFactory.getListenerContainers().get(0).getEndpoint();
	assertEquals("Wrong endpoint type", SimpleJmsListenerEndpoint.class, endpoint.getClass());
	assertEquals("Wrong listener set in custom endpoint", context.getBean("simpleMessageListener"),
			((SimpleJmsListenerEndpoint) endpoint).getMessageListener());

	JmsListenerEndpointRegistry customRegistry =
			context.getBean("customRegistry", JmsListenerEndpointRegistry.class);
	assertEquals("Wrong number of containers in the registry", 2,
			customRegistry.getListenerContainerIds().size());
	assertEquals("Wrong number of containers in the registry", 2,
			customRegistry.getListenerContainers().size());
	assertNotNull("Container with custom id on the annotation should be found",
			customRegistry.getListenerContainer("listenerId"));
	assertNotNull("Container created with custom id should be found",
			customRegistry.getListenerContainer("myCustomEndpointId"));
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
private void registerListenerEndpoint(JmsListenerEndpointRegistrar aRegistrar, String aQueueName, int aConcurrency, Object aDelegate, String aMethodName) {
  logger.info("Registring JMS Listener: {} -> {}:{}", aQueueName, aDelegate.getClass().getName(), aMethodName);
  
  MessageListenerAdapter messageListener = new MessageListenerAdapter(aDelegate);
  messageListener.setMessageConverter(jacksonJmsMessageConverter(objectMapper));
  messageListener.setDefaultListenerMethod(aMethodName);

  SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
  endpoint.setId(aQueueName+"Endpoint");
  endpoint.setDestination(aQueueName);
  endpoint.setMessageListener(messageListener);

  aRegistrar.registerEndpoint(endpoint,createContainerFactory(aConcurrency));
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的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.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
	registrar.setEndpointRegistry(customRegistry());

	// Also register a custom endpoint
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setId("myCustomEndpointId");
	endpoint.setDestination("myQueue");
	endpoint.setMessageListener(simpleMessageListener());
	registrar.registerEndpoint(endpoint);
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setId("myCustomEndpointId");
	endpoint.setDestination("myQueue");
	endpoint.setMessageListener(messageListener);
	registrar.registerEndpoint(endpoint);
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
    SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
    endpoint.setId("myJmsEndpoint");
    endpoint.setDestination(environment.getProperty("queue", "test.queue"));
    endpoint.setMessageListener(message -> {
        try {
            System.out.print(((TextMessage)message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    });
    registrar.registerEndpoint(endpoint);
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
  registrar.setContainerFactory(containerFactory);
  SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
  endpoint.setDestination("core-" + this.type + "-actions");
  endpoint.setMessageListener(this);
  loadProperties();
  log.debug("CONFIGURE Properties are: " + properties);
  endpoint.setConcurrency("5-" + properties.getProperty("concurrency", "15"));
  endpoint.setId(String.valueOf(Thread.currentThread().getId()));
  registrar.registerEndpoint(endpoint);
}
 

import org.springframework.jms.config.SimpleJmsListenerEndpoint; //导入依赖的package包/类
/**
 * Configure one endpoint
 *
 * @param endpointId
 * @param defaultLogin
 * @param defaultPassword
 * @return Configured endpoint
 */
private JmsListenerEndpoint configureEndpoint(String endpointId, String defaultLogin, String defaultPassword) throws Exception {
  // Define the endpoint
  SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
  endpoint.setId(endpointId);
  endpoint.setDestination(getRequiredEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_DESTINATION));
  
  String selector = getEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_SELECTOR);
  if (!StringUtils.isEmpty(selector)) {
    endpoint.setSelector(selector);
  }

  // Define the receiver
  //DefltMessageListener receiver = new DefaultMessageListener();
  String login = getEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_LOGIN, defaultLogin);
  String password = getEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_PASSWORD, defaultPassword);
  String definitionsIdentifier = getRequiredEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_BPMN_DEFINITION);
  
  String actionAsString = getEndpointProperty(endpointId, CONFIGURATION_KEY_JMS_ENDPOINT_BPMN_ACTION);
  BpmnAction action = BpmnAction.INSTANTIATE;
  try {
    action = BpmnAction.parse(actionAsString);
  } catch (IllegalArgumentException wrongArgument) {
    
    StringBuilder errorMessage = new StringBuilder();
    errorMessage.append("Action ('").append(actionAsString).append("') unknown for endpoint '");
    errorMessage.append(endpointId).append(" : only 'instantiate' or 'signal' are allowed.");
    if (ignoreErroneousEndpoint) {
      errorMessage.append(" Instantiate will be used.");
      logger.warn(errorMessage.toString());
    }
    else {
      throw new IllegalArgumentException(errorMessage.toString());
    }
  }
  
  Map<String, ? extends Object> listenerProperties = subsetToCamelCase(configuration, getEndpointBpmnPropertiesPrefix(endpointId), true);
  AbstractW4MessageListener listener = listenerFactory.getListener(action, login, password, definitionsIdentifier, listenerProperties);

  // Define the listener
  //MessageListenerAdapter listener = new MessageListenerAdapter(receiver);
  MessagingMessageListenerAdapter listenerAdapter = new DisposableMessagingMessageListenerAdapter();
  listenerAdapter.setHandlerMethod(methodFactory.createInvocableHandlerMethod(listener, getHandleMethod()));

  // Set the mapping if needed
  setMapping(endpointId, listenerAdapter);
  
  endpoint.setMessageListener(listenerAdapter);
  
  return endpoint;
}