Add spring.webflux.multipart configuration properties

See gh-26254

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/reactive/ReactiveMultipartAutoConfiguration.java

@@ -0,0 +1,80 @@
+package org.springframework.boot.autoconfigure.web.reactive;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Paths;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.context.properties.PropertyMapper;
+import org.springframework.boot.web.codec.CodecCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.codec.CodecConfigurer;
+import org.springframework.http.codec.multipart.DefaultPartHttpMessageReader;
+import org.springframework.util.unit.DataSize;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for multipart support in Spring
+ * Webflux.
+ * <p>
+ * Configures the {@link DefaultPartHttpMessageReader} via a {@link CodecCustomizer}.
+ *
+ * @author Chris Bono
+ * @since 2.6.0
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ CodecConfigurer.class, DefaultPartHttpMessageReader.class })
+@ConditionalOnWebApplication(type = Type.REACTIVE)
+@EnableConfigurationProperties(ReactiveMultipartProperties.class)
+class ReactiveMultipartAutoConfiguration {
+
+	@Bean
+	@Order(1)
+	CodecCustomizer defaultPartHttpMessageReaderCustomizer(ReactiveMultipartProperties multipartProperties) {
+		return (configurer) -> configurer.defaultCodecs().configureDefaultCodec((codec) -> {
+			if (!DefaultPartHttpMessageReader.class.isInstance(codec)) {
+				return;
+			}
+			DefaultPartHttpMessageReader defaultPartHttpMessageReader = (DefaultPartHttpMessageReader) codec;
+			boolean streaming = multipartProperties.getStreaming() != null && multipartProperties.getStreaming();
+			boolean unlimitedMaxMemorySize = multipartProperties.getMaxInMemorySize() != null
+					&& multipartProperties.getMaxInMemorySize().toBytes() == -1;
+			PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
+			map.from(multipartProperties::getStreaming).to(defaultPartHttpMessageReader::setStreaming);
+			if (!streaming) {
+				map.from(multipartProperties::getMaxInMemorySize).asInt(this::convertToBytes)
+						.to(defaultPartHttpMessageReader::setMaxInMemorySize);
+			}
+			if (!streaming && !unlimitedMaxMemorySize) {
+				map.from(multipartProperties::getMaxDiskUsagePerPart).as(this::convertToBytes)
+						.to(defaultPartHttpMessageReader::setMaxDiskUsagePerPart);
+				map.from(multipartProperties::getFileStorageDirectory)
+						.to(dir -> setFileStorageDirectory(dir, defaultPartHttpMessageReader));
+			}
+			map.from(multipartProperties::getMaxParts).to(defaultPartHttpMessageReader::setMaxParts);
+			map.from(multipartProperties::getMaxHeadersSize).asInt(this::convertToBytes)
+					.to(defaultPartHttpMessageReader::setMaxHeadersSize);
+			map.from(multipartProperties::getHeadersCharset).to(defaultPartHttpMessageReader::setHeadersCharset);
+		});
+	}
+
+	private void setFileStorageDirectory(String fileStorageDirectory,
+			DefaultPartHttpMessageReader defaultPartHttpMessageReader) {
+		try {
+			defaultPartHttpMessageReader.setFileStorageDirectory(Paths.get(fileStorageDirectory));
+		}
+		catch (IOException ex) {
+			throw new UncheckedIOException(ex);
+		}
+	}
+
+	private Long convertToBytes(DataSize size) {
+		return (size != null) ? size.toBytes() : null;
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/reactive/ReactiveMultipartProperties.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2012-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.boot.autoconfigure.web.reactive;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.http.codec.multipart.DefaultPartHttpMessageReader;
+import org.springframework.util.unit.DataSize;
+
+/**
+ * {@link ConfigurationProperties Configuration properties} for configuring multipart
+ * support in Spring Webflux. Used to configure the {@link DefaultPartHttpMessageReader}.
+ *
+ * @author Chris Bono
+ * @since 2.6.0
+ */
+@ConfigurationProperties(prefix = "spring.webflux.multipart")
+public class ReactiveMultipartProperties {
+
+	/**
+	 * Maximum amount of memory allowed per part. Set to -1 to store all contents in
+	 * memory. Ignored when streaming is enabled.
+	 */
+	private DataSize maxInMemorySize = DataSize.ofKilobytes(256);
+
+	/**
+	 * Maximum amount of memory allowed per headers section of each part. Set to -1 to
+	 * enforce no limits.
+	 */
+	private DataSize maxHeadersSize = DataSize.ofKilobytes(8);
+
+	/**
+	 * Maximum amount of disk space allowed per part. Default is -1 which enforces no
+	 * limits. Ignored when streaming is enabled or 'maxInMemorySize' is set to -1.
+	 */
+	private DataSize maxDiskUsagePerPart = DataSize.ofBytes(-1);
+
+	/**
+	 * Maximum number of parts allowed in a given multipart request. Default is -1 which
+	 * enforces no limits.
+	 */
+	private Integer maxParts = -1;
+
+	/**
+	 * Whether or not to stream directly from the parsed input buffer stream without
+	 * storing in memory nor file. Default is non-streaming.
+	 */
+	private Boolean streaming = Boolean.FALSE;
+
+	/**
+	 * Directory used to store parts larger than 'maxInMemorySize'. Default is a directory
+	 * named 'spring-multipart' created under the system temporary directory. Ignored when
+	 * streaming is enabled or 'maxInMemorySize' is set to -1.
+	 */
+	private String fileStorageDirectory;
+
+	/**
+	 * Character set used to decode headers.
+	 */
+	private Charset headersCharset = StandardCharsets.UTF_8;
+
+	public DataSize getMaxInMemorySize() {
+		return maxInMemorySize;
+	}
+
+	public void setMaxInMemorySize(DataSize maxInMemorySize) {
+		this.maxInMemorySize = maxInMemorySize;
+	}
+
+	public DataSize getMaxHeadersSize() {
+		return maxHeadersSize;
+	}
+
+	public void setMaxHeadersSize(DataSize maxHeadersSize) {
+		this.maxHeadersSize = maxHeadersSize;
+	}
+
+	public DataSize getMaxDiskUsagePerPart() {
+		return maxDiskUsagePerPart;
+	}
+
+	public void setMaxDiskUsagePerPart(DataSize maxDiskUsagePerPart) {
+		this.maxDiskUsagePerPart = maxDiskUsagePerPart;
+	}
+
+	public Integer getMaxParts() {
+		return maxParts;
+	}
+
+	public void setMaxParts(Integer maxParts) {
+		this.maxParts = maxParts;
+	}
+
+	public Boolean getStreaming() {
+		return streaming;
+	}
+
+	public void setStreaming(Boolean streaming) {
+		this.streaming = streaming;
+	}
+
+	public String getFileStorageDirectory() {
+		return fileStorageDirectory;
+	}
+
+	public void setFileStorageDirectory(String fileStorageDirectory) {
+		this.fileStorageDirectory = fileStorageDirectory;
+	}
+
+	public Charset getHeadersCharset() {
+		return headersCharset;
+	}
+
+	public void setHeadersCharset(Charset headersCharset) {
+		this.headersCharset = headersCharset;
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/reactive/WebFluxAutoConfiguration.java

@@ -91,6 +91,7 @@ import org.springframework.web.server.session.WebSessionManager;
  * @author Phillip Webb
  * @author Eddú Meléndez
  * @author Artsiom Yudovin
+ * @author Chris Bono
  * @since 2.0.0
  */
 @Configuration(proxyBeanMethods = false)
@@ -98,7 +99,7 @@ import org.springframework.web.server.session.WebSessionManager;
 @ConditionalOnClass(WebFluxConfigurer.class)
 @ConditionalOnMissingBean({ WebFluxConfigurationSupport.class })
 @AutoConfigureAfter({ ReactiveWebServerFactoryAutoConfiguration.class, CodecsAutoConfiguration.class,
-		ValidationAutoConfiguration.class })
+		ReactiveMultipartAutoConfiguration.class, ValidationAutoConfiguration.class })
 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
 public class WebFluxAutoConfiguration {
 

spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

@@ -139,6 +139,7 @@ org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,
 org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
+org.springframework.boot.autoconfigure.web.reactive.ReactiveMultipartAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
 org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/reactive/ReactiveMultipartAutoConfigurationTests.java

@@ -0,0 +1,251 @@
+/*
+ * Copyright 2012-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.boot.autoconfigure.web.reactive;
+
+import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.assertj.core.api.InstanceOfAssertFactories;
+import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Mono;
+
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.test.context.FilteredClassLoader;
+import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner;
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
+import org.springframework.boot.web.codec.CodecCustomizer;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.http.codec.CodecConfigurer;
+import org.springframework.http.codec.multipart.DefaultPartHttpMessageReader;
+import org.springframework.http.codec.support.DefaultServerCodecConfigurer;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.util.unit.DataSize;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link ReactiveMultipartAutoConfiguration}.
+ *
+ * @author Chris Bono
+ */
+class ReactiveMultipartAutoConfigurationTests {
+
+	private final ReactiveWebApplicationContextRunner contextRunner = new ReactiveWebApplicationContextRunner()
+			.withConfiguration(AutoConfigurations.of(ReactiveMultipartAutoConfiguration.class));
+
+	private static final boolean DEFAULT_STREAMING = false;
+
+	private static final int DEFAULT_MAX_IN_MEMORY_SIZE = 256 * 1024;
+
+	private static final int DEFAULT_MAX_PARTS = -1;
+
+	private static final int DEFAULT_MAX_HEADERS_SIZE = 8 * 1024;
+
+	private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
+
+	private static final long DEFAULT_MAX_DISK_USAGE_PER_PART = -1;
+
+	private static final Path DEFAULT_FILE_STORAGE_DIRECTORY = Paths.get(System.getProperty("java.io.tmpdir"),
+			"spring-multipart");
+
+	@Test
+	void shouldNotProvideCustomizerForNonReactiveApp() {
+		new WebApplicationContextRunner()
+				.withConfiguration(AutoConfigurations.of(ReactiveMultipartAutoConfiguration.class))
+				.run((context) -> assertThat(context).doesNotHaveBean(CodecCustomizer.class));
+	}
+
+	@Test
+	void shouldNotProvideCustomizerWhenDefaultPartHttpMessageReaderNotAvailable() {
+		this.contextRunner.withClassLoader(new FilteredClassLoader(DefaultPartHttpMessageReader.class))
+				.run((context) -> assertThat(context).doesNotHaveBean(CodecCustomizer.class));
+	}
+
+	@Test
+	void shouldNotProvideCustomizerWhenCodecConfigurerNotAvailable() {
+		this.contextRunner.withClassLoader(new FilteredClassLoader(CodecConfigurer.class))
+				.run((context) -> assertThat(context).doesNotHaveBean(CodecCustomizer.class));
+	}
+
+	@Test
+	void customizerSetsAppropriatePropsWhenStreamingEnabled() {
+		this.contextRunner.withPropertyValues("spring.webflux.multipart.streaming:true",
+				"spring.webflux.multipart.max-in-memory-size=1GB", "spring.webflux.multipart.max-headers-size=512MB",
+				"spring.webflux.multipart.max-disk-usage-per-part=100MB", "spring.webflux.multipart.max-parts=7",
+				"spring.webflux.multipart.file-storage-directory:.", "spring.webflux.multipart.headers-charset:UTF_16")
+				.run((context) -> {
+					CodecCustomizer customizer = context.getBean(CodecCustomizer.class);
+					DefaultServerCodecConfigurer configurer = new DefaultServerCodecConfigurer();
+					customizer.customize(configurer);
+					DefaultPartHttpMessageReader partReader = getPartReader(configurer);
+
+					// always set
+					assertThat(partReader).hasFieldOrPropertyWithValue("streaming", true);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxParts", 7);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxHeadersSize",
+							toIntBytes(DataSize.ofMegabytes(512)));
+					assertThat(partReader).hasFieldOrPropertyWithValue("headersCharset", StandardCharsets.UTF_16);
+
+					// never set when streaming
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxInMemorySize", DEFAULT_MAX_IN_MEMORY_SIZE);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart",
+							DEFAULT_MAX_DISK_USAGE_PER_PART);
+					assertThat(partReader).extracting("fileStorageDirectory")
+							.asInstanceOf(InstanceOfAssertFactories.type(Mono.class))
+							.returns(DEFAULT_FILE_STORAGE_DIRECTORY, Mono<Path>::block);
+				});
+	}
+
+	@Test
+	void customizerSetsAppropriatePropsWhenStreamingDisabledWithUnlimitedMemorySize() {
+		this.contextRunner.withPropertyValues("spring.webflux.multipart.streaming:false",
+				"spring.webflux.multipart.max-in-memory-size=-1", "spring.webflux.multipart.max-headers-size=512MB",
+				"spring.webflux.multipart.max-disk-usage-per-part=100MB", "spring.webflux.multipart.max-parts=7",
+				"spring.webflux.multipart.file-storage-directory:.", "spring.webflux.multipart.headers-charset:UTF_16")
+				.run((context) -> {
+
+					CodecCustomizer customizer = context.getBean(CodecCustomizer.class);
+					DefaultServerCodecConfigurer configurer = new DefaultServerCodecConfigurer();
+					customizer.customize(configurer);
+					DefaultPartHttpMessageReader partReader = getPartReader(configurer);
+
+					// always set
+					assertThat(partReader).hasFieldOrPropertyWithValue("streaming", false);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxParts", 7);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxHeadersSize",
+							toIntBytes(DataSize.ofMegabytes(512)));
+					assertThat(partReader).hasFieldOrPropertyWithValue("headersCharset", StandardCharsets.UTF_16);
+
+					// set when not streaming w/ unlimited memory size
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxInMemorySize", -1);
+
+					// never set when not streaming w/ unlimited memory size
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart",
+							DEFAULT_MAX_DISK_USAGE_PER_PART);
+					assertThat(partReader).extracting("fileStorageDirectory")
+							.asInstanceOf(InstanceOfAssertFactories.type(Mono.class))
+							.returns(DEFAULT_FILE_STORAGE_DIRECTORY, Mono<Path>::block);
+				});
+	}
+
+	@Test
+	void customizerSetsAppropriatePropsWhenStreamingDisabledWithLimitedMemorySize() {
+		this.contextRunner.withPropertyValues("spring.webflux.multipart.streaming:false",
+				"spring.webflux.multipart.max-in-memory-size=1GB", "spring.webflux.multipart.max-headers-size=512MB",
+				"spring.webflux.multipart.max-disk-usage-per-part=100MB", "spring.webflux.multipart.max-parts=7",
+				"spring.webflux.multipart.file-storage-directory:.", "spring.webflux.multipart.headers-charset:UTF_16")
+				.run((context) -> {
+
+					CodecCustomizer customizer = context.getBean(CodecCustomizer.class);
+					DefaultServerCodecConfigurer configurer = new DefaultServerCodecConfigurer();
+					customizer.customize(configurer);
+					DefaultPartHttpMessageReader partReader = getPartReader(configurer);
+
+					// always set
+					assertThat(partReader).hasFieldOrPropertyWithValue("streaming", false);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxParts", 7);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxHeadersSize",
+							toIntBytes(DataSize.ofMegabytes(512)));
+					assertThat(partReader).hasFieldOrPropertyWithValue("headersCharset", StandardCharsets.UTF_16);
+
+					// set when not streaming w/ limited memory size
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxInMemorySize",
+							toIntBytes(DataSize.ofGigabytes(1)));
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart",
+							DataSize.ofMegabytes(100).toBytes());
+					assertThat(partReader).extracting("fileStorageDirectory")
+							.asInstanceOf(InstanceOfAssertFactories.type(Mono.class))
+							.returns(Paths.get("."), Mono<Path>::block);
+				});
+	}
+
+	@Test
+	void customizerSetsDefaultPropsWhenNoPropertiesAreSet() {
+		this.contextRunner.run((context) -> {
+			CodecCustomizer customizer = context.getBean(CodecCustomizer.class);
+			DefaultServerCodecConfigurer configurer = new DefaultServerCodecConfigurer();
+			customizer.customize(configurer);
+			DefaultPartHttpMessageReader partReader = getPartReader(configurer);
+			assertThat(partReader).hasFieldOrPropertyWithValue("streaming", DEFAULT_STREAMING);
+			assertThat(partReader).hasFieldOrPropertyWithValue("maxParts", DEFAULT_MAX_PARTS);
+			assertThat(partReader).hasFieldOrPropertyWithValue("maxHeadersSize", DEFAULT_MAX_HEADERS_SIZE);
+			assertThat(partReader).hasFieldOrPropertyWithValue("headersCharset", DEFAULT_CHARSET);
+			assertThat(partReader).hasFieldOrPropertyWithValue("maxInMemorySize", DEFAULT_MAX_IN_MEMORY_SIZE);
+			assertThat(partReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart", DEFAULT_MAX_DISK_USAGE_PER_PART);
+			assertThat(partReader).extracting("fileStorageDirectory")
+					.asInstanceOf(InstanceOfAssertFactories.type(Mono.class))
+					.returns(DEFAULT_FILE_STORAGE_DIRECTORY, Mono<Path>::block);
+		});
+	}
+
+	@Test
+	void customizerSetsDefaultPropsWhenDefaultsAreExplicitlySet() {
+		this.contextRunner.withPropertyValues("spring.webflux.multipart.streaming:false",
+				"spring.webflux.multipart.max-in-memory-size=256KB", "spring.webflux.multipart.max-headers-size=8KB",
+				"spring.webflux.multipart.max-disk-usage-per-part=-1", "spring.webflux.multipart.max-parts=-1",
+				"spring.webflux.multipart.file-storage-directory:" + DEFAULT_FILE_STORAGE_DIRECTORY,
+				"spring.webflux.multipart.headers-charset:" + DEFAULT_CHARSET).run((context) -> {
+					CodecCustomizer customizer = context.getBean(CodecCustomizer.class);
+					DefaultServerCodecConfigurer configurer = new DefaultServerCodecConfigurer();
+					customizer.customize(configurer);
+					DefaultPartHttpMessageReader partReader = getPartReader(configurer);
+					assertThat(partReader).hasFieldOrPropertyWithValue("streaming", DEFAULT_STREAMING);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxParts", DEFAULT_MAX_PARTS);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxHeadersSize", DEFAULT_MAX_HEADERS_SIZE);
+					assertThat(partReader).hasFieldOrPropertyWithValue("headersCharset", DEFAULT_CHARSET);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxInMemorySize", DEFAULT_MAX_IN_MEMORY_SIZE);
+					assertThat(partReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart",
+							DEFAULT_MAX_DISK_USAGE_PER_PART);
+					assertThat(partReader).extracting("fileStorageDirectory")
+							.asInstanceOf(InstanceOfAssertFactories.type(Mono.class))
+							.returns(DEFAULT_FILE_STORAGE_DIRECTORY, Mono<Path>::block);
+				});
+	}
+
+	@Test
+	void customizerBeanShouldHaveOrderOne() {
+		this.contextRunner.run((context) -> {
+			Method customizerMethod = ReflectionUtils.findMethod(ReactiveMultipartAutoConfiguration.class,
+					"defaultPartHttpMessageReaderCustomizer", ReactiveMultipartProperties.class);
+			Integer order = new TestAnnotationAwareOrderComparator().findOrder(customizerMethod);
+			assertThat(order).isEqualTo(1);
+		});
+	}
+
+	private DefaultPartHttpMessageReader getPartReader(DefaultServerCodecConfigurer codecConfigurer) {
+		return codecConfigurer.getReaders().stream().filter(DefaultPartHttpMessageReader.class::isInstance)
+				.map(DefaultPartHttpMessageReader.class::cast).findFirst()
+				.orElseThrow(() -> new IllegalStateException("Could not find DefaultPartHttpMessageReader"));
+	}
+
+	private Integer toIntBytes(DataSize size) {
+		return (size != null) ? (int) size.toBytes() : null;
+	}
+
+	static class TestAnnotationAwareOrderComparator extends AnnotationAwareOrderComparator {
+
+		@Override
+		public Integer findOrder(Object obj) {
+			return super.findOrder(obj);
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/reactive/ReactiveMultipartPropertiesTests.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012-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.boot.autoconfigure.web.reactive;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.http.codec.multipart.DefaultPartHttpMessageReader;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link ReactiveMultipartProperties}
+ *
+ * @author Chris Bono
+ */
+class ReactiveMultipartPropertiesTests {
+
+	@Test
+	void defaultValuesAreConsistent() {
+		ReactiveMultipartProperties multipartProperties = new ReactiveMultipartProperties();
+		DefaultPartHttpMessageReader defaultPartHttpMessageReader = new DefaultPartHttpMessageReader();
+		assertThat(defaultPartHttpMessageReader).hasFieldOrPropertyWithValue("streaming",
+				multipartProperties.getStreaming());
+		assertThat(defaultPartHttpMessageReader).hasFieldOrPropertyWithValue("maxInMemorySize",
+				(int) multipartProperties.getMaxInMemorySize().toBytes());
+		assertThat(defaultPartHttpMessageReader).hasFieldOrPropertyWithValue("maxHeadersSize",
+				(int) multipartProperties.getMaxHeadersSize().toBytes());
+		assertThat(defaultPartHttpMessageReader).hasFieldOrPropertyWithValue("maxDiskUsagePerPart",
+				multipartProperties.getMaxDiskUsagePerPart().toBytes());
+		assertThat(defaultPartHttpMessageReader).hasFieldOrPropertyWithValue("maxParts",
+				multipartProperties.getMaxParts());
+	}
+
+}