org.springframework.cloud.stream.binding.MessageConverterConfigurer Java Examples

private DirectChannel createBindableChannelInternal(String channelName,
		BindingProperties bindingProperties, boolean inputChannel) {

	MessageConverterConfigurer messageConverterConfigurer = getBinder()
			.getApplicationContext().getBean(MessageConverterConfigurer.class);

	DirectChannel channel = new DirectChannel();
	channel.setBeanName(channelName);
	if (inputChannel) {
		messageConverterConfigurer.configureInputChannel(channel, channelName);
	}
	else {
		messageConverterConfigurer.configureOutputChannel(channel, channelName);
	}
	return channel;
}
 

@Test
public void testDefaultMessageSource() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(2);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	AtomicInteger count = new AtomicInteger();
	assertThat(pollableSource.poll(message -> {
		assertThat(message).isNotNull();
		count.incrementAndGet();
	})).isTrue();
	assertThat(count.get()).isOne();
}
 

@SuppressWarnings("unchecked")
@Test
public void testAutoStartupOn() {
	TestChannelBinder binder = createBinder();
	binder.setMessageSourceDelegate(new LifecycleMessageSource(
			() -> new GenericMessage<>("{\"foo\":\"bar\"}".getBytes())));
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setAutoStartup(true);

	Binding<PollableSource<MessageHandler>> pollableSourceBinding = binder
			.bindPollableConsumer("foo", "bar", pollableSource, properties);

	assertThat(pollableSourceBinding.isRunning()).isTrue();
}
 

@SuppressWarnings("unchecked")
@Test
public void testAutoStartupOff() {
	TestChannelBinder binder = createBinder();
	binder.setMessageSourceDelegate(new LifecycleMessageSource(
			() -> new GenericMessage<>("{\"foo\":\"bar\"}".getBytes())));
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setAutoStartup(false);

	Binding<PollableSource<MessageHandler>> pollableSourceBinding = binder
			.bindPollableConsumer("foo", "bar", pollableSource, properties);

	assertThat(pollableSourceBinding.isRunning()).isFalse();
}
 

private MessageConverterConfigurer createConverterConfigurer(String channelName,
		BindingProperties bindingProperties) throws Exception {
	BindingServiceProperties bindingServiceProperties = new BindingServiceProperties();
	bindingServiceProperties.getBindings().put(channelName, bindingProperties);
	bindingServiceProperties.setApplicationContext(applicationContext);
	bindingServiceProperties.setConversionService(new DefaultConversionService());
	bindingServiceProperties.afterPropertiesSet();
	MessageConverterConfigurer messageConverterConfigurer = new MessageConverterConfigurer(
			bindingServiceProperties,
			new CompositeMessageConverterFactory(null, null).getMessageConverterForAllRegistered());
	messageConverterConfigurer.setBeanFactory(applicationContext.getBeanFactory());
	return messageConverterConfigurer;
}
 

public RocketMQMessageHandler(RocketMQTemplate rocketMQTemplate, String destination,
		String groupName, Boolean transactional,
		InstrumentationManager instrumentationManager,
		ExtendedProducerProperties<RocketMQProducerProperties> producerProperties,
		MessageConverterConfigurer.PartitioningInterceptor partitioningInterceptor) {
	this.rocketMQTemplate = rocketMQTemplate;
	this.destination = destination;
	this.groupName = groupName;
	this.transactional = transactional;
	this.instrumentationManager = instrumentationManager;
	this.producerProperties = producerProperties;
	this.partitioningInterceptor = partitioningInterceptor;
}
 

protected DirectChannel createBindableChannel(String channelName,
		BindingProperties bindingProperties, boolean inputChannel) throws Exception {
	MessageConverterConfigurer messageConverterConfigurer = createConverterConfigurer(
			channelName, bindingProperties);
	DirectChannel channel = new DirectChannel();
	channel.setBeanName(channelName);
	if (inputChannel) {
		messageConverterConfigurer.configureInputChannel(channel, channelName);
	}
	else {
		messageConverterConfigurer.configureOutputChannel(channel, channelName);
	}
	return channel;
}
 

@Test
public void testRequeueFromErrorFlow() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	AcknowledgmentCallback callback = mock(AcknowledgmentCallback.class);
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder.fromMessage(message)
					.setHeader(
							IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK,
							callback)
					.build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(null);
	properties.setMaxAttempts(1);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	SubscribableChannel errorChannel = new DirectChannel();
	errorChannel.subscribe(msg -> {
		throw new RequeueCurrentMessageException((Throwable) msg.getPayload());
	});
	pollableSource.setErrorChannel(errorChannel);
	try {
		pollableSource.poll(received -> {
			throw new RuntimeException("test requeue from error flow");
		});
	}
	catch (Exception e) {
		// no op
	}
	verify(callback).acknowledge(Status.REQUEUE);
}
 

@Test
public void testRequeueWithNoAcknowledgementCallback() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder.fromMessage(message)
					.build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(null);
	properties.setMaxAttempts(2);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicInteger count = new AtomicInteger();

	assertThat(pollableSource.poll(received -> {
		count.incrementAndGet();
		throw new RequeueCurrentMessageException("test retry");
	})).isTrue();

	assertThat(count.get()).isEqualTo(2);

}
 

@Test
public void testRequeue() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	AcknowledgmentCallback callback = mock(AcknowledgmentCallback.class);
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder.fromMessage(message)
					.setHeader(
							IntegrationMessageHeaderAccessor.ACKNOWLEDGMENT_CALLBACK,
							callback)
					.build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(null);
	properties.setMaxAttempts(2);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicInteger count = new AtomicInteger();
	try {
		assertThat(pollableSource.poll(received -> {
			count.incrementAndGet();
			throw new RequeueCurrentMessageException("test retry");
		})).isTrue();
	}
	catch (Exception e) {
		// no op
	}
	assertThat(count.get()).isEqualTo(2);
	verify(callback).acknowledge(Status.REQUEUE);
}
 

@Test
public void testErrorsNoRetry() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder
					.withPayload(((String) message.getPayload()).toUpperCase())
					.copyHeaders(message.getHeaders()).build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(1);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final CountDownLatch latch = new CountDownLatch(1);
	this.context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME,
			SubscribableChannel.class).subscribe(m -> {
				latch.countDown();
			});
	final AtomicInteger count = new AtomicInteger();
	assertThat(pollableSource.poll(received -> {
		count.incrementAndGet();
		throw new RuntimeException("test recoverer");
	})).isTrue();
	assertThat(count.get()).isEqualTo(1);
}
 

@Test
public void testConvertMap() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	binder.setMessageSourceDelegate(
			() -> new GenericMessage<>("{\"qux\":{\"foo\":\"bar\"}}".getBytes()));
	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");

	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(1);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicReference<Object> payload = new AtomicReference<>();
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<Map<String, Foo>>() {
	})).isTrue();
	@SuppressWarnings("unchecked")
	Map<String, Foo> map = (Map<String, Foo>) payload.get();
	assertThat(map.size()).isEqualTo(1);
	assertThat(map.get("qux").getFoo()).isEqualTo("bar");
}
 

@Test
public void testConvertList() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	binder.setMessageSourceDelegate(() -> new GenericMessage<>(
			"[{\"foo\":\"bar\"},{\"foo\":\"baz\"}]".getBytes()));
	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");

	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(1);
	properties.setBackOffInitialInterval(0);

	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);

	final AtomicReference<Object> payload = new AtomicReference<>();
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<List<Foo>>() {
	})).isTrue();
	@SuppressWarnings("unchecked")
	List<Foo> list = (List<Foo>) payload.get();
	assertThat(list.size()).isEqualTo(2);
	assertThat(list.get(0).getFoo()).isEqualTo("bar");
	assertThat(list.get(1).getFoo()).isEqualTo("baz");
}
 

@Test
public void testConvertSimpler() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);
	BindingServiceProperties bsps = this.context
			.getBean(BindingServiceProperties.class);
	BindingProperties props = new BindingProperties();
	props.setContentType("text/plain");
	bsps.setBindings(Collections.singletonMap("foo", props));

	binder.setMessageSourceDelegate(() -> new GenericMessage<>("foo".getBytes()));
	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");

	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(1);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicReference<Object> payload = new AtomicReference<>();
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<String>() {
	})).isTrue();
	assertThat(payload.get()).isInstanceOf(String.class);
	assertThat(payload.get()).isEqualTo("foo");
	// test the cache for coverage
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<String>() {
	})).isTrue();
	assertThat(payload.get()).isInstanceOf(String.class);
	assertThat(payload.get()).isEqualTo("foo");
}
 

@Test
public void testConvertSimple() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	binder.setMessageSourceDelegate(
			() -> new GenericMessage<>("{\"foo\":\"bar\"}".getBytes()));
	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");

	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(1);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicReference<Object> payload = new AtomicReference<>();
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<Foo>() {
	})).isTrue();
	assertThat(payload.get()).isInstanceOf(Foo.class);
	assertThat(((Foo) payload.get()).getFoo()).isEqualTo("bar");
	// test the cache for coverage
	assertThat(pollableSource.poll(received -> {
		payload.set(received.getPayload());
	}, new ParameterizedTypeReference<Foo>() {
	})).isTrue();
	assertThat(payload.get()).isInstanceOf(Foo.class);
	assertThat(((Foo) payload.get()).getFoo()).isEqualTo("bar");
}
 

@Test
public void testSimple() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder
					.withPayload(((String) message.getPayload()).toUpperCase())
					.copyHeaders(message.getHeaders()).build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(2);
	properties.setBackOffInitialInterval(0);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final AtomicInteger count = new AtomicInteger();
	assertThat(pollableSource.poll(received -> {
		assertThat(received.getPayload()).isEqualTo("POLLED DATA");
		assertThat(received.getHeaders().get(MessageHeaders.CONTENT_TYPE))
				.isEqualTo(MimeType.valueOf("text/plain"));
		if (count.incrementAndGet() == 1) {
			throw new RuntimeException("test retry");
		}
	})).isTrue();
	assertThat(count.get()).isEqualTo(2);
}
 

@Bean
public CompositeMessageChannelConfigurer compositeMessageChannelConfigurer(
		MessageConverterConfigurer messageConverterConfigurer) {
	List<MessageChannelConfigurer> configurerList = new ArrayList<>();
	configurerList.add(messageConverterConfigurer);
	return new CompositeMessageChannelConfigurer(configurerList);
}
 

@Bean
public MessageConverterConfigurer messageConverterConfigurer(
		BindingServiceProperties bindingServiceProperties,
		@Qualifier(IntegrationContextUtils.ARGUMENT_RESOLVER_MESSAGE_CONVERTER_BEAN_NAME) CompositeMessageConverter compositeMessageConverter,
		@Nullable StreamFunctionProperties streamFunctionProperties) {

	return new MessageConverterConfigurer(bindingServiceProperties, compositeMessageConverter, streamFunctionProperties);
}
 

@Test
public void testErrors() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder
					.withPayload(((String) message.getPayload()).toUpperCase())
					.copyHeaders(message.getHeaders()).build();
		}

	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setMaxAttempts(2);
	properties.setBackOffInitialInterval(0);
	properties.getRetryableExceptions().put(IllegalStateException.class, false);
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	final CountDownLatch latch = new CountDownLatch(1);
	this.context.getBean(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME,
			SubscribableChannel.class).subscribe(m -> {
				latch.countDown();
			});
	final AtomicInteger count = new AtomicInteger();
	assertThat(pollableSource.poll(received -> {
		count.incrementAndGet();
		throw new RuntimeException("test recoverer");
	})).isTrue();
	assertThat(count.get()).isEqualTo(2);
	Message<?> lastError = binder.getLastError();
	assertThat(lastError).isNotNull();
	assertThat(((Exception) lastError.getPayload()).getCause().getMessage())
			.isEqualTo("test recoverer");
	assertThat(pollableSource.poll(received -> {
		count.incrementAndGet();
		throw new IllegalStateException("no retries");
	})).isTrue();
	assertThat(count.get()).isEqualTo(3);
	lastError = binder.getLastError();
	assertThat(lastError).isNotNull();
	assertThat(((Exception) lastError.getPayload()).getCause().getMessage())
			.isEqualTo("no retries");
}
 

@Test
public void testEmbedded() {
	TestChannelBinder binder = createBinder();
	MessageConverterConfigurer configurer = this.context
			.getBean(MessageConverterConfigurer.class);

	binder.setMessageSourceDelegate(() -> {
		MessageValues original = new MessageValues("foo".getBytes(),
				Collections.singletonMap(MessageHeaders.CONTENT_TYPE,
						"application/octet-stream"));
		byte[] payload = new byte[0];
		try {
			payload = EmbeddedHeaderUtils.embedHeaders(original,
					MessageHeaders.CONTENT_TYPE);
		}
		catch (Exception e) {
			fail(e.getMessage());
		}
		return new GenericMessage<>(payload);
	});
	ExtendedConsumerProperties<Object> properties = new ExtendedConsumerProperties<>(
			null);
	properties.setHeaderMode(HeaderMode.embeddedHeaders);
	DefaultPollableMessageSource pollableSource = new DefaultPollableMessageSource(
			this.messageConverter);
	configurer.configurePolledMessageSource(pollableSource, "foo");
	pollableSource.addInterceptor(new ChannelInterceptor() {

		@Override
		public Message<?> preSend(Message<?> message, MessageChannel channel) {
			return MessageBuilder
					.withPayload(
							new String((byte[]) message.getPayload()).toUpperCase())
					.copyHeaders(message.getHeaders()).build();
		}

	});
	binder.bindPollableConsumer("foo", "bar", pollableSource, properties);
	assertThat(pollableSource.poll(received -> {
		assertThat(received.getPayload()).isEqualTo("FOO");
		assertThat(received.getHeaders().get(MessageHeaders.CONTENT_TYPE))
				.isEqualTo("application/octet-stream");
	})).isTrue();
}