From d168dfe675e7d86f3e61ca33a6738407aaefc73d Mon Sep 17 00:00:00 2001 From: scruel Date: Fri, 24 Dec 2021 14:24:00 +0800 Subject: [PATCH 1/7] Add MediaMessage annotation support. Supports the ability to define the content type of Message from the client side for resolving. --- .../kafka/annotation/MediaMessage.java | 48 ++++++++++++++ .../resolver/MediaMessageResolver.java | 64 +++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java create mode 100644 spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java diff --git a/spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java b/spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java new file mode 100644 index 0000000000..c1ca164352 --- /dev/null +++ b/spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java @@ -0,0 +1,48 @@ +/* + * Copyright 2014-2021 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.kafka.annotation; + +import org.springframework.util.MimeTypeUtils; + +import java.lang.annotation.*; + +/** + * Used to define the content type of {@code Message} with {@code MediaMessageResolver}. + * + * @author Scruel Tao + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.PARAMETER}) +public @interface MediaMessage { + /** + * The string value of the content type of message, which can support parse, + * Default application/json. + * + * @return the string value of mime type. + * @see org.springframework.util.MimeType + */ + String type() default MimeTypeUtils.APPLICATION_JSON_VALUE; + + /** + * Regardless of whether there is a type header in the {@code Message}, the parse + * progress will set the header of {@code Message} by this annotation {@link #type()}. + * + * @return whether to force parse with the annotation {@link #type()} + */ + boolean force() default false; +} diff --git a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java new file mode 100644 index 0000000000..64b606dd97 --- /dev/null +++ b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java @@ -0,0 +1,64 @@ +/* + * Copyright 2014-2021 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.kafka.support.resolver; + +import org.springframework.core.MethodParameter; +import org.springframework.kafka.annotation.MediaMessage; +import org.springframework.messaging.Message; +import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.handler.annotation.support.PayloadMethodArgumentResolver; +import org.springframework.messaging.support.MessageBuilder; + +/** + * A resolver to extract and convert the payload of a message using a MessageConverter. + * This HandlerMethodArgumentResolver only work with MediaMessage annotation now. + * + * @author Scruel Tao + */ +public class MediaMessageResolver extends PayloadMethodArgumentResolver { + /** + * Create a new {@code MediaMessageResolver} with the given + * {@link MessageConverter}. + * + * @param messageConverter the MessageConverter to use (required) + */ + public MediaMessageResolver(MessageConverter messageConverter) { + super(messageConverter); + } + + @Override + public boolean supportsParameter(MethodParameter parameter) { + return parameter.hasParameterAnnotation(MediaMessage.class); + } + + @Override + public Object resolveArgument(MethodParameter parameter, Message message) throws Exception { + MediaMessage ann = parameter.getParameterAnnotation(MediaMessage.class); + if (null == ann) { + throw new IllegalStateException("Annotation parsing failed."); + } + // If not present, parse content type from annotation + if (message.getHeaders().get(MessageHeaders.CONTENT_TYPE) == null) { + message = MessageBuilder.fromMessage(message) + .setHeader(MessageHeaders.CONTENT_TYPE, ann.type()) + .build(); + } + return super.resolveArgument(parameter, message); + } + +} From ab7edc021157702da473262ef8de49a07fa2ce5d Mon Sep 17 00:00:00 2001 From: scruel Date: Tue, 4 Jan 2022 23:08:47 +0800 Subject: [PATCH 2/7] Complete MediaMessage annotation support force part and tests. --- .../resolver/MediaMessageResolver.java | 3 +- .../resolver/MediaMessageResolverTests.java | 165 ++++++++++++++++++ 2 files changed, 167 insertions(+), 1 deletion(-) create mode 100644 spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java diff --git a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java index 64b606dd97..fbcaace227 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java @@ -53,7 +53,8 @@ public Object resolveArgument(MethodParameter parameter, Message message) thr throw new IllegalStateException("Annotation parsing failed."); } // If not present, parse content type from annotation - if (message.getHeaders().get(MessageHeaders.CONTENT_TYPE) == null) { + Object type = message.getHeaders().get(MessageHeaders.CONTENT_TYPE); + if (ann.force() || type == null) { message = MessageBuilder.fromMessage(message) .setHeader(MessageHeaders.CONTENT_TYPE, ann.type()) .build(); diff --git a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java new file mode 100644 index 0000000000..8d633cd577 --- /dev/null +++ b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java @@ -0,0 +1,165 @@ +/* + * Copyright 2019-2021 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.kafka.support.resolver; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import org.jetbrains.annotations.NotNull; +import org.junit.jupiter.api.Test; +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.NoSuchBeanDefinitionException; +import org.springframework.beans.factory.support.DefaultListableBeanFactory; +import org.springframework.kafka.annotation.KafkaListenerAnnotationBeanPostProcessor; +import org.springframework.kafka.annotation.KafkaListenerConfigurer; +import org.springframework.kafka.annotation.MediaMessage; +import org.springframework.kafka.config.KafkaListenerEndpointRegistrar; +import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.*; +import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory; +import org.springframework.messaging.handler.invocation.InvocableHandlerMethod; +import org.springframework.messaging.support.GenericMessage; + +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +/** + * @author Scruel Tao + */ +public class MediaMessageResolverTests { + private static final String TEXT = "kafka"; + + @Test + void jsonFoo() throws Exception { + InvocableHandlerMethod method = getFooInvocableHandlerMethod(); + String s = new ObjectMapper().writeValueAsString(new Foo().setText(TEXT)); + method.invoke(new GenericMessage<>(s)); + } + + @Test + void bytesToFoo() throws Exception { + InvocableHandlerMethod method = getFooInvocableHandlerMethod(); + String s = new ObjectMapper().writeValueAsString(new Foo().setText(TEXT)); + method.invoke(new GenericMessage<>(s.getBytes(StandardCharsets.UTF_8))); + } + + public void onMessageWithFoo(@MediaMessage Foo payload) { + assertThat(payload.getText()).isEqualTo(TEXT); + } + + @Test + void stringToFooForceJson() throws Exception { + final InvocableHandlerMethod method = getFooInvocableHandlerMethod(); + final String s = new ObjectMapper().writeValueAsString(new Foo().setText(TEXT)); + final Map contentType = Map.of(MessageHeaders.CONTENT_TYPE, "application/xml"); + // No converters can process xml media type, so will cause MessageConversionException. + assertThatThrownBy(() -> + method.invoke(new GenericMessage<>(s, contentType))) + .isExactlyInstanceOf(MessageConversionException.class); + // Ignore the header, and force using own converter. + InvocableHandlerMethod forceMethod = getForceJsonFooInvocableHandlerMethod(); + forceMethod.invoke(new GenericMessage<>(s, contentType)); + } + + public void onForceJsonMessageWithFoo(@MediaMessage(force = true) Foo payload) { + assertThat(payload.getText()).isEqualTo(TEXT); + } + + @NotNull + private InvocableHandlerMethod getFooInvocableHandlerMethod() throws NoSuchMethodException { + MessageHandlerMethodFactory factory = getMessageHandlerMethodFactory(); + return factory.createInvocableHandlerMethod(this, getClass().getDeclaredMethod( + "onMessageWithFoo", Foo.class)); + } + + @NotNull + private InvocableHandlerMethod getForceJsonFooInvocableHandlerMethod() throws NoSuchMethodException { + MessageHandlerMethodFactory factory = getMessageHandlerMethodFactory(); + return factory.createInvocableHandlerMethod(this, getClass().getDeclaredMethod( + "onForceJsonMessageWithFoo", Foo.class)); + } + + @SuppressWarnings("rawtypes") + private MessageHandlerMethodFactory getMessageHandlerMethodFactory() { + KafkaListenerAnnotationBeanPostProcessor bpp = new KafkaListenerAnnotationBeanPostProcessor<>(); + beanPostProcessorConfig(bpp); + return bpp.getMessageHandlerMethodFactory(); + } + + @SuppressWarnings("rawtypes") + private void beanPostProcessorConfig(KafkaListenerAnnotationBeanPostProcessor processor) { + processor.setBeanFactory(new KafkaBeanFactory()); + try { + processor.afterSingletonsInstantiated(); + } catch (NoSuchBeanDefinitionException ignore) { + } + } + + @SuppressWarnings("unchecked") + static class KafkaBeanFactory extends DefaultListableBeanFactory { + @Override + public Map getBeansOfType(Class type) throws BeansException { + return new HashMap<>() { + { + if (KafkaListenerConfigurer.class.equals(type)) { + put("bean", (T) new MediaMessageConfig()); + } + } + }; + } + } + + static class MediaMessageConfig implements KafkaListenerConfigurer { + public CompositeMessageConverter createMessageConverter() { + List converters = new ArrayList<>(); + converters.add(new StringMessageConverter()); + converters.add(new ByteArrayMessageConverter()); + converters.add(createJacksonConverter()); + return new CompositeMessageConverter(converters); + } + + protected MappingJackson2MessageConverter createJacksonConverter() { + MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); + converter.setContentTypeResolver(new DefaultContentTypeResolver()); + return converter; + } + + @Override + public void configureKafkaListeners(@JsonDeserialize KafkaListenerEndpointRegistrar registrar) { + registrar.setCustomMethodArgumentResolvers(new MediaMessageResolver(createMessageConverter())); + } + } + + static class Foo { + private String text; + + public String getText() { + return text; + } + + public Foo setText(String text) { + this.text = text; + return this; + } + } + +} From 561cb784b59cb6693f3b4297fe01084d88f3e30b Mon Sep 17 00:00:00 2001 From: scruel Date: Tue, 4 Jan 2022 23:28:06 +0800 Subject: [PATCH 3/7] Rename @MediaMessage to @ResolvableType --- .../{MediaMessage.java => ResolvableType.java} | 2 +- ...essageResolver.java => ResolvableTypeResolver.java} | 10 +++++----- ...lverTests.java => ResolvableTypeResolverTests.java} | 10 +++++----- 3 files changed, 11 insertions(+), 11 deletions(-) rename spring-kafka/src/main/java/org/springframework/kafka/annotation/{MediaMessage.java => ResolvableType.java} (97%) rename spring-kafka/src/main/java/org/springframework/kafka/support/resolver/{MediaMessageResolver.java => ResolvableTypeResolver.java} (85%) rename spring-kafka/src/test/java/org/springframework/kafka/support/resolver/{MediaMessageResolverTests.java => ResolvableTypeResolverTests.java} (94%) diff --git a/spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java similarity index 97% rename from spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java rename to spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java index c1ca164352..947d2119e8 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/annotation/MediaMessage.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java @@ -28,7 +28,7 @@ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.PARAMETER}) -public @interface MediaMessage { +public @interface ResolvableType { /** * The string value of the content type of message, which can support parse, * Default application/json. diff --git a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java similarity index 85% rename from spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java rename to spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java index fbcaace227..df5e2e37f7 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/MediaMessageResolver.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java @@ -17,7 +17,7 @@ package org.springframework.kafka.support.resolver; import org.springframework.core.MethodParameter; -import org.springframework.kafka.annotation.MediaMessage; +import org.springframework.kafka.annotation.ResolvableType; import org.springframework.messaging.Message; import org.springframework.messaging.MessageHeaders; import org.springframework.messaging.converter.MessageConverter; @@ -30,25 +30,25 @@ * * @author Scruel Tao */ -public class MediaMessageResolver extends PayloadMethodArgumentResolver { +public class ResolvableTypeResolver extends PayloadMethodArgumentResolver { /** * Create a new {@code MediaMessageResolver} with the given * {@link MessageConverter}. * * @param messageConverter the MessageConverter to use (required) */ - public MediaMessageResolver(MessageConverter messageConverter) { + public ResolvableTypeResolver(MessageConverter messageConverter) { super(messageConverter); } @Override public boolean supportsParameter(MethodParameter parameter) { - return parameter.hasParameterAnnotation(MediaMessage.class); + return parameter.hasParameterAnnotation(ResolvableType.class); } @Override public Object resolveArgument(MethodParameter parameter, Message message) throws Exception { - MediaMessage ann = parameter.getParameterAnnotation(MediaMessage.class); + ResolvableType ann = parameter.getParameterAnnotation(ResolvableType.class); if (null == ann) { throw new IllegalStateException("Annotation parsing failed."); } diff --git a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java similarity index 94% rename from spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java rename to spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java index 8d633cd577..22dba37c64 100644 --- a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/MediaMessageResolverTests.java +++ b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java @@ -25,7 +25,7 @@ import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.kafka.annotation.KafkaListenerAnnotationBeanPostProcessor; import org.springframework.kafka.annotation.KafkaListenerConfigurer; -import org.springframework.kafka.annotation.MediaMessage; +import org.springframework.kafka.annotation.ResolvableType; import org.springframework.kafka.config.KafkaListenerEndpointRegistrar; import org.springframework.messaging.MessageHeaders; import org.springframework.messaging.converter.*; @@ -45,7 +45,7 @@ /** * @author Scruel Tao */ -public class MediaMessageResolverTests { +public class ResolvableTypeResolverTests { private static final String TEXT = "kafka"; @Test @@ -62,7 +62,7 @@ void bytesToFoo() throws Exception { method.invoke(new GenericMessage<>(s.getBytes(StandardCharsets.UTF_8))); } - public void onMessageWithFoo(@MediaMessage Foo payload) { + public void onMessageWithFoo(@ResolvableType Foo payload) { assertThat(payload.getText()).isEqualTo(TEXT); } @@ -80,7 +80,7 @@ void stringToFooForceJson() throws Exception { forceMethod.invoke(new GenericMessage<>(s, contentType)); } - public void onForceJsonMessageWithFoo(@MediaMessage(force = true) Foo payload) { + public void onForceJsonMessageWithFoo(@ResolvableType(force = true) Foo payload) { assertThat(payload.getText()).isEqualTo(TEXT); } @@ -145,7 +145,7 @@ protected MappingJackson2MessageConverter createJacksonConverter() { @Override public void configureKafkaListeners(@JsonDeserialize KafkaListenerEndpointRegistrar registrar) { - registrar.setCustomMethodArgumentResolvers(new MediaMessageResolver(createMessageConverter())); + registrar.setCustomMethodArgumentResolvers(new ResolvableTypeResolver(createMessageConverter())); } } From db96fb9172f5e13009b6aee5269eb467c209e02c Mon Sep 17 00:00:00 2001 From: scruel Date: Wed, 5 Jan 2022 08:30:17 +0800 Subject: [PATCH 4/7] Remove @JsonDeserialize annotation --- .../kafka/support/resolver/ResolvableTypeResolverTests.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java index 22dba37c64..fe31f60dce 100644 --- a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java +++ b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java @@ -144,7 +144,7 @@ protected MappingJackson2MessageConverter createJacksonConverter() { } @Override - public void configureKafkaListeners(@JsonDeserialize KafkaListenerEndpointRegistrar registrar) { + public void configureKafkaListeners(KafkaListenerEndpointRegistrar registrar) { registrar.setCustomMethodArgumentResolvers(new ResolvableTypeResolver(createMessageConverter())); } } From 9538b006c74f09eaebde787c2a9c11b5bd48a455 Mon Sep 17 00:00:00 2001 From: scruel Date: Wed, 5 Jan 2022 08:31:48 +0800 Subject: [PATCH 5/7] Replace wildcard imports with single class imports --- .../springframework/kafka/annotation/ResolvableType.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java index 947d2119e8..94f4a55f25 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java @@ -18,7 +18,11 @@ import org.springframework.util.MimeTypeUtils; -import java.lang.annotation.*; +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** * Used to define the content type of {@code Message} with {@code MediaMessageResolver}. From a18ce5831ea5eae4b6de3f887b2766c5a4621531 Mon Sep 17 00:00:00 2001 From: scruel Date: Wed, 5 Jan 2022 08:32:42 +0800 Subject: [PATCH 6/7] Replace wildcard imports with single class imports --- .../support/resolver/ResolvableTypeResolverTests.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java index fe31f60dce..a5db714a59 100644 --- a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java +++ b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java @@ -28,7 +28,13 @@ import org.springframework.kafka.annotation.ResolvableType; import org.springframework.kafka.config.KafkaListenerEndpointRegistrar; import org.springframework.messaging.MessageHeaders; -import org.springframework.messaging.converter.*; +import org.springframework.messaging.converter.ByteArrayMessageConverter; +import org.springframework.messaging.converter.CompositeMessageConverter; +import org.springframework.messaging.converter.DefaultContentTypeResolver; +import org.springframework.messaging.converter.MappingJackson2MessageConverter; +import org.springframework.messaging.converter.MessageConversionException; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.converter.StringMessageConverter; import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory; import org.springframework.messaging.handler.invocation.InvocableHandlerMethod; import org.springframework.messaging.support.GenericMessage; From a934304072b997ac1c815d7d304cf05dd12dcdee Mon Sep 17 00:00:00 2001 From: scruel Date: Wed, 5 Jan 2022 08:43:15 +0800 Subject: [PATCH 7/7] Rename @MediaMessage to @ResolvableType --- .../org/springframework/kafka/annotation/ResolvableType.java | 2 +- .../kafka/support/resolver/ResolvableTypeResolver.java | 4 ++-- .../kafka/support/resolver/ResolvableTypeResolverTests.java | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java index 94f4a55f25..ef349835fd 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/annotation/ResolvableType.java @@ -25,7 +25,7 @@ import java.lang.annotation.Target; /** - * Used to define the content type of {@code Message} with {@code MediaMessageResolver}. + * Used to define the content type of {@code Message} with {@code ResolvableTypeResolver}. * * @author Scruel Tao */ diff --git a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java index df5e2e37f7..dc8c320fd3 100644 --- a/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java +++ b/spring-kafka/src/main/java/org/springframework/kafka/support/resolver/ResolvableTypeResolver.java @@ -26,13 +26,13 @@ /** * A resolver to extract and convert the payload of a message using a MessageConverter. - * This HandlerMethodArgumentResolver only work with MediaMessage annotation now. + * This HandlerMethodArgumentResolver only work with ResolvableType annotation now. * * @author Scruel Tao */ public class ResolvableTypeResolver extends PayloadMethodArgumentResolver { /** - * Create a new {@code MediaMessageResolver} with the given + * Create a new {@code ResolvableTypeResolver} with the given * {@link MessageConverter}. * * @param messageConverter the MessageConverter to use (required) diff --git a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java index a5db714a59..2a2272b468 100644 --- a/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java +++ b/spring-kafka/src/test/java/org/springframework/kafka/support/resolver/ResolvableTypeResolverTests.java @@ -127,14 +127,14 @@ public Map getBeansOfType(Class type) throws BeansException { return new HashMap<>() { { if (KafkaListenerConfigurer.class.equals(type)) { - put("bean", (T) new MediaMessageConfig()); + put("bean", (T) new ResolvableTypeConfig()); } } }; } } - static class MediaMessageConfig implements KafkaListenerConfigurer { + static class ResolvableTypeConfig implements KafkaListenerConfigurer { public CompositeMessageConverter createMessageConverter() { List converters = new ArrayList<>(); converters.add(new StringMessageConverter());