org.springframework.amqp.support.converter.MessageConverter Java Examples

@Test
public void RejectAndDontRequeue例外が発生した場合はリトライが実行されない() throws Exception {
    container.setQueues(ctx.getBean("retryTestQueue", Queue.class));
    container.setMessageListener(new MessageListenerAdapter(new AmqpRejectAndDontRequeueExceptionTestHandler(), ctx.getBean(MessageConverter.class)));
    unrecoverableContainer.setQueues(ctx.getBean("unrecoverableExceptionQueue", Queue.class));
    unrecoverableContainer.setMessageListener(new MessageListenerAdapter(new UnrecoverableTestHandler(), ctx.getBean(MessageConverter.class)));
    container.start();
    unrecoverableContainer.start();
    template.convertAndSend("retry.test.exchange", "retry.test.binding", new RetryTestBean("test"));
    assertThat(unretry.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unretry.getCount(), is(0L));
    assertThat(unrecover.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unrecover.getCount(), is(0L));
    container.stop();
    unrecoverableContainer.stop();
}
 

@Test
public void システム例外の場合はリトライが実行されない() throws Exception {
    container.setQueues(ctx.getBean("retryTestQueue", Queue.class));
    container.setMessageListener(new MessageListenerAdapter(new SystemExceptionTestHandler(), ctx.getBean(MessageConverter.class)));
    unrecoverableContainer.setQueues(ctx.getBean("unrecoverableExceptionQueue", Queue.class));
    unrecoverableContainer.setMessageListener(new MessageListenerAdapter(new UnrecoverableTestHandler(), ctx.getBean(MessageConverter.class)));
    container.start();
    unrecoverableContainer.start();
    template.convertAndSend("retry.test.exchange", "retry.test.binding", new RetryTestBean("test"));
    assertThat(unretry.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unretry.getCount(), is(0L));
    assertThat(unrecover.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unrecover.getCount(), is(0L));
    container.stop();
    unrecoverableContainer.stop();
}
 

@Test
public void アプリケーション回復不能例外の場合はリトライが実行されない() throws Exception {
    container.setQueues(ctx.getBean("retryTestQueue", Queue.class));
    container.setMessageListener(new MessageListenerAdapter(new ApplicationUnrecoverableExceptionTestHandler(), ctx.getBean(MessageConverter.class)));
    unrecoverableContainer.setQueues(ctx.getBean("unrecoverableExceptionQueue", Queue.class));
    unrecoverableContainer.setMessageListener(new MessageListenerAdapter(new UnrecoverableTestHandler(), ctx.getBean(MessageConverter.class)));
    container.start();
    unrecoverableContainer.start();
    template.convertAndSend("retry.test.exchange", "retry.test.binding", new RetryTestBean("test"));
    assertThat(unretry.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unretry.getCount(), is(0L));
    assertThat(unrecover.await(3, TimeUnit.SECONDS), is(true));
    assertThat(unrecover.getCount(), is(0L));
    container.stop();
    unrecoverableContainer.stop();
}
 

@Test
public void 回復可能例外の場合はデフォルトの指定回数リトライが実行されて回復可能例外キューに配信される() throws Exception {
    container.setQueues(ctx.getBean("retryTestQueue", Queue.class));
    container.setMessageListener(new MessageListenerAdapter(new ApplicationRecoverableExceptionTestHandler(), ctx.getBean(MessageConverter.class)));
    recoverableContainer.setQueues(ctx.getBean("recoverableExceptionQueue", Queue.class));
    recoverableContainer.setMessageListener(new MessageListenerAdapter(new RecoverableTestHandler(), ctx.getBean(MessageConverter.class)));
    container.start();
    recoverableContainer.start();
    template.convertAndSend("retry.test.exchange", "retry.test.binding", new RetryTestBean("test"));
    assertThat(retry.await(30, TimeUnit.SECONDS), is(true));
    assertThat(retry.getCount(), is(0L));
    assertThat(recover.await(3, TimeUnit.SECONDS), is(true));
    assertThat(recover.getCount(), is(0L));
    container.stop();
    recoverableContainer.stop();
}
 

@Override
public Factory addDLX(String queueName, String exchangeName, String routingKey, Processor processor, SendTypeEnum type,
                      MessageConverter messageConverter) {
    if (processor != null) {
        msgAdapterHandler.add(exchangeName, routingKey, processor, type, messageConverter);
        if (rabbit.isListenerEnable()) {
            declareBinding(queueName, exchangeName, routingKey, true,
                    type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), true);
            if (listenerContainer == null) {
                initMsgListenerAdapter();
            } else {
                listenerContainer.addQueueNames(queueName);
            }
        } else {
            declareBinding(queueName, exchangeName, routingKey, false,
                    type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), true);
        }
        return this;
    } else {
        declareBinding(queueName, exchangeName, routingKey, false,
                type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), true);
        return this;
    }
}
 

@Override
public Factory add(String queueName, String exchangeName, String routingKey, Processor processor, SendTypeEnum type,
                   MessageConverter messageConverter) {
    if (processor != null) {
        msgAdapterHandler.add(exchangeName, routingKey, processor, type, messageConverter);
        if (rabbit.isListenerEnable()) {
            declareBinding(queueName, exchangeName, routingKey, true,
                    type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), false);
            if (listenerContainer == null) {
                initMsgListenerAdapter();
            } else {
                listenerContainer.addQueueNames(queueName);
            }
        } else {
            declareBinding(queueName, exchangeName, routingKey, false,
                    type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), false);
        }
        return this;
    } else {
        declareBinding(queueName, exchangeName, routingKey, false,
                type == null ? SendTypeEnum.DIRECT.toString() : type.toString(), false);
        return this;
    }
}
 

@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(MessageConverter converter,
    ConnectionFactory connectionFactory, @Autowired(required = false) List<Consumer<?>> list) {
  SimpleMessageListenerContainer container =
      new SimpleMessageListenerContainer(connectionFactory);
  init(list);
  Receiver receiver = new Receiver(converter);
  container.setMessageListener(new MessageListenerAdapter(receiver, converter));
  container.setQueueNames(queueNames.toArray(new String[0]));
  container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  container.setPrefetchCount(prefetchCount);
  container.setTxSize(txSize);
  return container;
}
 

@Test
public void 値がオーバライドされて指定のインスタンスがDIコンテナに登録される() {
    assertThat(config.host, is("192.168.10.10"));
    assertThat(config.port, is("5673"));
    assertThat(config.username, is("jfw"));
    assertThat(config.password, is("jfw"));
    assertThat(config.channelCacheSize, is(100));
    assertThat(context.getBean(ConnectionFactory.class), is(notNullValue()));
    assertThat(context.getBean(RabbitTemplate.class), is(notNullValue()));
    assertThat(context.getBean(MessageConverter.class), is(notNullValue()));
}
 

@Test
public void デフォルト値が設定されて指定のインスタンスがDIコンテナに登録される() {
    assertThat(config.host, is("127.0.0.1"));
    assertThat(config.port, is("5672"));
    assertThat(config.username, is("guest"));
    assertThat(config.password, is("guest"));
    assertThat(config.channelCacheSize, is(10));
    assertThat(context.getBean(ConnectionFactory.class), is(notNullValue()));
    assertThat(context.getBean(RabbitTemplate.class), is(notNullValue()));
    assertThat(context.getBean(MessageConverter.class), is(notNullValue()));
}
 

@Bean
public MessageConverter jsonMessageConverter()
{
    final Jackson2JsonMessageConverter converter = new Jackson2JsonMessageConverter();
    converter.setClassMapper(classMapper());
    return converter;
}
 

private Object send(String exchangeName, Object msg, MessageConverter messageConverter, SendTypeEnum type,
                    String routingKey, int expiration, int priority) throws Exception {
    check(exchangeName, routingKey);

    Object obj = null;
    String msgId = UUID.randomUUID().toString();
    EventMessage eventMessage = new EventMessage(exchangeName, routingKey, type.toString(), msg, null, msgId);
    MessageProperties messageProperties = new MessageProperties();
    //过期时间
    if (expiration > 0) {
        messageProperties.setExpiration(String.valueOf(expiration));
    }
    //消息优先级
    if (priority > 0) {
        messageProperties.setPriority(priority);
    }
    messageProperties.setMessageId(msgId);
    // 设置消息持久化
    messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
    Message message = messageConverter.toMessage(eventMessage, messageProperties);
    rabbitmqFactory.setCorrelationData(msgId, null, eventMessage, null);
    try {
        if (SendTypeEnum.RPC.equals(type)) {
            obj = eventAmqpTemplate.convertSendAndReceive(routingKey, message);
        } else {
            eventAmqpTemplate.send(exchangeName, routingKey, message);
        }
    } catch (AmqpException e) {
        logger.error("send event fail. Event Message : [{}]", eventMessage, e);
        throw new Exception("send event fail", e);
    }
    return obj;
}
 

protected void add(String exchangeName, String routingKey, Processor processor, SendTypeEnum type,
                   MessageConverter messageConverter) {

    Objects.requireNonNull(exchangeName, "The exchangeName is empty.");
    Objects.requireNonNull(messageConverter, "The messageConverter is empty.");
    Objects.requireNonNull(routingKey, "The routingKey is empty.");

    ProcessorWrap pw = new ProcessorWrap(messageConverter, processor);
    ProcessorWrap oldProcessorWrap = map.putIfAbsent(exchangeName + "_" + routingKey + "_" +
            (type == null ? SendTypeEnum.DIRECT.toString() : type.toString()), pw);
    if (oldProcessorWrap != null) {
        logger.warn("The processor of this queue and exchange exists");
    }
}
 

@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
		ConnectionFactory connectionFactory, MessageConverter messageConverter) {
	SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
	factory.setConnectionFactory(connectionFactory);
	factory.setConcurrentConsumers(3);
	factory.setMaxConcurrentConsumers(10);
	factory.setMessageConverter(messageConverter);
	return factory;
}
 

@Bean
MessageListenerAdapter messageListenerAdapter(BusReceiver busReceiver, MessageConverter messageConverter) {
    log.info("new listener");
    return new MessageListenerAdapter(busReceiver, messageConverter);
}
 

@Bean 
MessageConverter jacksonAmqpMessageConverter(ObjectMapper aObjectMapper) {
  return new Jackson2JsonMessageConverter(aObjectMapper);
}
 

@Bean
public MessageConverter jsonMessageConverter() {
    return new Jackson2JsonMessageConverter();
}
 

@Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}
 

@Bean
public MessageConverter messageConverter() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    return new ContentTypeDelegatingMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
}
 

@Bean
public MessageConverter messageConverter() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    return new ContentTypeDelegatingMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
}
 

@Bean
public MessageConverter messageConverter() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    return new ContentTypeDelegatingMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
}
 

@Bean
public MessageConverter messageConverter() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    return new ContentTypeDelegatingMessageConverter(new Jackson2JsonMessageConverter(objectMapper));
}
 

@Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter();
}
 

@Bean
public MessageConverter jackson2JsonMessageConverter() {
    Jackson2JsonMessageConverter bean = new Jackson2JsonMessageConverter();
    return bean;
}
 

@Bean
public MessageConverter jackson2JsonMessageConverter() {
    Jackson2JsonMessageConverter bean = new Jackson2JsonMessageConverter();
    return bean;
}
 

@Bean
public MessageListenerAdapter messageListenerAdapter(
		MessageSubscriber messageSubscriber, MessageConverter messageConverter) {
	return new MessageListenerAdapter(messageSubscriber, messageConverter);
}
 

ContractVerifierHelper(MessageVerifier<Message> exchange,
		MessageConverter messageConverter) {
	super(exchange);
	this.messageConverter = messageConverter;
}
 

@Bean
public MessageConverter jsonMessageConverter() {
    return new Jackson2JsonMessageConverter();
}
 

protected MessageConverter getMessageConverter() {
    return rabbitTemplate.getMessageConverter();
}
 

public void setMessageConverter(MessageConverter messageConverter) {
	this.messageConverter = messageConverter;
}
 

@Bean
public MessageConverter messageConverter() {
    return new Jackson2JsonMessageConverter(objectMapper);
}