Examples with DestinationResolver org.springframework.jms.support.destination.DestinationResolver used on opensource projects

Example 6 with DestinationResolver

use of org.springframework.jms.support.destination.DestinationResolver in project camel by apache.

the class QueueReplyManager method createListenerContainer.

protected AbstractMessageListenerContainer createListenerContainer() throws Exception {
    DefaultMessageListenerContainer answer;
    ReplyToType type = endpoint.getConfiguration().getReplyToType();
    if (type == null) {
        // use shared by default for reply queues
        type = ReplyToType.Shared;
    }
    if (ReplyToType.Shared == type) {
        // shared reply to queues support either a fixed or dynamic JMS message selector
        String replyToSelectorName = endpoint.getReplyToDestinationSelectorName();
        if (replyToSelectorName != null) {
            // create a random selector value we will use for the reply queue
            replyToSelectorValue = "ID:" + new BigInteger(24 * 8, new Random()).toString(16);
            String fixedMessageSelector = replyToSelectorName + "='" + replyToSelectorValue + "'";
            answer = new SharedQueueMessageListenerContainer(endpoint, fixedMessageSelector);
            // must use cache level consumer for fixed message selector
            answer.setCacheLevel(DefaultMessageListenerContainer.CACHE_CONSUMER);
            log.debug("Using shared queue: " + endpoint.getReplyTo() + " with fixed message selector [" + fixedMessageSelector + "] as reply listener: " + answer);
        } else {
            // use a dynamic message selector which will select the message we want to receive as reply
            dynamicMessageSelector = new MessageSelectorCreator(correlation);
            answer = new SharedQueueMessageListenerContainer(endpoint, dynamicMessageSelector);
            // must use cache level session for dynamic message selector,
            // as otherwise the dynamic message selector will not be updated on-the-fly
            answer.setCacheLevel(DefaultMessageListenerContainer.CACHE_SESSION);
            log.debug("Using shared queue: " + endpoint.getReplyTo() + " with dynamic message selector as reply listener: " + answer);
        }
        // shared is not as fast as temporary or exclusive, so log this so the end user may be aware of this
        log.warn("{} is using a shared reply queue, which is not as fast as alternatives." + " See more detail at the section 'Request-reply over JMS' at http://camel.apache.org/jms", endpoint);
    } else if (ReplyToType.Exclusive == type) {
        answer = new ExclusiveQueueMessageListenerContainer(endpoint);
        // must use cache level consumer for exclusive as there is no message selector
        answer.setCacheLevel(DefaultMessageListenerContainer.CACHE_CONSUMER);
        log.debug("Using exclusive queue:" + endpoint.getReplyTo() + " as reply listener: " + answer);
    } else {
        throw new IllegalArgumentException("ReplyToType " + type + " is not supported for reply queues");
    }
    String replyToCacheLevelName = endpoint.getConfiguration().getReplyToCacheLevelName();
    if (replyToCacheLevelName != null) {
        answer.setCacheLevelName(replyToCacheLevelName);
        log.debug("Setting the replyCacheLevel to be " + replyToCacheLevelName);
    }
    DestinationResolver resolver = endpoint.getDestinationResolver();
    if (resolver == null) {
        resolver = answer.getDestinationResolver();
    }
    answer.setDestinationResolver(new DestinationResolverDelegate(resolver));
    answer.setDestinationName(endpoint.getReplyTo());
    answer.setAutoStartup(true);
    answer.setIdleConsumerLimit(endpoint.getIdleConsumerLimit());
    answer.setIdleTaskExecutionLimit(endpoint.getIdleTaskExecutionLimit());
    if (endpoint.getMaxMessagesPerTask() >= 0) {
        answer.setMaxMessagesPerTask(endpoint.getMaxMessagesPerTask());
    }
    answer.setMessageListener(this);
    answer.setPubSubDomain(false);
    answer.setSubscriptionDurable(false);
    answer.setConcurrentConsumers(endpoint.getReplyToConcurrentConsumers());
    if (endpoint.getReplyToMaxConcurrentConsumers() > 0) {
        answer.setMaxConcurrentConsumers(endpoint.getReplyToMaxConcurrentConsumers());
    }
    answer.setConnectionFactory(endpoint.getConnectionFactory());
    String clientId = endpoint.getClientId();
    if (clientId != null) {
        clientId += ".CamelReplyManager";
        answer.setClientId(clientId);
    }
    // we cannot do request-reply over JMS with transaction
    answer.setSessionTransacted(false);
    // other optional properties
    if (endpoint.getExceptionListener() != null) {
        answer.setExceptionListener(endpoint.getExceptionListener());
    }
    if (endpoint.getErrorHandler() != null) {
        answer.setErrorHandler(endpoint.getErrorHandler());
    } else {
        answer.setErrorHandler(new DefaultSpringErrorHandler(endpoint.getCamelContext(), QueueReplyManager.class, endpoint.getErrorHandlerLoggingLevel(), endpoint.isErrorHandlerLogStackTrace()));
    }
    if (endpoint.getReceiveTimeout() >= 0) {
        answer.setReceiveTimeout(endpoint.getReceiveTimeout());
    }
    if (endpoint.getRecoveryInterval() >= 0) {
        answer.setRecoveryInterval(endpoint.getRecoveryInterval());
    }
    // set task executor
    if (endpoint.getTaskExecutor() != null) {
        if (log.isDebugEnabled()) {
            log.debug("Using custom TaskExecutor: {} on listener container: {}", endpoint.getTaskExecutor(), answer);
        }
        answer.setTaskExecutor(endpoint.getTaskExecutor());
    }
    // setup a bean name which is used by Spring JMS as the thread name
    String name = "QueueReplyManager[" + answer.getDestinationName() + "]";
    answer.setBeanName(name);
    if (answer.getConcurrentConsumers() > 1) {
        if (ReplyToType.Shared == type) {
            // warn if using concurrent consumer with shared reply queue as that may not work properly
            log.warn("Using {}-{} concurrent consumer on {} with shared queue {} may not work properly with all message brokers.", new Object[] { answer.getConcurrentConsumers(), answer.getMaxConcurrentConsumers(), name, endpoint.getReplyTo() });
        } else {
            // log that we are using concurrent consumers
            log.info("Using {}-{} concurrent consumers on {}", new Object[] { answer.getConcurrentConsumers(), answer.getMaxConcurrentConsumers(), name });
        }
    }
    return answer;
}

Example 7 with DestinationResolver

use of org.springframework.jms.support.destination.DestinationResolver in project spring-framework by spring-projects.

the class DefaultJmsActivationSpecFactoryTests method webSphereResourceAdapterSetup.

@Test
public void webSphereResourceAdapterSetup() throws Exception {
    Destination destination = new StubQueue();
    DestinationResolver destinationResolver = mock(DestinationResolver.class);
    given(destinationResolver.resolveDestinationName(null, "destinationname", false)).willReturn(destination);
    DefaultJmsActivationSpecFactory activationSpecFactory = new DefaultJmsActivationSpecFactory();
    activationSpecFactory.setDestinationResolver(destinationResolver);
    StubWebSphereActivationSpecImpl spec = (StubWebSphereActivationSpecImpl) activationSpecFactory.createActivationSpec(new StubWebSphereResourceAdapterImpl(), activationSpecConfig);
    assertEquals(destination, spec.getDestination());
    assertEquals(5, spec.getMaxConcurrency());
    assertEquals(3, spec.getMaxBatchSize());
}

Example 8 with DestinationResolver

use of org.springframework.jms.support.destination.DestinationResolver in project spring-framework by spring-projects.

the class MethodJmsListenerEndpoint method createMessageListener.

@Override
protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
    Assert.state(this.messageHandlerMethodFactory != null, "Could not create message listener - MessageHandlerMethodFactory not set");
    MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
    InvocableHandlerMethod invocableHandlerMethod = this.messageHandlerMethodFactory.createInvocableHandlerMethod(getBean(), getMethod());
    messageListener.setHandlerMethod(invocableHandlerMethod);
    String responseDestination = getDefaultResponseDestination();
    if (StringUtils.hasText(responseDestination)) {
        if (container.isReplyPubSubDomain()) {
            messageListener.setDefaultResponseTopicName(responseDestination);
        } else {
            messageListener.setDefaultResponseQueueName(responseDestination);
        }
    }
    MessageConverter messageConverter = container.getMessageConverter();
    if (messageConverter != null) {
        messageListener.setMessageConverter(messageConverter);
    }
    DestinationResolver destinationResolver = container.getDestinationResolver();
    if (destinationResolver != null) {
        messageListener.setDestinationResolver(destinationResolver);
    }
    return messageListener;
}