当spring集成配置包含优先级通道时，如何重新排队消息

时间：2015-09-16 18:14:15

标签： spring-integration

我有一个使用优先级通道的Spring Integration配置。当从该通道读取项目时，在该时间点检查本地资源，如果资源不可用于处理该项目，我想重新排队该消息，以便另一台机器获取它。最初，我错误地认为会出现重新排队的异常，但是as was answered in my other question这不会起作用，因为优先级通道在另一个线程中而不是监听器容器中执行。

我考虑过在入站通道适配器之后放置一个过滤器，并在当时资源不可用时抛出异常，但在那个时刻，由于当时的资源可用性，无法准确评估资源匹配根据优先级选择消息时可用的内容。

我的下一个想法是在优先级通道之后和服务激活器之前放置一个过滤器，并将当前资源无法处理的消息定向到discard-channel，该discard-channel定义为将消息发送回的discbound-channel。原始队列。这种方法有缺陷吗？

编辑20150917：

根据Gary的建议，我已经转移到RabbitMQ 3.5.x以获取内置的优先级队列。我现在有一个跟踪尝试次数的问题，因为看起来我的原始消息被放回队列，而不是我修改过的消息。我更新了代码块以反映当前的设置。

编辑20150922：

我正在更新此帖子以反映我创建的概念代码库的最终证明。我无论如何都不是Spring-Integration专家，所以请记住这一点，以及这个测试代码不是生产就绪的事实。我最初的意图是如果抛出特定异常，则重新提交消息并重试一定次数。这可以使用StatefulRetryOperationsInterceptor来完成。但是为了进一步试验，我希望能够在失败时设置/增加标头，然后在我的流程中有一些可以对该值做出反应的东西。这是通过使用覆盖RepublishMessageRecoverer的{​​{1}}的扩展来完成的。然后，此对象用于配置additionalHeaders()。

另一个小问题：当我抛出信号异常时，我想减少一些默认的Spring Integration日志记录，所以我需要确保命名我的错误频道＆＃34; errorChannel＆＃34;为了取代Spring Integration默认值。我还需要创建一个自定义RetryOperationsInterceptor，用于分配ErrorHandler默认值，将所有内容记录到ERROR级别。

这是我目前的设置：

Spring Integration 4.2.0.RELEASE

Spring AMQP 1.5.0.RELEASE

RabbitMQ 3.5.x

配置 

ListenerContainer

SpringIntegrationHelper 

@Autowired
public void setSpringIntegrationConfigHelper (SpringIntegrationHelper springIntegrationConfigHelper) {
    this.springIntegrationConfigHelper = springIntegrationConfigHelper;   
}

@Bean
public String priorityPOCQueueName() {
    return "poc.priority";
}

@Bean
public Queue priorityPOCQueue(RabbitAdmin rabbitAdmin) {
    boolean durable = true;
    boolean exclusive = false;
    boolean autoDelete = false;

    //Adding the x-max-priority argument is what signals RabbitMQ that this is a priority queue. Must be Rabbit 3.5.x
    Map<String,Object> arguments = new HashMap<String, Object>();
    arguments.put("x-max-priority", 5);

    Queue queue = new Queue(priorityPOCQueueName(),
            durable,
            exclusive,
            autoDelete,
            arguments);

    rabbitAdmin.declareQueue(queue);
    return queue;
}

@Bean
public Binding priorityPOCQueueBinding(RabbitAdmin rabbitAdmin) {
    Binding binding = new Binding(priorityPOCQueueName(),
                                  DestinationType.QUEUE,
                                  "amq.direct",
                                  priorityPOCQueue(rabbitAdmin).getName(),
                                  null);
    rabbitAdmin.declareBinding(binding);
    return binding;
}

@Bean
public AmqpTemplate priorityPOCMessageTemplate(ConnectionFactory amqpConnectionFactory,
                                                @Qualifier("priorityPOCQueueName") String queueName,
                                                @Qualifier("jsonMessageConverter") MessageConverter messageConverter) {
    RabbitTemplate template = new RabbitTemplate(amqpConnectionFactory);
    template.setChannelTransacted(false);
    template.setExchange("amq.direct");
    template.setQueue(queueName);
    template.setRoutingKey(queueName);
    template.setMessageConverter(messageConverter);
    return template;
}


@Autowired
@Qualifier("priorityPOCQueue")
public void setPriorityPOCQueue(Queue priorityPOCQueue) {
    this.priorityPOCQueue = priorityPOCQueue;
}

@Bean
public MessageRecoverer miTestMessageRecoverer(final AmqpTemplate priorityPOCMessageTemplate) {
    return new MessageRecoverer() {

        @Override
        public void recover(org.springframework.amqp.core.Message msg, Throwable t) {
            StringBuilder sb = new StringBuilder();
            sb.append("Firing Test Recoverer: ").append(t.getClass().getName()).append(" Message Count: ")
            .append(msg.getMessageProperties().getMessageCount())
            .append(" ID: ").append(msg.getMessageProperties().getMessageId())
            .append(" DeliveryTag: ").append(msg.getMessageProperties().getDeliveryTag())
            .append(" Redilivered: ").append(msg.getMessageProperties().isRedelivered());
            logger.debug(sb.toString());

            PriorityMessage m = new PriorityMessage(5);
            m.setId(randomGenerator.nextLong(10L, 1000000L));
            priorityPOCMessageTemplate.convertAndSend(m , new SimulateErrorHeaderPostProcessor(Boolean.FALSE, m.getPriority()));
        }

    };
}


@Bean
public RepublishMessageRecoverer miRepublishRecoverer(final AmqpTemplate priorityPOCMessageTemplate) {
    class MiRecoverer extends RepublishMessageRecoverer {

        public MiRecoverer(AmqpTemplate errorTemplate) {
            super(errorTemplate);
            this.setErrorRoutingKeyPrefix("");
        }

        @Override
        protected Map<? extends String, ? extends Object> additionalHeaders(
                org.springframework.amqp.core.Message message, Throwable cause) {
            Map<String, Object> map = new HashMap<>();
           if (message.getMessageProperties().getHeaders().containsKey("jmattempts") == false) {
                 map.put("jmattempts", 0);
            } else {
                Integer count = Integer.valueOf(message.getMessageProperties().getHeaders().get("jmattempts").toString());
                map.put("jmattempts", ++count);
            }
           return map;
        }
    } ;
    return new MiRecoverer(priorityPOCMessageTemplate);
}

@Bean
public StatefulRetryOperationsInterceptor inadequateResourceInterceptor(@Qualifier("priorityPOCMessageTemplate") AmqpTemplate priorityPOCMessageTemplate
        , @Qualifier("priorityMessageKeyGenerator") PriorityMessageKeyGenerator priorityMessageKeyGenerator
        ,  @Qualifier("miTestMessageRecoverer") MessageRecoverer messageRecoverer
        , @Qualifier("miRepublishRecoverer") RepublishMessageRecoverer miRepublishRecoverer) {
    StatefulRetryInterceptorBuilder b = RetryInterceptorBuilder.stateful();
    return b.maxAttempts(2)
            .backOffOptions(2000L, 1.0D, 4000L)
            .messageKeyGenerator(priorityMessageKeyGenerator)
            .recoverer(miRepublishRecoverer)
           .build();
 }


@Bean(name="exec.priorityPOC")
TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor e = new ThreadPoolTaskExecutor();
    e.setCorePoolSize(1);
    e.setQueueCapacity(1);
    return e;
}

/*    @Bean(name="poc.priorityChannel")
public MessageChannel pocPriorityChannel() {
    PriorityChannel c = new PriorityChannel(new PriorityComparator());
    c.setComponentName("poc.priorityChannel");
    c.setBeanName("poc.priorityChannel");
    return c;
}
*/
@Bean(name="poc.inputChannel")
public MessageChannel pocPriorityChannel() {
    DirectChannel c = new DirectChannel();
    c.setComponentName("poc.inputChannel");
    c.setBeanName("poc.inputChannel");
    return c;
}

@Bean(name="poc.inboundChannelAdapter") //make this a unique name
public AmqpInboundChannelAdapter amqpInboundChannelAdapter(@Qualifier("exec.priorityPOC") TaskExecutor taskExecutor
        , @Qualifier("errorChannel") MessageChannel pocErrorChannel
        , @Qualifier("inadequateResourceInterceptor") StatefulRetryOperationsInterceptor inadequateResourceInterceptor) {

    org.aopalliance.aop.Advice[] adviceChain = new org.aopalliance.aop.Advice[]{inadequateResourceInterceptor};
    int concurrentConsumers = 1;
    AmqpInboundChannelAdapter a =  springIntegrationConfigHelper.createInboundChannelAdapter(taskExecutor
            , pocPriorityChannel(), new Queue[]{priorityPOCQueue},  concurrentConsumers, adviceChain
            , new PocErrorHandler());
    a.setErrorChannel(pocErrorChannel);
    return a;

}

@Transformer(inputChannel = "poc.inputChannel", outputChannel = "poc.procesPoc")
public Message<PriorityMessage> incrementAttempts(Message<PriorityMessage> msg) {
    //I stopped using this in the POC.
    return msg;
}

@ServiceActivator(inputChannel="poc.procesPoc")
public void procesPoc(@Header(SimulateErrorHeaderPostProcessor.ERROR_SIMULATE_HEADER_KEY) Boolean simulateError
        ,  @Headers Map<String, Object> headerMap
        , PriorityMessage priorityMessage) throws InterruptedException {
    if (isFirstMessageReceived == false) {
        //Thread.sleep(15000); //Cause a bit of a backup so we can see prioritizing in action.
        isFirstMessageReceived = true;
    }
    Integer retryAttempts = 0;
    if (headerMap.containsKey("jmattempts")) {
        retryAttempts = Integer.valueOf(headerMap.get("jmattempts").toString());
    }
    logger.debug("Received message with priority: " + priorityMessage.getPriority() + ", simulateError: " + simulateError +  ", Current attempts count is "
        + retryAttempts);
    if (simulateError && retryAttempts < PriorityMessage.MAX_MESSAGE_RETRY_COUNT) {
        logger.debug(" Simulating an error and re-queue'ng. Current attempt count is " + retryAttempts);
        throw new AnalyzerNonAdequateResourceException();
    } else if (simulateError && retryAttempts > PriorityMessage.MAX_MESSAGE_RETRY_COUNT) {
        logger.debug(" Max attempt count exceeded");
    }
}

/**************************************************************************************************
 * 
 *                        Error Channel
 *
 **************************************************************************************************/
//Note that we want to override default Spring error channel, so the name of the bean must be errorChannel
@Bean(name="errorChannel")
public MessageChannel pocErrorChannel() {
    DirectChannel c = new DirectChannel();
    c.setComponentName("errorChannel");
    c.setBeanName("errorChannel");
    return c;
}

@ServiceActivator(inputChannel="errorChannel")
public void pocHandleError(Message<MessagingException> message) throws Throwable {
     MessagingException me = message.getPayload();
    logger.error("pocHandleError: error encountered: " +  me.getCause().getClass().getName());
    SortedMap<String, Object> sorted= new TreeMap<>();
    sorted.putAll(me.getFailedMessage().getHeaders());
    if (me.getCause() instanceof AnalyzerNonAdequateResourceException) {
        logger.debug("Headers: " + sorted.toString());
        //Let this message get requeued
        throw me.getCause();

    }


    Message<?> failedMsg = me.getFailedMessage();
    Object o = failedMsg.getPayload();
    StringBuilder sb = new StringBuilder();
    if (o != null) {
        sb.append("AnalyzerErrorHandler: Failed Message Type: ")
           .append(o.getClass().getCanonicalName()).append(". toString: ").append(o.toString());
        logger.error(sb.toString());
    }

    //The first level sometimes brings back either MessagingHandlingException or 
    //MessagingTransformationException which may contain a subcause 
    Exception e = (Exception)me.getCause();
    int i = 0;
    sb.delete(0, sb.length());
    sb.append("AnalyzerErrorHandler nested messages: ");
    while (e != null && i++ < 10) {
        sb.append(System.lineSeparator()).append("  ")
        .append(e.getClass().getCanonicalName()).append(": ")
        .append(e.getMessage());
    }
    if (i > 0) {
        logger.error(sb.toString());
    }

    //Don't want a message to recycle
    throw new AmqpRejectAndDontRequeueException(e);
}



/**
 * This gets set on the ListenerContainer.  The default handler on the listener
 * container logs everything with full stack trace.  We don't want to do that
 * for our known resource exception
 */
public static class PocErrorHandler implements ErrorHandler {

    @Override
    public void handleError(Throwable t) {
        Throwable cause = t.getCause();
        if (cause != null) {
            while (cause.getCause() != null) {
                cause = cause.getCause();
            }
        } else {
            cause = t;
        }
        if (cause instanceof AnalyzerNonAdequateResourceException) {
            logger.info(AnalyzerNonAdequateResourceException.class.getName() + ": not enough resources to process the item.");
            return;
        }
        else {
            logger.error("POC Listener Exception",  t);
        }
    }
}

1 个答案:

答案 0 :(得分：1)

目前尚不清楚为什么要在此上下文中使用PriorityChannel;为什么不使用priority queue in RabbitMQ？这样，您就可以在容器线程上运行流程。

将队列发送到队列的后面会有效，但是存在丢失消息的风险。

相关问题
最新问题