Java SimpleMessageListenerContainer类代码示例

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
private int extractMaxNumberOfMessagesFromListenerContainer(
        @NonNull SimpleMessageListenerContainer simpleMessageListenerContainer) {
    try {
        Field f = simpleMessageListenerContainer.getClass().getSuperclass().getDeclaredField(
                "maxNumberOfMessages");
        f.setAccessible(true);
        Integer maxNumberOfMessages = (Integer) f.get(simpleMessageListenerContainer);
        if (maxNumberOfMessages != null) {
            return maxNumberOfMessages;
        } else {
            // org.springframework.cloud.aws.messaging.listener.AbstractMessageListenerContainer.DEFAULT_MAX_NUMBER_OF_MESSAGES
            return 10;
        }
    } catch (NoSuchFieldException | IllegalAccessException e) {
        throw new IllegalStateException(
                "Cannot get BatchSize of SimpleMessageListenerContainer", e);
    }
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void configuration_withMinimalBeans_shouldStartSqsListenerContainer() throws Exception {
    // Arrange & Act
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MinimalConfiguration.class);
    SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);

    // Assert
    assertTrue(container.isRunning());
    QueueMessageHandler queueMessageHandler = applicationContext.getBean(QueueMessageHandler.class);
    assertTrue(QueueMessageHandler.class.isInstance(queueMessageHandler));

    HandlerMethodReturnValueHandler sendToReturnValueHandler = queueMessageHandler.getCustomReturnValueHandlers().get(0);
    QueueMessagingTemplate messagingTemplate = (QueueMessagingTemplate) ReflectionTestUtils.getField(sendToReturnValueHandler, "messageTemplate");
    AmazonSQSBufferedAsyncClient amazonBufferedSqsClient = (AmazonSQSBufferedAsyncClient) ReflectionTestUtils.getField(messagingTemplate, "amazonSqs");
    AmazonSQSAsyncClient amazonSqsClient = (AmazonSQSAsyncClient) ReflectionTestUtils.getField(amazonBufferedSqsClient, "realSQS");
    assertNotNull(ReflectionTestUtils.getField(amazonSqsClient, "awsCredentialsProvider"));
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void configuration_withCustomConfigurationFactory_shouldBeUsedToCreateTheContainer() throws Exception {
    // Arrange & Act
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ConfigurationWithCustomContainerFactory.class);
    SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);

    // Assert
    assertEquals(ConfigurationWithCustomContainerFactory.AMAZON_SQS, ReflectionTestUtils.getField(container, "amazonSqs"));
    assertEquals(ConfigurationWithCustomContainerFactory.AUTO_STARTUP, container.isAutoStartup());
    assertEquals(ConfigurationWithCustomContainerFactory.MAX_NUMBER_OF_MESSAGES, ReflectionTestUtils.getField(container, "maxNumberOfMessages"));
    assertEquals(ConfigurationWithCustomContainerFactory.MESSAGE_HANDLER, ReflectionTestUtils.getField(container, "messageHandler"));
    assertEquals(ConfigurationWithCustomContainerFactory.RESOURCE_ID_RESOLVER, ReflectionTestUtils.getField(container, "resourceIdResolver"));
    assertEquals(ConfigurationWithCustomContainerFactory.TASK_EXECUTOR, ReflectionTestUtils.getField(container, "taskExecutor"));
    assertEquals(ConfigurationWithCustomContainerFactory.VISIBILITY_TIMEOUT, ReflectionTestUtils.getField(container, "visibilityTimeout"));
    assertEquals(ConfigurationWithCustomContainerFactory.WAIT_TIME_OUT, ReflectionTestUtils.getField(container, "waitTimeOut"));
    assertTrue(ConfigurationWithCustomContainerFactory.DESTINATION_RESOLVER == ReflectionTestUtils.getField(container, "destinationResolver"));
    assertEquals(ConfigurationWithCustomContainerFactory.BACK_OFF_TIME, container.getBackOffTime());
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_customSqsClient_shouldProduceContainerWithCustomSqsClientUsed() throws Exception {
    //Arrange
    SimpleBeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);

    //Act
    reader.loadBeanDefinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-amazon-sqs.xml", getClass()));

    //Assert
    BeanDefinition sqsAsync = registry.getBeanDefinition("myClient");
    assertNotNull(sqsAsync);

    BeanDefinition abstractContainerDefinition = registry.getBeanDefinition(SimpleMessageListenerContainer.class.getName() + "#0");
    assertNotNull(abstractContainerDefinition);

    assertEquals(3, abstractContainerDefinition.getPropertyValues().size());
    assertEquals("myClient",
            ((RuntimeBeanReference) abstractContainerDefinition.getPropertyValues().getPropertyValue("amazonSqs").getValue()).getBeanName());
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_customTaskExecutor_shouldCreateContainerAndClientWithCustomTaskExecutor() throws Exception {
    //Arrange
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

    //Act
    reader.loadBeanDefinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-task-executor.xml", getClass()));

    //Assert
    BeanDefinition executor = beanFactory.getBeanDefinition("executor");
    assertNotNull(executor);

    BeanDefinition abstractContainerDefinition = beanFactory.getBeanDefinition(SimpleMessageListenerContainer.class.getName() + "#0");
    assertNotNull(abstractContainerDefinition);

    assertEquals(4, abstractContainerDefinition.getPropertyValues().size());
    assertEquals("executor",
            ((RuntimeBeanReference) abstractContainerDefinition.getPropertyValues().getPropertyValue("taskExecutor").getValue()).getBeanName());

    AmazonSQSBufferedAsyncClient bufferedAsyncClient = beanFactory.getBean(AmazonSQSBufferedAsyncClient.class);
    assertNotNull(bufferedAsyncClient);
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_withCustomProperties_customPropertiesConfiguredOnContainer() throws Exception {
    //Arrange
    SimpleBeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);

    //Act
    reader.loadBeanDefinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-properties.xml", getClass()));

    //Assert
    BeanDefinition abstractContainerDefinition = registry.getBeanDefinition(SimpleMessageListenerContainer.class.getName() + "#0");
    assertNotNull(abstractContainerDefinition);

    assertEquals("false", abstractContainerDefinition.getPropertyValues().getPropertyValue("autoStartup").getValue());
    assertEquals("9", abstractContainerDefinition.getPropertyValues().getPropertyValue("maxNumberOfMessages").getValue());
    assertEquals("6", abstractContainerDefinition.getPropertyValues().getPropertyValue("visibilityTimeout").getValue());
    assertEquals("3", abstractContainerDefinition.getPropertyValues().getPropertyValue("waitTimeOut").getValue());
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Inject
public LongRunningMessageHandlerFactory(
        @NonNull MessageHandlingRunnableFactory messageHandlingRunnableFactory,
        @NonNull VisibilityTimeoutExtenderFactory timeoutExtenderFactory,
        @NonNull QueueFactory queueFactory,
        @NonNull SimpleMessageListenerContainer simpleMessageListenerContainer) {
    this.messageHandlingRunnableFactory = messageHandlingRunnableFactory;
    this.timeoutExtenderFactory = timeoutExtenderFactory;
    this.queueFactory = queueFactory;

    this.executorService = Executors.newScheduledThreadPool(1);

    this.maxNumberOfMessagesPerBatch = extractMaxNumberOfMessagesFromListenerContainer(
            simpleMessageListenerContainer);
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer();
    uut = new LongRunningMessageHandlerFactory(messageHandlingRunnableFactory,
            timeoutExtenderFactory, queueFactory, simpleMessageListenerContainer);
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void testConstructor_extractsTheCorrectMessageBatchSize() {
    // given
    SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer();
    simpleMessageListenerContainer.setMaxNumberOfMessages(2);

    // when
    uut = new LongRunningMessageHandlerFactory(messageHandlingRunnableFactory,
            timeoutExtenderFactory, queueFactory, simpleMessageListenerContainer);

    // then
    assertEquals(2, uut.maxNumberOfMessagesPerBatch);
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Bean
public SimpleMessageListenerContainer sqsMessageListenerContainer() {
  SimpleMessageListenerContainerFactory factory = sqsMessageListenerContainerFactory();
  SimpleMessageListenerContainer container = factory.createSimpleMessageListenerContainer();
  container.setMessageHandler(factory.getQueueMessageHandler());
  return container;
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
public SimpleMessageListenerContainer createSimpleMessageListenerContainer() {
    Assert.notNull(this.amazonSqs, "amazonSqs must not be null");

    SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer();
    simpleMessageListenerContainer.setAmazonSqs(this.amazonSqs);
    simpleMessageListenerContainer.setAutoStartup(this.autoStartup);

    if (this.taskExecutor != null) {
        simpleMessageListenerContainer.setTaskExecutor(this.taskExecutor);
    }
    if (this.maxNumberOfMessages != null) {
        simpleMessageListenerContainer.setMaxNumberOfMessages(this.maxNumberOfMessages);
    }
    if (this.visibilityTimeout != null) {
        simpleMessageListenerContainer.setVisibilityTimeout(this.visibilityTimeout);
    }
    if (this.waitTimeOut != null) {
        simpleMessageListenerContainer.setWaitTimeOut(this.waitTimeOut);
    }
    if (this.resourceIdResolver != null) {
        simpleMessageListenerContainer.setResourceIdResolver(this.resourceIdResolver);
    }
    if (this.destinationResolver != null) {
        simpleMessageListenerContainer.setDestinationResolver(this.destinationResolver);
    }
    if (this.backOffTime != null) {
        simpleMessageListenerContainer.setBackOffTime(this.backOffTime);
    }

    return simpleMessageListenerContainer;
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void queueMessageHandlerBeanMustBeSetOnContainer() throws Exception {
    // Arrange & Act
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MinimalConfiguration.class);
    SimpleMessageListenerContainer simpleMessageListenerContainer = applicationContext.getBean(SimpleMessageListenerContainer.class);
    QueueMessageHandler queueMessageHandler = applicationContext.getBean(QueueMessageHandler.class);

    // Assert
    assertEquals(queueMessageHandler, ReflectionTestUtils.getField(simpleMessageListenerContainer, "messageHandler"));
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_minimalConfiguration_shouldProduceContainerWithDefaultAmazonSqsBean() throws Exception {
    //Act
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(getClass().getSimpleName() + "-minimal.xml", getClass());

    //Assert
    AmazonSQSAsync amazonSqsClient = applicationContext.getBean(AmazonSQSAsync.class);
    assertNotNull(amazonSqsClient);

    SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);
    assertNotNull(container);

    assertSame(amazonSqsClient, ReflectionTestUtils.getField(container, "amazonSqs"));
    assertSame(applicationContext.getBean(StackResourceRegistryDetectingResourceIdResolver.class), ReflectionTestUtils.getField(container, "resourceIdResolver"));

    QueueMessageHandler queueMessageHandler = (QueueMessageHandler) ReflectionTestUtils.getField(container, "messageHandler");
    HandlerMethodReturnValueHandler sendToReturnValueHandler = queueMessageHandler.getReturnValueHandlers().get(0);
    assertTrue(SendToHandlerMethodReturnValueHandler.class.isInstance(sendToReturnValueHandler));
    QueueMessagingTemplate queueMessagingTemplate = (QueueMessagingTemplate) ReflectionTestUtils.getField(sendToReturnValueHandler, "messageTemplate");

    assertTrue(CompositeMessageConverter.class.isInstance(queueMessagingTemplate.getMessageConverter()));

    @SuppressWarnings("unchecked")
    List<MessageConverter> messageConverters = (List<MessageConverter>) ReflectionTestUtils.getField(queueMessagingTemplate.getMessageConverter(), "converters");
    assertEquals(2, messageConverters.size());
    assertTrue(StringMessageConverter.class.isInstance(messageConverters.get(0)));
    assertTrue(MappingJackson2MessageConverter.class.isInstance(messageConverters.get(1)));

    StringMessageConverter stringMessageConverter = (StringMessageConverter) messageConverters.get(0);
    assertSame(String.class, stringMessageConverter.getSerializedPayloadClass());
    assertEquals(false, ReflectionTestUtils.getField(stringMessageConverter, "strictContentTypeMatch"));

    MappingJackson2MessageConverter jackson2MessageConverter = (MappingJackson2MessageConverter) messageConverters.get(1);
    assertSame(String.class, jackson2MessageConverter.getSerializedPayloadClass());
    assertEquals(false, ReflectionTestUtils.getField(jackson2MessageConverter, "strictContentTypeMatch"));
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_customDestinationResolver_isUsedOnTheContainer() throws Exception {
    // Arrange & Act
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(getClass().getSimpleName() + "-custom-destination-resolver.xml", getClass());

    // Assert
    SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);
    DestinationResolver<?> customDestinationResolver = applicationContext.getBean(DestinationResolver.class);
    assertTrue(customDestinationResolver == ReflectionTestUtils.getField(container, "destinationResolver"));
}
 

import org.springframework.cloud.aws.messaging.listener.SimpleMessageListenerContainer; //导入依赖的package包/类
@Test
public void parseInternal_definedBackOffTime_shouldBeSetOnContainer() throws Exception {
    // Arrange & Act
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(getClass().getSimpleName() + "-back-off-time.xml", getClass());

    // Assert
    SimpleMessageListenerContainer container = applicationContext.getBean(SimpleMessageListenerContainer.class);
    assertEquals(5000L, container.getBackOffTime());
}