保證消息異步傳遞

Question

我寫了一段代碼來保證消息的傳遞和處理。 但它在一個線程中工作。 如何重構代碼以使其在並行線程或異步中工作？ 在這種情況下，即使應用程序崩潰，也必須保證能夠傳遞消息。 它們將在應用程序新啟動后或在此應用程序的其他運行實例的幫助下交付。

制作人：

@Async("threadPoolTaskExecutor")
@EventListener(condition = "#event.queue")
public void start(GenericSpringEvent<RenderQueueObject> event) {
    RenderQueueObject renderQueueObject = event.getWhat();
    send(RENDER_NAME, renderQueueObject);
}
private void send(String routingKey, Object queue) {
    try {
        log.info("SEND message");
        rabbitTemplate.convertAndSend(routingKey, objectMapper.writeValueAsString(queue));
    } catch (JsonProcessingException e) {
        log.warn("Can't send event!", e);
    }
}

消費者

@Slf4j
@RequiredArgsConstructor
@Service
public class RenderRabbitEventListener extends RabbitEventListener {

    private final ApplicationEventPublisher eventPublisher;

    @RabbitListener(bindings = @QueueBinding(value = @Queue(Queues.RENDER_NAME),
                                             exchange = @Exchange(value = Exchanges.EXC_RENDER_NAME, type = "topic"),
                                             key = "render.#")
    )
    public void onMessage(Message message, Channel channel) {
        String routingKey = parseRoutingKey(message);

        log.debug(String.format("Event %s", routingKey));

        RenderQueueObject queueObject = parseRender(message, RenderQueueObject.class);
        handleMessage(queueObject);
    }
    public void handleMessage(RenderQueueObject render) {
        GenericSpringEvent<RenderQueueObject> springEvent = new GenericSpringEvent<>(render);
        springEvent.setRender(true);
        eventPublisher.publishEvent(springEvent);
    }
}

public class Exchanges {
    public static final String EXC_RENDER_NAME = "render.exchange.topic";
    public static final TopicExchange EXC_RENDER = new TopicExchange(EXC_RENDER_NAME, true, false);
}

public class Queues {
    public static final String RENDER_NAME = "render.queue.topic";
    public static final Queue RENDER = new Queue(RENDER_NAME);
}

這樣我的消息就被處理了。 如果我添加@Async，那么會有並行處理，但如果應用程序崩潰，那么在新的開始時，將不會再次發送消息。

@EventListener(condition = "#event.render")
public void startRender(GenericSpringEvent<RenderQueueObject> event) {
    RenderQueueObject render = event.getWhat();
    storageService.updateDocument(
            render.getGuid(),
            new Document("$set", new Document("dateStartRendering", new Date()).append("status", State.rendering.toString()))
    );
    Future<RenderWorkObject> submit = taskExecutor.submit(new RenderExecutor(render));
    try {
        completeResult(submit);
    } catch (IOException | ExecutionException | InterruptedException e) {
        log.info("Error when complete results after invoke executors");
    }
}

private void completeResult(Future<RenderWorkObject> renderFuture) throws IOException, ExecutionException, InterruptedException {
    RenderWorkObject renderWorkObject = renderFuture.get();
    State currentState = renderWorkObject.getState();
    if (Stream.of(result, error, cancel).anyMatch(isEqual(currentState))) {
       storageService.updateDocument(renderWorkObject.getGuidJob(), new Document("$set", toUpdate));
    }
}

我嘗試自定義配置以滿足我的需求。 但它沒有用：

@Bean
Queue queue() {
    return Queues.RENDER;
}

@Bean
TopicExchange exchange() {
    return Exchanges.EXC_RENDER;
}

@Bean
Binding binding(Queue queue, TopicExchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with(Queues.RENDER_NAME);
}

@Bean
public RabbitTemplate rabbitTemplate(@Qualifier("defaultConnectionFactory") ConnectionFactory connectionFactory) {
    RabbitTemplate template = new RabbitTemplate(connectionFactory);
    return template;
}
@Bean
public SimpleMessageListenerContainer container(@Qualifier("defaultConnectionFactory") ConnectionFactory connectionFactory, RabbitEventListener listenerAdapter) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
    container.setQueueNames(Queues.RENDER_NAME);
    container.setQueues(Queues.RENDER);
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(20);
    container.setConcurrentConsumers(10);
    container.setPrefetchCount(1000);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    return container;
}
@Bean
public ConnectionFactory defaultConnectionFactory() {
    CachingConnectionFactory cf = new CachingConnectionFactory();
    cf.setAddresses("127.0.0.1:5672");
    cf.setUsername("guest");
    cf.setPassword("guest");
    cf.setVirtualHost("/");
    cf.setPublisherConfirms(true);
    cf.setPublisherReturns(true);
    cf.setChannelCacheSize(25);

    ExecutorService es = Executors.newFixedThreadPool(20);
    cf.setExecutor(es);
    return cf;
}

我將不勝感激任何想法

Answer 1

我想我找到了解決方案。 我更改了 RenderRabbitEventListener 以便它在崩潰的情況下從 Rabbit 收到消息時再次將消息發送到隊列。 多虧了這一點，我的消費者將始終並行工作。 這將在所有節點發生故障以及一個節點發生故障的情況下並行工作。

以下是我所做的更改：

@RabbitListener(bindings = @QueueBinding(value = @Queue(Queues.RENDER_NAME),
        exchange = @Exchange(value = Exchanges.EXC_RENDER_NAME, type = "topic"),
        key = "render.#")
)
public void onMessage(Message message, Channel channel,
                      @Header(AmqpHeaders.DELIVERY_TAG) long tag
) {
    RenderQueueObject queueObject = parseRender(message, RenderQueueObject.class);
    if (message.getMessageProperties().isRedelivered()) {
        log.info("Message Redelivered, try also");
        try {
            channel.basicAck(tag, false);
            MessageConverter messageConverter = rabbitTemplate.getMessageConverter();
            String valueAsString = parseBody(message);
            Message copyMessage = messageConverter.toMessage(valueAsString, new MessageProperties());
            rabbitTemplate.convertAndSend(
                    message.getMessageProperties().getReceivedRoutingKey(),
                    copyMessage);
            return;
        } catch (IOException e) {
            log.info("basicAck exception");
        }
    }
    log.info("message not redelievered");
    String routingKey = parseRoutingKey(message);
    log.debug(String.format("Event %s", routingKey));
    handleMessage(queueObject);
}