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

Add register methods to CodecConfigurer.CustomCodecs 

The new register methods replace the now deprecated
encoder, decoder, reader, and writer methods, and also offer a choice
to opt into default properties such maxInMemorySize, if configured.

See gh-24124
This commit is contained in:
Rossen Stoyanchev 2019-12-12 18:06:12 +00:00
parent 9d65830133
commit 11e321b8e7
7 changed files with 220 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
spring-web/src/main/java/org/springframework/http/codec/CodecConfigurer.java
View File

@ -191,18 +191,66 @@ public interface CodecConfigurer {
*/ */
interface CustomCodecs { interface CustomCodecs {
/**
* Register a custom codec. This is expected to be one of the following:
* <ul>
* <li>{@link HttpMessageReader}
* <li>{@link HttpMessageWriter}
* <li>{@link Encoder} (wrapped internally with {@link EncoderHttpMessageWriter})
* <li>{@link Decoder} (wrapped internally with {@link DecoderHttpMessageReader})
* </ul>
* @param codec the codec to register
* @since 5.2.3
*/
void register(Object codec);
/**
* Variant of {@link #register(Object)} that also applies the below
* properties, if configured, via {@link #defaultCodecs()}:
* <ul>
* <li>{@link CodecConfigurer.DefaultCodecs#maxInMemorySize(int) maxInMemorySize}
* <li>{@link CodecConfigurer.DefaultCodecs#enableLoggingRequestDetails(boolean) enableLoggingRequestDetails}
* </ul>
* <p>The properties are applied every time {@link #getReaders()} or
* {@link #getWriters()} are used to obtain the list of configured
* readers or writers.
* @param codec the codec to register and apply default config to
* @since 5.2.3
*/
void registerWithDefaultConfig(Object codec);
/**
* Variant of {@link #register(Object)} that also allows the caller to
* apply the properties from {@link DefaultCodecConfig} to the given
* codec. If you want to apply all the properties, prefer using
* {@link #registerWithDefaultConfig(Object)}.
* <p>The consumer is called every time {@link #getReaders()} or
* {@link #getWriters()} are used to obtain the list of configured
* readers or writers.
* @param codec the codec to register
* @param configConsumer consumer of the default config
* @since 5.2.3
*/
void registerWithDefaultConfig(Object codec, Consumer<DefaultCodecConfig> configConsumer);
/** /**
* Add a custom {@code Decoder} internally wrapped with * Add a custom {@code Decoder} internally wrapped with
* {@link DecoderHttpMessageReader}). * {@link DecoderHttpMessageReader}).
* @param decoder the decoder to add * @param decoder the decoder to add
* @deprecated as of 5.1.13, use {@link #register(Object)} or
* {@link #registerWithDefaultConfig(Object)} instead.
*/ */
@Deprecated
void decoder(Decoder<?> decoder); void decoder(Decoder<?> decoder);
/** /**
* Add a custom {@code Encoder}, internally wrapped with * Add a custom {@code Encoder}, internally wrapped with
* {@link EncoderHttpMessageWriter}. * {@link EncoderHttpMessageWriter}.
* @param encoder the encoder to add * @param encoder the encoder to add
* @deprecated as of 5.1.13, use {@link #register(Object)} or
* {@link #registerWithDefaultConfig(Object)} instead.
*/ */
@Deprecated
void encoder(Encoder<?> encoder); void encoder(Encoder<?> encoder);
/** /**
@ -210,7 +258,10 @@ public interface CodecConfigurer {
* {@link DecoderHttpMessageReader} consider using the shortcut * {@link DecoderHttpMessageReader} consider using the shortcut
* {@link #decoder(Decoder)} instead. * {@link #decoder(Decoder)} instead.
* @param reader the reader to add * @param reader the reader to add
* @deprecated as of 5.1.13, use {@link #register(Object)} or
* {@link #registerWithDefaultConfig(Object)} instead.
*/ */
@Deprecated
void reader(HttpMessageReader<?> reader); void reader(HttpMessageReader<?> reader);
/** /**
@ -218,7 +269,10 @@ public interface CodecConfigurer {
* {@link EncoderHttpMessageWriter} consider using the shortcut * {@link EncoderHttpMessageWriter} consider using the shortcut
* {@link #encoder(Encoder)} instead. * {@link #encoder(Encoder)} instead.
* @param writer the writer to add * @param writer the writer to add
* @deprecated as of 5.1.13, use {@link #register(Object)} or
* {@link #registerWithDefaultConfig(Object)} instead.
*/ */
@Deprecated
void writer(HttpMessageWriter<?> writer); void writer(HttpMessageWriter<?> writer);
/** /**
@ -227,16 +281,21 @@ public interface CodecConfigurer {
* guidelines applied to default ones, such as logging details and limiting * guidelines applied to default ones, such as logging details and limiting
* the amount of buffered data. * the amount of buffered data.
* @param codecsConfigConsumer the default codecs configuration callback * @param codecsConfigConsumer the default codecs configuration callback
* @since 5.1.12 * @deprecated as of 5.1.13, use {@link #registerWithDefaultConfig(Object)}
* or {@link #registerWithDefaultConfig(Object, Consumer)} instead.
*/ */
@Deprecated
void withDefaultCodecConfig(Consumer<DefaultCodecConfig> codecsConfigConsumer); void withDefaultCodecConfig(Consumer<DefaultCodecConfig> codecsConfigConsumer);
} }
/** /**
* Common options applied to default codecs and passed in a callback to custom codecs * Exposes the values of properties configured through
* so they get a chance to align their behavior on the default ones. * {@link #defaultCodecs()} that are applied to default codecs.
* The main purpose of this interface is to provide access to them so they
* can also be applied to custom codecs if needed.
* @since 5.1.12 * @since 5.1.12
* @see CustomCodecs#registerWithDefaultConfig(Object, Consumer)
*/ */
interface DefaultCodecConfig { interface DefaultCodecConfig {

114
spring-web/src/main/java/org/springframework/http/codec/support/BaseCodecConfigurer.java
View File

@ -17,7 +17,9 @@
package org.springframework.http.codec.support; package org.springframework.http.codec.support;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.function.Consumer; import java.util.function.Consumer;
import org.springframework.core.ResolvableType; import org.springframework.core.ResolvableType;
@ -40,8 +42,6 @@ import org.springframework.util.Assert;
*/ */
abstract class BaseCodecConfigurer implements CodecConfigurer { abstract class BaseCodecConfigurer implements CodecConfigurer {
protected boolean customCodecsInitialized;
protected final BaseDefaultCodecs defaultCodecs; protected final BaseDefaultCodecs defaultCodecs;
protected final DefaultCustomCodecs customCodecs; protected final DefaultCustomCodecs customCodecs;
@ -91,21 +91,20 @@ abstract class BaseCodecConfigurer implements CodecConfigurer {
@Override @Override
public List<HttpMessageReader<?>> getReaders() { public List<HttpMessageReader<?>> getReaders() {
initializeCustomCodecs(); this.defaultCodecs.applyDefaultConfig(this.customCodecs);
List<HttpMessageReader<?>> result = new ArrayList<>(); List<HttpMessageReader<?>> result = new ArrayList<>();
result.addAll(this.customCodecs.getTypedReaders().keySet());
result.addAll(this.customCodecs.getTypedReaders());
result.addAll(this.defaultCodecs.getTypedReaders()); result.addAll(this.defaultCodecs.getTypedReaders());
result.addAll(this.customCodecs.getObjectReaders().keySet());
result.addAll(this.customCodecs.getObjectReaders());
result.addAll(this.defaultCodecs.getObjectReaders()); result.addAll(this.defaultCodecs.getObjectReaders());
result.addAll(this.defaultCodecs.getCatchAllReaders()); result.addAll(this.defaultCodecs.getCatchAllReaders());
return result; return result;
} }
@Override @Override
public List<HttpMessageWriter<?>> getWriters() { public List<HttpMessageWriter<?>> getWriters() {
this.defaultCodecs.applyDefaultConfig(this.customCodecs);
return getWritersInternal(false); return getWritersInternal(false);
} }
@ -117,13 +116,12 @@ abstract class BaseCodecConfigurer implements CodecConfigurer {
* same except for the multipart writer itself. * same except for the multipart writer itself.
*/ */
protected List<HttpMessageWriter<?>> getWritersInternal(boolean forMultipart) { protected List<HttpMessageWriter<?>> getWritersInternal(boolean forMultipart) {
initializeCustomCodecs();
List<HttpMessageWriter<?>> result = new ArrayList<>(); List<HttpMessageWriter<?>> result = new ArrayList<>();
result.addAll(this.customCodecs.getTypedWriters()); result.addAll(this.customCodecs.getTypedWriters().keySet());
result.addAll(this.defaultCodecs.getTypedWriters(forMultipart)); result.addAll(this.defaultCodecs.getTypedWriters(forMultipart));
result.addAll(this.customCodecs.getObjectWriters()); result.addAll(this.customCodecs.getObjectWriters().keySet());
result.addAll(this.defaultCodecs.getObjectWriters(forMultipart)); result.addAll(this.defaultCodecs.getObjectWriters(forMultipart));
result.addAll(this.defaultCodecs.getCatchAllWriters()); result.addAll(this.defaultCodecs.getCatchAllWriters());
@ -133,28 +131,21 @@ abstract class BaseCodecConfigurer implements CodecConfigurer {
@Override @Override
public abstract CodecConfigurer clone(); public abstract CodecConfigurer clone();
private void initializeCustomCodecs() {
if(!this.customCodecsInitialized) {
this.customCodecs.configConsumers.forEach(consumer -> consumer.accept(this.defaultCodecs));
this.customCodecsInitialized = true;
}
}
/** /**
* Default implementation of {@code CustomCodecs}. * Default implementation of {@code CustomCodecs}.
*/ */
protected static final class DefaultCustomCodecs implements CustomCodecs { protected static final class DefaultCustomCodecs implements CustomCodecs {
private final List<HttpMessageReader<?>> typedReaders = new ArrayList<>(); private final Map<HttpMessageReader<?>, Boolean> typedReaders = new LinkedHashMap<>(4);
private final List<HttpMessageWriter<?>> typedWriters = new ArrayList<>(); private final Map<HttpMessageWriter<?>, Boolean> typedWriters = new LinkedHashMap<>(4);
private final List<HttpMessageReader<?>> objectReaders = new ArrayList<>(); private final Map<HttpMessageReader<?>, Boolean> objectReaders = new LinkedHashMap<>(4);
private final List<HttpMessageWriter<?>> objectWriters = new ArrayList<>(); private final Map<HttpMessageWriter<?>, Boolean> objectWriters = new LinkedHashMap<>(4);
private final List<Consumer<DefaultCodecConfig>> configConsumers = new ArrayList<>(); private final List<Consumer<DefaultCodecConfig>> defaultConfigConsumers = new ArrayList<>(4);
DefaultCustomCodecs() { DefaultCustomCodecs() {
} }
@ -164,56 +155,103 @@ abstract class BaseCodecConfigurer implements CodecConfigurer {
* @since 5.1.12 * @since 5.1.12
*/ */
DefaultCustomCodecs(DefaultCustomCodecs other) { DefaultCustomCodecs(DefaultCustomCodecs other) {
other.typedReaders.addAll(this.typedReaders); other.typedReaders.putAll(this.typedReaders);
other.typedWriters.addAll(this.typedWriters); other.typedWriters.putAll(this.typedWriters);
other.objectReaders.addAll(this.objectReaders); other.objectReaders.putAll(this.objectReaders);
other.objectWriters.addAll(this.objectWriters); other.objectWriters.putAll(this.objectWriters);
} }
@Override
public void register(Object codec) {
addCodec(codec, false);
}
@Override
public void registerWithDefaultConfig(Object codec) {
addCodec(codec, true);
}
@Override
public void registerWithDefaultConfig(Object codec, Consumer<DefaultCodecConfig> configConsumer) {
addCodec(codec, false);
this.defaultConfigConsumers.add(configConsumer);
}
@SuppressWarnings("deprecation")
@Override @Override
public void decoder(Decoder<?> decoder) { public void decoder(Decoder<?> decoder) {
reader(new DecoderHttpMessageReader<>(decoder)); addCodec(decoder, false);
} }
@SuppressWarnings("deprecation")
@Override @Override
public void encoder(Encoder<?> encoder) { public void encoder(Encoder<?> encoder) {
writer(new EncoderHttpMessageWriter<>(encoder)); addCodec(encoder, false);
} }
@SuppressWarnings("deprecation")
@Override @Override
public void reader(HttpMessageReader<?> reader) { public void reader(HttpMessageReader<?> reader) {
boolean canReadToObject = reader.canRead(ResolvableType.forClass(Object.class), null); addCodec(reader, false);
(canReadToObject ? this.objectReaders : this.typedReaders).add(reader);
} }
@SuppressWarnings("deprecation")
@Override @Override
public void writer(HttpMessageWriter<?> writer) { public void writer(HttpMessageWriter<?> writer) {
boolean canWriteObject = writer.canWrite(ResolvableType.forClass(Object.class), null); addCodec(writer, false);
(canWriteObject ? this.objectWriters : this.typedWriters).add(writer);
} }
@SuppressWarnings("deprecation")
@Override @Override
public void withDefaultCodecConfig(Consumer<DefaultCodecConfig> codecsConfigConsumer) { public void withDefaultCodecConfig(Consumer<DefaultCodecConfig> codecsConfigConsumer) {
this.configConsumers.add(codecsConfigConsumer); this.defaultConfigConsumers.add(codecsConfigConsumer);
}
private void addCodec(Object codec, boolean applyDefaultConfig) {
if (codec instanceof Decoder) {
codec = new DecoderHttpMessageReader<>((Decoder<?>) codec);
}
else if (codec instanceof Encoder) {
codec = new EncoderHttpMessageWriter<>((Encoder<?>) codec);
}
if (codec instanceof HttpMessageReader) {
HttpMessageReader<?> reader = (HttpMessageReader<?>) codec;
boolean canReadToObject = reader.canRead(ResolvableType.forClass(Object.class), null);
(canReadToObject ? this.objectReaders : this.typedReaders).put(reader, applyDefaultConfig);
}
else if (codec instanceof HttpMessageWriter) {
HttpMessageWriter<?> writer = (HttpMessageWriter<?>) codec;
boolean canWriteObject = writer.canWrite(ResolvableType.forClass(Object.class), null);
(canWriteObject ? this.objectWriters : this.typedWriters).put(writer, applyDefaultConfig);
}
else {
throw new IllegalArgumentException("Unexpected codec type: " + codec.getClass().getName());
}
} }
// Package private accessors... // Package private accessors...
List<HttpMessageReader<?>> getTypedReaders() { Map<HttpMessageReader<?>, Boolean> getTypedReaders() {
return this.typedReaders; return this.typedReaders;
} }
List<HttpMessageWriter<?>> getTypedWriters() { Map<HttpMessageWriter<?>, Boolean> getTypedWriters() {
return this.typedWriters; return this.typedWriters;
} }
List<HttpMessageReader<?>> getObjectReaders() { Map<HttpMessageReader<?>, Boolean> getObjectReaders() {
return this.objectReaders; return this.objectReaders;
} }
List<HttpMessageWriter<?>> getObjectWriters() { Map<HttpMessageWriter<?>, Boolean> getObjectWriters() {
return this.objectWriters; return this.objectWriters;
} }
List<Consumer<DefaultCodecConfig>> getDefaultConfigConsumers() {
return this.defaultConfigConsumers;
}
} }
} }

16
spring-web/src/main/java/org/springframework/http/codec/support/BaseDefaultCodecs.java
View File

@ -19,6 +19,7 @@ package org.springframework.http.codec.support;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map;
import org.springframework.core.codec.AbstractDataBufferDecoder; import org.springframework.core.codec.AbstractDataBufferDecoder;
import org.springframework.core.codec.ByteArrayDecoder; import org.springframework.core.codec.ByteArrayDecoder;
@ -433,6 +434,21 @@ class BaseDefaultCodecs implements CodecConfigurer.DefaultCodecs, CodecConfigure
return result; return result;
} }
void applyDefaultConfig(BaseCodecConfigurer.DefaultCustomCodecs customCodecs) {
applyDefaultConfig(customCodecs.getTypedReaders());
applyDefaultConfig(customCodecs.getObjectReaders());
applyDefaultConfig(customCodecs.getTypedWriters());
applyDefaultConfig(customCodecs.getObjectWriters());
customCodecs.getDefaultConfigConsumers().forEach(consumer -> consumer.accept(this));
}
private void applyDefaultConfig(Map<?, Boolean> readers) {
readers.entrySet().stream()
.filter(Map.Entry::getValue)
.map(Map.Entry::getKey)
.forEach(this::initCodec);
}
// Accessors for use in subclasses... // Accessors for use in subclasses...

41
spring-web/src/test/java/org/springframework/http/codec/support/CodecConfigurerTests.java
View File

@ -121,11 +121,11 @@ public class CodecConfigurerTests {
given(customReader1.canRead(ResolvableType.forClass(Object.class), null)).willReturn(false); given(customReader1.canRead(ResolvableType.forClass(Object.class), null)).willReturn(false);
given(customReader2.canRead(ResolvableType.forClass(Object.class), null)).willReturn(true); given(customReader2.canRead(ResolvableType.forClass(Object.class), null)).willReturn(true);
this.configurer.customCodecs().decoder(customDecoder1); this.configurer.customCodecs().register(customDecoder1);
this.configurer.customCodecs().decoder(customDecoder2); this.configurer.customCodecs().register(customDecoder2);
this.configurer.customCodecs().reader(customReader1); this.configurer.customCodecs().register(customReader1);
this.configurer.customCodecs().reader(customReader2); this.configurer.customCodecs().register(customReader2);
List<HttpMessageReader<?>> readers = this.configurer.getReaders(); List<HttpMessageReader<?>> readers = this.configurer.getReaders();
@ -161,11 +161,11 @@ public class CodecConfigurerTests {
given(customWriter1.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(false); given(customWriter1.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(false);
given(customWriter2.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(true); given(customWriter2.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(true);
this.configurer.customCodecs().encoder(customEncoder1); this.configurer.customCodecs().register(customEncoder1);
this.configurer.customCodecs().encoder(customEncoder2); this.configurer.customCodecs().register(customEncoder2);
this.configurer.customCodecs().writer(customWriter1); this.configurer.customCodecs().register(customWriter1);
this.configurer.customCodecs().writer(customWriter2); this.configurer.customCodecs().register(customWriter2);
List<HttpMessageWriter<?>> writers = this.configurer.getWriters(); List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
@ -200,11 +200,11 @@ public class CodecConfigurerTests {
given(customReader1.canRead(ResolvableType.forClass(Object.class), null)).willReturn(false); given(customReader1.canRead(ResolvableType.forClass(Object.class), null)).willReturn(false);
given(customReader2.canRead(ResolvableType.forClass(Object.class), null)).willReturn(true); given(customReader2.canRead(ResolvableType.forClass(Object.class), null)).willReturn(true);
this.configurer.customCodecs().decoder(customDecoder1); this.configurer.customCodecs().register(customDecoder1);
this.configurer.customCodecs().decoder(customDecoder2); this.configurer.customCodecs().register(customDecoder2);
this.configurer.customCodecs().reader(customReader1); this.configurer.customCodecs().register(customReader1);
this.configurer.customCodecs().reader(customReader2); this.configurer.customCodecs().register(customReader2);
this.configurer.registerDefaults(false); this.configurer.registerDefaults(false);
@ -231,11 +231,11 @@ public class CodecConfigurerTests {
given(customWriter1.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(false); given(customWriter1.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(false);
given(customWriter2.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(true); given(customWriter2.canWrite(ResolvableType.forClass(Object.class), null)).willReturn(true);
this.configurer.customCodecs().encoder(customEncoder1); this.configurer.customCodecs().register(customEncoder1);
this.configurer.customCodecs().encoder(customEncoder2); this.configurer.customCodecs().register(customEncoder2);
this.configurer.customCodecs().writer(customWriter1); this.configurer.customCodecs().register(customWriter1);
this.configurer.customCodecs().writer(customWriter2); this.configurer.customCodecs().register(customWriter2);
this.configurer.registerDefaults(false); this.configurer.registerDefaults(false);
@ -277,10 +277,10 @@ public class CodecConfigurerTests {
this.configurer.registerDefaults(false); this.configurer.registerDefaults(false);
CodecConfigurer clone = this.configurer.clone(); CodecConfigurer clone = this.configurer.clone();
clone.customCodecs().encoder(new Jackson2JsonEncoder()); clone.customCodecs().register(new Jackson2JsonEncoder());
clone.customCodecs().decoder(new Jackson2JsonDecoder()); clone.customCodecs().register(new Jackson2JsonDecoder());
clone.customCodecs().reader(new ServerSentEventHttpMessageReader()); clone.customCodecs().register(new ServerSentEventHttpMessageReader());
clone.customCodecs().writer(new ServerSentEventHttpMessageWriter()); clone.customCodecs().register(new ServerSentEventHttpMessageWriter());
assertThat(this.configurer.getReaders().size()).isEqualTo(0); assertThat(this.configurer.getReaders().size()).isEqualTo(0);
assertThat(this.configurer.getWriters().size()).isEqualTo(0); assertThat(this.configurer.getWriters().size()).isEqualTo(0);
@ -337,6 +337,7 @@ public class CodecConfigurerTests {
assertThat(encoders).doesNotContain(jacksonEncoder, jaxb2Encoder, protoEncoder); assertThat(encoders).doesNotContain(jacksonEncoder, jaxb2Encoder, protoEncoder);
} }
@SuppressWarnings("deprecation")
@Test @Test
void withDefaultCodecConfig() { void withDefaultCodecConfig() {
AtomicBoolean callbackCalled = new AtomicBoolean(false); AtomicBoolean callbackCalled = new AtomicBoolean(false);

40
spring-web/src/test/java/org/springframework/http/codec/support/ServerCodecConfigurerTests.java
View File

@ -40,6 +40,7 @@ import org.springframework.core.codec.ResourceDecoder;
import org.springframework.core.codec.StringDecoder; import org.springframework.core.codec.StringDecoder;
import org.springframework.core.io.buffer.DefaultDataBufferFactory; import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import org.springframework.http.codec.CodecConfigurer;
import org.springframework.http.codec.DecoderHttpMessageReader; import org.springframework.http.codec.DecoderHttpMessageReader;
import org.springframework.http.codec.EncoderHttpMessageWriter; import org.springframework.http.codec.EncoderHttpMessageWriter;
import org.springframework.http.codec.FormHttpMessageReader; import org.springframework.http.codec.FormHttpMessageReader;
@ -129,8 +130,8 @@ public class ServerCodecConfigurerTests {
public void maxInMemorySize() { public void maxInMemorySize() {
int size = 99; int size = 99;
this.configurer.defaultCodecs().maxInMemorySize(size); this.configurer.defaultCodecs().maxInMemorySize(size);
List<HttpMessageReader<?>> readers = this.configurer.getReaders(); List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertThat(readers.size()).isEqualTo(13);
assertThat(((ByteArrayDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size); assertThat(((ByteArrayDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
assertThat(((ByteBufferDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size); assertThat(((ByteBufferDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
assertThat(((DataBufferDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size); assertThat(((DataBufferDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
@ -150,6 +151,28 @@ public class ServerCodecConfigurerTests {
assertThat(((StringDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size); assertThat(((StringDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
} }
@Test
public void maxInMemorySizeWithCustomCodecs() {
int size = 99;
this.configurer.defaultCodecs().maxInMemorySize(size);
this.configurer.registerDefaults(false);
CodecConfigurer.CustomCodecs customCodecs = this.configurer.customCodecs();
customCodecs.register(new ByteArrayDecoder());
customCodecs.registerWithDefaultConfig(new ByteArrayDecoder());
customCodecs.register(new Jackson2JsonDecoder());
customCodecs.registerWithDefaultConfig(new Jackson2JsonDecoder());
this.configurer.defaultCodecs().enableLoggingRequestDetails(true);
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertThat(((ByteArrayDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(256 * 1024);
assertThat(((ByteArrayDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
assertThat(((Jackson2JsonDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(256 * 1024);
assertThat(((Jackson2JsonDecoder) getNextDecoder(readers)).getMaxInMemorySize()).isEqualTo(size);
}
@Test @Test
public void enableRequestLoggingDetails() { public void enableRequestLoggingDetails() {
this.configurer.defaultCodecs().enableLoggingRequestDetails(true); this.configurer.defaultCodecs().enableLoggingRequestDetails(true);
@ -164,6 +187,21 @@ public class ServerCodecConfigurerTests {
assertThat(reader.isEnableLoggingRequestDetails()).isTrue(); assertThat(reader.isEnableLoggingRequestDetails()).isTrue();
} }
@Test
public void enableRequestLoggingDetailsWithCustomCodecs() {
this.configurer.registerDefaults(false);
this.configurer.defaultCodecs().enableLoggingRequestDetails(true);
CodecConfigurer.CustomCodecs customCodecs = this.configurer.customCodecs();
customCodecs.register(new FormHttpMessageReader());
customCodecs.registerWithDefaultConfig(new FormHttpMessageReader());
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertThat(((FormHttpMessageReader) readers.get(0)).isEnableLoggingRequestDetails()).isFalse();
assertThat(((FormHttpMessageReader) readers.get(1)).isEnableLoggingRequestDetails()).isTrue();
}
@Test @Test
public void cloneConfigurer() { public void cloneConfigurer() {
ServerCodecConfigurer clone = this.configurer.clone(); ServerCodecConfigurer clone = this.configurer.clone();

8
spring-webflux/src/test/java/org/springframework/web/reactive/config/WebFluxConfigurationSupportTests.java
View File

@ -350,10 +350,10 @@ public class WebFluxConfigurationSupportTests {
@Override @Override
protected void configureHttpMessageCodecs(ServerCodecConfigurer configurer) { protected void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
configurer.registerDefaults(false); configurer.registerDefaults(false);
configurer.customCodecs().decoder(StringDecoder.textPlainOnly()); configurer.customCodecs().register(StringDecoder.textPlainOnly());
configurer.customCodecs().decoder(new Jaxb2XmlDecoder()); configurer.customCodecs().register(new Jaxb2XmlDecoder());
configurer.customCodecs().encoder(CharSequenceEncoder.textPlainOnly()); configurer.customCodecs().register(CharSequenceEncoder.textPlainOnly());
configurer.customCodecs().encoder(new Jaxb2XmlEncoder()); configurer.customCodecs().register(new Jaxb2XmlEncoder());
} }
} }

4
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/ControllerMethodResolverTests.java
View File

@ -68,8 +68,8 @@ public class ControllerMethodResolverTests {
resolvers.addCustomResolver(new CustomSyncArgumentResolver()); resolvers.addCustomResolver(new CustomSyncArgumentResolver());
ServerCodecConfigurer codecs = ServerCodecConfigurer.create(); ServerCodecConfigurer codecs = ServerCodecConfigurer.create();
codecs.customCodecs().decoder(new ByteArrayDecoder()); codecs.customCodecs().register(new ByteArrayDecoder());
codecs.customCodecs().decoder(new ByteBufferDecoder()); codecs.customCodecs().register(new ByteBufferDecoder());
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(); AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.registerBean(TestControllerAdvice.class); applicationContext.registerBean(TestControllerAdvice.class);