import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
@Override
public void configureJmsListeners (JmsListenerEndpointRegistrar aRegistrar) {
  CoordinatorProperties coordinatorProperties = properties.getCoordinator();
  WorkerProperties workerProperties = properties.getWorker();
  if(coordinatorProperties.isEnabled()) {
    registerListenerEndpoint(aRegistrar, Queues.COMPLETIONS, coordinatorProperties.getSubscriptions().getCompletions() , coordinator, "complete");
    registerListenerEndpoint(aRegistrar, Queues.ERRORS, coordinatorProperties.getSubscriptions().getErrors(), coordinator, "handleError");
    registerListenerEndpoint(aRegistrar, Queues.EVENTS, coordinatorProperties.getSubscriptions().getEvents(), eventListener, "onApplicationEvent");
    registerListenerEndpoint(aRegistrar, Queues.JOBS, coordinatorProperties.getSubscriptions().getJobs(), coordinator, "start");
  }
  if(workerProperties.isEnabled()) {
    Map<String, Object> subscriptions = workerProperties.getSubscriptions();
    subscriptions.forEach((k,v) -> registerListenerEndpoint(aRegistrar, k, Integer.valueOf((String)v), worker, "handle"));
    registerListenerEndpoint(aRegistrar, Exchanges.CONTROL+"/"+Exchanges.CONTROL, 1, worker, "handle");
  }
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的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.JmsListenerEndpointRegistrar; //导入依赖的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.JmsListenerEndpointRegistrar; //导入依赖的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.JmsListenerEndpointRegistrar; //导入依赖的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.JmsListenerEndpointRegistrar; //导入依赖的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.JmsListenerEndpointRegistrar; //导入依赖的package包/类
/**
 * resets the registrar; this method is a hack and could break upon upgrades to Spring since it uses reflection
 * to access private members. TODO: come up with better approach
 */
private void resetRegistrar() {
    Field registrarField = ReflectionUtils.findField(JmsListenerAnnotationBeanPostProcessor.class, "registrar");
    ReflectionUtils.makeAccessible(registrarField);
    JmsListenerEndpointRegistrar registrar = (JmsListenerEndpointRegistrar) ReflectionUtils.getField(registrarField, this);
    Field descriptorField = ReflectionUtils.findField(JmsListenerEndpointRegistrar.class, "endpointDescriptors");
    ReflectionUtils.makeAccessible(descriptorField);
    List descriptorList = (List) ReflectionUtils.getField(descriptorField, registrar);
    descriptorList.clear();
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
void setRegistrar(JmsListenerEndpointRegistrar registrar) {
  this.registrar = registrar;
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
  registry.setRegistrar(registrar);
  registrar.setEndpointRegistry(registry);
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
    registrar.setEndpointRegistry(endpointRegistry);
    registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory);
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
@Override
public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
  initializeFactory(methodFactory);

  /*
   As a single container factory setup can be fairly common, the containerFactory attribute can 
   be omitted if a default one has either been set or discovered. 
   By default, we look up for a bean named jmsListenerContainerFactory.
   */
  if (configuration == null) {
    logger.warn("Configuration file ('configuration.properties') is missing.");
    return;
  }

  // Check if any endpoint has been defined
  String endpointsStr = StringUtils.trim(configuration.getProperty(CONFIGURATION_KEY_JMS_ENDPOINTS));
  if (StringUtils.isEmpty(endpointsStr)) {
    logger.warn("No endpoint has been defined.");
    return;
  }

  // Parse endpoints ids
  String[] endpoints = stringAsArray(endpointsStr);
  
  String defaultLogin = configuration.getProperty(CONFIGURATION_KEY_JMS_LOGIN);
  String defaultPassword = configuration.getProperty(CONFIGURATION_KEY_JMS_PASSWORD);

  // Configure each endpoint
  for (String endpointId : endpoints) {
    JmsListenerEndpoint endpoint;
    try {
      endpoint = configureEndpoint(endpointId, defaultLogin, defaultPassword);
    } catch (Exception ex) {
      StringBuilder errorMessage = new StringBuilder();
      errorMessage.append("Failed to configure endpoint '").append(endpointId).append("'.");
      if (ignoreErroneousEndpoint) {
        errorMessage.append(" Go to the next one.");
        logger.warn(errorMessage.toString(), ex);
        continue;
      }
      else {
        throw new JMSModuleException(errorMessage.toString(), ex);
      }
    }
    // The default registrar is already populated with the container factory
    //  bean named "jmsListenerContainerFactory" by default
    //registrar.setContainerFactoryBeanName();
    registrar.registerEndpoint(endpoint);
  }
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
@Test
public void testConfigureJmsListeners() {
  JmsListenerEndpointRegistrar registrar = mock(JmsListenerEndpointRegistrar.class);
  instance.setIgnoreErroneousEndpoint(false);
  instance.configureJmsListeners(registrar);
}
 

import org.springframework.jms.config.JmsListenerEndpointRegistrar; //导入依赖的package包/类
/**
 * Callback allowing a {@link org.springframework.jms.config.JmsListenerEndpointRegistry
 * JmsListenerEndpointRegistry} and specific {@link org.springframework.jms.config.JmsListenerEndpoint
 * JmsListenerEndpoint} instances to be registered against the given
 * {@link JmsListenerEndpointRegistrar}. The default
 * {@link org.springframework.jms.config.JmsListenerContainerFactory JmsListenerContainerFactory}
 * can also be customized.
 * @param registrar the registrar to be configured
 */
void configureJmsListeners(JmsListenerEndpointRegistrar registrar);