root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 10 Packages Projects Releases Wiki Activity

Polishing 

Closes gh-29768
This commit is contained in:
rstoyanchev 2023-06-20 17:15:32 +01:00
parent b677ff20fe
commit db19f6395d
3 changed files with 37 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
spring-messaging/src/main/java/org/springframework/messaging/converter/AbstractMessageConverter.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2021 the original author or authors. * Copyright 2002-2023 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -63,15 +63,13 @@ public abstract class AbstractMessageConverter implements SmartMessageConverter
/** /**
* Constructor with a single MIME type. * Constructor with a single MIME type.
* @param supportedMimeType the supported MIME type
*/ */
protected AbstractMessageConverter(MimeType supportedMimeType) { protected AbstractMessageConverter(MimeType supportedMimeType) {
this(Collections.singletonList(supportedMimeType)); this(Collections.singletonList(supportedMimeType));
} }
/** /**
* Constructor with one or more MIME types via vararg. * Constructor with multiple MIME types.
* @param supportedMimeTypes the supported MIME types
* @since 5.2.2 * @since 5.2.2
*/ */
protected AbstractMessageConverter(MimeType... supportedMimeTypes) { protected AbstractMessageConverter(MimeType... supportedMimeTypes) {
@ -79,8 +77,7 @@ public abstract class AbstractMessageConverter implements SmartMessageConverter
} }
/** /**
* Constructor with a Collection of MIME types. * Constructor with Collection of MIME types.
* @param supportedMimeTypes the supported MIME types
*/ */
protected AbstractMessageConverter(Collection<MimeType> supportedMimeTypes) { protected AbstractMessageConverter(Collection<MimeType> supportedMimeTypes) {
this.supportedMimeTypes.addAll(supportedMimeTypes); this.supportedMimeTypes.addAll(supportedMimeTypes);
@ -103,20 +100,21 @@ public abstract class AbstractMessageConverter implements SmartMessageConverter
} }
/** /**
* Configure the {@link ContentTypeResolver} to use to resolve the content * Configure a {@link ContentTypeResolver} for resolving the content type
* type of an input message. * of input messages.
* <p>Note that if no resolver is configured, then
* {@link #setStrictContentTypeMatch(boolean) strictContentTypeMatch} should
* be left as {@code false} (the default) or otherwise this converter will
* ignore all messages.
* <p>By default, a {@code DefaultContentTypeResolver} instance is used. * <p>By default, a {@code DefaultContentTypeResolver} instance is used.
* <p><strong>Note:</strong> if the resolver is set to {@code null}, then
* {@link #setStrictContentTypeMatch(boolean) strictContentTypeMatch} should
* be {@code false}, which is the default, or otherwise this converter will
* ignore all messages.
*/ */
public void setContentTypeResolver(@Nullable ContentTypeResolver resolver) { public void setContentTypeResolver(@Nullable ContentTypeResolver resolver) {
this.contentTypeResolver = resolver; this.contentTypeResolver = resolver;
} }
/** /**
* Return the configured {@link ContentTypeResolver}. * Return the {@link #setContentTypeResolver(ContentTypeResolver) configured}
* {@code ContentTypeResolver}.
*/ */
@Nullable @Nullable
public ContentTypeResolver getContentTypeResolver() { public ContentTypeResolver getContentTypeResolver() {
@ -125,11 +123,11 @@ public abstract class AbstractMessageConverter implements SmartMessageConverter
/** /**
* Whether this converter should convert messages for which no content type * Whether this converter should convert messages for which no content type
* could be resolved through the configured * can be resolved through the configured
* {@link org.springframework.messaging.converter.ContentTypeResolver}. * {@link org.springframework.messaging.converter.ContentTypeResolver}.
* <p>A converter can be configured to be strict only when a * <p>A converter can be configured to be strict only when a
* {@link #setContentTypeResolver contentTypeResolver} is configured and the * {@link #setContentTypeResolver contentTypeResolver} is configured and the
* list of {@link #getSupportedMimeTypes() supportedMimeTypes} is not be empty. * list of {@link #getSupportedMimeTypes() supportedMimeTypes} is not empty.
* <p>When this flag is set to {@code true}, {@link #supportsMimeType(MessageHeaders)} * <p>When this flag is set to {@code true}, {@link #supportsMimeType(MessageHeaders)}
* will return {@code false} if the {@link #setContentTypeResolver contentTypeResolver} * will return {@code false} if the {@link #setContentTypeResolver contentTypeResolver}
* is not defined or if no content-type header is present. * is not defined or if no content-type header is present.
@ -193,7 +191,9 @@ public abstract class AbstractMessageConverter implements SmartMessageConverter
@Override @Override
@Nullable @Nullable
public final Message<?> toMessage(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) { public final Message<?> toMessage(
Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) {
if (!canConvertTo(payload, headers)) { if (!canConvertTo(payload, headers)) {
return null; return null;
} }

49
spring-messaging/src/test/java/org/springframework/messaging/converter/DefaultContentTypeResolverTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2020 the original author or authors. * Copyright 2002-2023 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -17,10 +17,8 @@
package org.springframework.messaging.converter; package org.springframework.messaging.converter;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.messaging.MessageHeaders; import org.springframework.messaging.MessageHeaders;
@ -32,67 +30,50 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
/** /**
* Test fixture for {@link org.springframework.messaging.converter.DefaultContentTypeResolver}. * Unit tests for
* {@link org.springframework.messaging.converter.DefaultContentTypeResolver}.
* *
* @author Rossen Stoyanchev * @author Rossen Stoyanchev
*/ */
public class DefaultContentTypeResolverTests { public class DefaultContentTypeResolverTests {
private DefaultContentTypeResolver resolver; private final DefaultContentTypeResolver resolver = new DefaultContentTypeResolver();
@BeforeEach
public void setup() {
this.resolver = new DefaultContentTypeResolver();
}
@Test @Test
public void resolve() { public void resolve() {
Map<String, Object> map = new HashMap<>(); MessageHeaders headers = headers(MimeTypeUtils.APPLICATION_JSON);
map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON);
MessageHeaders headers = new MessageHeaders(map);
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON); assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
} }
@Test @Test
public void resolveStringContentType() { public void resolveStringContentType() {
Map<String, Object> map = new HashMap<>(); MessageHeaders headers = headers(MimeTypeUtils.APPLICATION_JSON_VALUE);
map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON_VALUE);
MessageHeaders headers = new MessageHeaders(map);
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON); assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
} }
@Test @Test
public void resolveInvalidStringContentType() { public void resolveInvalidStringContentType() {
Map<String, Object> map = new HashMap<>(); MessageHeaders headers = headers("invalidContentType");
map.put(MessageHeaders.CONTENT_TYPE, "invalidContentType"); assertThatExceptionOfType(InvalidMimeTypeException.class).isThrownBy(() -> this.resolver.resolve(headers));
MessageHeaders headers = new MessageHeaders(map);
assertThatExceptionOfType(InvalidMimeTypeException.class).isThrownBy(() ->
this.resolver.resolve(headers));
} }
@Test @Test
public void resolveUnknownHeaderType() { public void resolveUnknownHeaderType() {
Map<String, Object> map = new HashMap<>(); MessageHeaders headers = headers(1);
map.put(MessageHeaders.CONTENT_TYPE, 1); assertThatIllegalArgumentException().isThrownBy(() -> this.resolver.resolve(headers));
MessageHeaders headers = new MessageHeaders(map);
assertThatIllegalArgumentException().isThrownBy(() ->
this.resolver.resolve(headers));
} }
@Test @Test
public void resolveNoContentTypeHeader() { public void resolveNoContentTypeHeader() {
MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap()); MessageHeaders headers = new MessageHeaders(Collections.emptyMap());
assertThat(this.resolver.resolve(headers)).isNull(); assertThat(this.resolver.resolve(headers)).isNull();
} }
@Test @Test
public void resolveDefaultMimeType() { public void resolveDefaultMimeType() {
this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON); this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON);
MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap()); MessageHeaders headers = new MessageHeaders(Collections.emptyMap());
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON); assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
} }
@ -100,9 +81,11 @@ public class DefaultContentTypeResolverTests {
@Test @Test
public void resolveDefaultMimeTypeWithNoHeader() { public void resolveDefaultMimeTypeWithNoHeader() {
this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON); this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON);
MessageHeaders headers = null; assertThat(this.resolver.resolve(null)).isEqualTo(MimeTypeUtils.APPLICATION_JSON);
}
assertThat(this.resolver.resolve(headers)).isEqualTo(MimeTypeUtils.APPLICATION_JSON); private MessageHeaders headers(Object mimeType) {
return new MessageHeaders(Map.of(MessageHeaders.CONTENT_TYPE, mimeType));
} }
} }

13
spring-messaging/src/test/java/org/springframework/messaging/converter/MessageConverterTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2019 the original author or authors. * Copyright 2002-2023 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -138,10 +138,11 @@ public class MessageConverterTests {
assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN); assertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
} }
@Test @Test // gh-29768
public void toMessageDefaultContentType() { public void toMessageDefaultContentType() {
DefaultContentTypeResolver resolver = new DefaultContentTypeResolver(); DefaultContentTypeResolver resolver = new DefaultContentTypeResolver();
resolver.setDefaultMimeType(MimeTypeUtils.TEXT_PLAIN); resolver.setDefaultMimeType(MimeTypeUtils.TEXT_PLAIN);
TestMessageConverter converter = new TestMessageConverter(); TestMessageConverter converter = new TestMessageConverter();
converter.setContentTypeResolver(resolver); converter.setContentTypeResolver(resolver);
converter.setStrictContentTypeMatch(true); converter.setStrictContentTypeMatch(true);
@ -167,16 +168,12 @@ public class MessageConverterTests {
} }
@Override @Override
protected Object convertFromInternal( protected Object convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object hint) {
Message<?> message, Class<?> targetClass, @Nullable Object conversionHint) {
return "success-from"; return "success-from";
} }
@Override @Override
protected Object convertToInternal( protected Object convertToInternal(Object payload, @Nullable MessageHeaders headers, @Nullable Object hint) {
Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) {
return "success-to"; return "success-to";
} }
} }