Refactor CodecConfigurer

This commit refactors the CodecConfigurer, with it's subtypes
ServerCodecConfigurer and ClientCodecConfigurerTests, into interfaces
instead of classes.

spring-web/src/main/java/org/springframework/http/codec/ClientCodecConfigurer.java

@@ -13,13 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.http.codec;
 
-import java.util.List;
-
 import org.springframework.core.codec.Decoder;
-import org.springframework.core.codec.StringDecoder;
-import org.springframework.http.codec.json.Jackson2JsonDecoder;
 
 /**
  * Helps to configure a list of client-side HTTP message readers and writers
@@ -35,71 +32,36 @@ import org.springframework.http.codec.json.Jackson2JsonDecoder;
  * @author Rossen Stoyanchev
  * @since 5.0
  */
-public class ClientCodecConfigurer extends AbstractCodecConfigurer {
-
-
-	public ClientCodecConfigurer() {
-		super(new ClientDefaultCodecConfigurer());
-	}
-
+public interface ClientCodecConfigurer extends CodecConfigurer {
 
+	/**
+	 * {@inheritDoc}
+	 * <p>Overriden to return {@link ClientDefaultCodecsConfigurer}.
+	 */
 	@Override
-	public ClientDefaultCodecConfigurer defaultCodecs() {
-		return (ClientDefaultCodecConfigurer) super.defaultCodecs();
-	}
-
-
-	@Override
-	protected void addDefaultTypedWriter(List<HttpMessageWriter<?>> result) {
-		super.addDefaultTypedWriter(result);
-		defaultCodecs().addWriterTo(result, FormHttpMessageWriter::new);
-	}
-
-	@Override
-	protected void addDefaultObjectReaders(List<HttpMessageReader<?>> result) {
-		super.addDefaultObjectReaders(result);
-		defaultCodecs().addServerSentEventReaderTo(result);
-	}
+	ClientDefaultCodecsConfigurer defaultCodecs();
 
 
 	/**
-	 * Extension of {@code DefaultCodecConfigurer} with extra client options.
+	 * Creates a new instance of the {@code ClientCodecConfigurer}.
+	 * @return the created instance
 	 */
-	public static class ClientDefaultCodecConfigurer extends DefaultCodecConfigurer {
+	static ClientCodecConfigurer create() {
+		return new DefaultClientCodecConfigurer();
+	}
+
+	/**
+	 * Extension of {@link DefaultCodecConfigurer} with extra client options.
+	 */
+	interface ClientDefaultCodecsConfigurer extends DefaultCodecsConfigurer {
 
 		/**
 		 * Configure the {@code Decoder} to use for Server-Sent Events.
 		 * <p>By default the {@link #jackson2Decoder} override is used for SSE.
 		 * @param decoder the decoder to use
 		 */
-		public void serverSentEventDecoder(Decoder<?> decoder) {
-			HttpMessageReader<?> reader = new ServerSentEventHttpMessageReader(decoder);
-			getReaders().put(ServerSentEventHttpMessageReader.class, reader);
-		}
-
-
-		// Internal methods for building a list of default readers or writers...
-
-		@Override
-		protected void addStringReaderTextOnlyTo(List<HttpMessageReader<?>> result) {
-			addReaderTo(result, () -> new DecoderHttpMessageReader<>(StringDecoder.textPlainOnly(false)));
-		}
-
-		@Override
-		protected void addStringReaderTo(List<HttpMessageReader<?>> result) {
-			addReaderTo(result, () -> new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(false)));
-		}
-
-		private void addServerSentEventReaderTo(List<HttpMessageReader<?>> result) {
-			addReaderTo(result, () -> findReader(ServerSentEventHttpMessageReader.class, () -> {
-				Decoder<?> decoder = null;
-				if (jackson2Present) {
-					decoder = findDecoderReader(
-							Jackson2JsonDecoder.class, Jackson2JsonDecoder::new).getDecoder();
-				}
-				return new ServerSentEventHttpMessageReader(decoder);
-			}));
-		}
+		void serverSentEventDecoder(Decoder<?> decoder);
 	}
 
+
 }

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

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2002-2017 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
+ *
+ *      http://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.http.codec;
+
+import java.util.List;
+
+import org.springframework.core.codec.Decoder;
+import org.springframework.core.codec.Encoder;
+import org.springframework.http.codec.json.Jackson2JsonDecoder;
+import org.springframework.http.codec.json.Jackson2JsonEncoder;
+
+/**
+ * Defines the interface for client or server HTTP message reader and writer configurers.
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0
+ */
+public interface CodecConfigurer {
+
+	/**
+	 * Provide overrides for built-in HTTP message readers or writers.
+	 */
+	DefaultCodecsConfigurer defaultCodecs();
+
+	/**
+	 * Whether to make default HTTP message reader and writer registrations.
+	 * <p>By default this is set to {@code "true"}.
+	 */
+	void registerDefaults(boolean registerDefaults);
+
+	/**
+	 * Register a custom encoder or decoder.
+	 */
+	CustomCodecsConfigurer customCodecs();
+
+	/**
+	 * Prepare a list of HTTP message readers.
+	 */
+	List<HttpMessageReader<?>> getReaders();
+
+	/**
+	 * Prepare a list of HTTP message writers.
+	 */
+	List<HttpMessageWriter<?>> getWriters();
+
+
+	/**
+	 * Registry and container for built-in HTTP message readers and writers.
+	 * @see ClientCodecConfigurer.ClientDefaultCodecsConfigurer
+	 * @see ServerCodecConfigurer.ServerDefaultCodecsConfigurer
+	 */
+	interface DefaultCodecsConfigurer {
+
+		/**
+		 * Override the default Jackson {@code Decoder}.
+		 * @param decoder the decoder to use
+		 */
+		void jackson2Decoder(Jackson2JsonDecoder decoder);
+
+		/**
+		 * Override the default Jackson {@code Encoder} for JSON.
+		 * @param encoder the encoder to use
+		 */
+		void jackson2Encoder(Jackson2JsonEncoder encoder);
+
+	}
+
+
+	/**
+	 * Registry and container for custom HTTP message readers and writers.
+	 */
+	interface CustomCodecsConfigurer {
+
+		/**
+		 * Add a custom {@code Decoder} internally wrapped with
+		 * {@link DecoderHttpMessageReader}).
+		 * @param decoder the decoder to add
+		 */
+		void decoder(Decoder<?> decoder);
+
+		/**
+		 * Add a custom {@code Encoder}, internally wrapped with
+		 * {@link EncoderHttpMessageWriter}.
+		 * @param encoder the encoder to add
+		 */
+		void encoder(Encoder<?> encoder);
+
+		/**
+		 * Add a custom {@link HttpMessageReader}. For readers of type
+		 * {@link DecoderHttpMessageReader} consider using the shortcut
+		 * {@link #decoder(Decoder)} instead.
+		 * @param reader the reader to add
+		 */
+		void reader(HttpMessageReader<?> reader);
+
+		/**
+		 * Add a custom {@link HttpMessageWriter}. For readers of type
+		 * {@link EncoderHttpMessageWriter} consider using the shortcut
+		 * {@link #encoder(Encoder)} instead.
+		 * @param writer the writer to add
+		 */
+		void writer(HttpMessageWriter<?> writer);
+
+	}
+}

spring-web/src/main/java/org/springframework/http/codec/DefaultClientCodecConfigurer.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2002-2017 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
+ *
+ *      http://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.http.codec;
+
+import java.util.List;
+
+import org.springframework.core.codec.Decoder;
+import org.springframework.core.codec.StringDecoder;
+import org.springframework.http.codec.json.Jackson2JsonDecoder;
+
+/**
+ * Default implementation of {@link ClientCodecConfigurer}.
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0
+ */
+class DefaultClientCodecConfigurer extends DefaultCodecConfigurer implements ClientCodecConfigurer {
+
+	public DefaultClientCodecConfigurer() {
+		super(new DefaultClientDefaultCodecsConfigurer());
+	}
+
+	@Override
+	public ClientDefaultCodecsConfigurer defaultCodecs() {
+		return (ClientDefaultCodecsConfigurer) super.defaultCodecs();
+	}
+
+
+	/**
+	 * Default implementation of {@link ClientCodecConfigurer.ClientDefaultCodecsConfigurer}.
+	 */
+	private static class DefaultClientDefaultCodecsConfigurer
+			extends AbstractDefaultCodecsConfigurer
+			implements ClientCodecConfigurer.ClientDefaultCodecsConfigurer {
+
+		@Override
+		public void serverSentEventDecoder(Decoder<?> decoder) {
+			HttpMessageReader<?> reader = new ServerSentEventHttpMessageReader(decoder);
+			getReaders().put(ServerSentEventHttpMessageReader.class, reader);
+		}
+
+		@Override
+		protected void addTypedWritersTo(List<HttpMessageWriter<?>> result) {
+			super.addTypedWritersTo(result);
+			addWriterTo(result, FormHttpMessageWriter::new);
+		}
+
+		@Override
+		protected void addObjectReadersTo(List<HttpMessageReader<?>> result) {
+			super.addObjectReadersTo(result);
+			addServerSentEventReaderTo(result);
+		}
+
+		private void addServerSentEventReaderTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result, () -> findReader(ServerSentEventHttpMessageReader.class, () -> {
+				Decoder<?> decoder = null;
+				if (jackson2Present) {
+					decoder = findDecoderReader(
+							Jackson2JsonDecoder.class, Jackson2JsonDecoder::new).getDecoder();
+				}
+				return new ServerSentEventHttpMessageReader(decoder);
+			}));
+		}
+
+		@Override
+		protected void addStringReaderTextOnlyTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result,
+					() -> new DecoderHttpMessageReader<>(StringDecoder.textPlainOnly(false)));
+		}
+
+		@Override
+		protected void addStringReaderTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result,
+					() -> new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(false)));
+		}
+
+	}
+
+}

spring-web/src/main/java/org/springframework/http/codec/DefaultCodecConfigurer.java

@@ -40,24 +40,26 @@ import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
- * Base class for client or server HTTP message reader and writer configurers.
+ * Default implementation of {@link CodecConfigurer}.
  *
  * @author Rossen Stoyanchev
  * @since 5.0
  */
-public abstract class AbstractCodecConfigurer {
+class DefaultCodecConfigurer implements CodecConfigurer {
 
-	public static final boolean jackson2Present =
+	static final boolean jackson2Present =
 			ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper",
-					AbstractCodecConfigurer.class.getClassLoader()) &&
+					org.springframework.http.codec.DefaultCodecConfigurer.class.getClassLoader()) &&
 					ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator",
-							AbstractCodecConfigurer.class.getClassLoader());
+							org.springframework.http.codec.DefaultCodecConfigurer.class
+									.getClassLoader());
 
-	public static final boolean jaxb2Present =
-			ClassUtils.isPresent("javax.xml.bind.Binder", AbstractCodecConfigurer.class.getClassLoader());
+	static final boolean jaxb2Present =
+			ClassUtils.isPresent("javax.xml.bind.Binder",
+					org.springframework.http.codec.DefaultCodecConfigurer.class.getClassLoader());
 
 
-	private final DefaultCodecConfigurer defaultCodecs;
+	private final AbstractDefaultCodecsConfigurer defaultCodecs;
 
 	private final CustomCodecConfigurer customCodecs = new CustomCodecConfigurer();
 
@@ -65,122 +67,68 @@ public abstract class AbstractCodecConfigurer {
 	/**
 	 * Protected constructor with the configurer for default readers and writers.
 	 */
-	protected AbstractCodecConfigurer(DefaultCodecConfigurer defaultCodecConfigurer) {
+	DefaultCodecConfigurer(AbstractDefaultCodecsConfigurer defaultCodecConfigurer) {
 		Assert.notNull(defaultCodecConfigurer, "DefaultCodecConfigurer is required.");
 		this.defaultCodecs = defaultCodecConfigurer;
 	}
 
 
-	/**
-	 * Provide overrides for built-in HTTP message readers or writers.
-	 */
-	public DefaultCodecConfigurer defaultCodecs() {
+	@Override
+	public DefaultCodecsConfigurer defaultCodecs() {
 		return this.defaultCodecs;
 	}
 
-	/**
-	 * Whether to make default HTTP message reader and writer registrations.
-	 * <p>By default this is set to {@code "true"}.
-	 */
+	@Override
 	public void registerDefaults(boolean registerDefaults) {
-		this.defaultCodecs().setSuppressed(!registerDefaults);
+		this.defaultCodecs.setSuppressed(!registerDefaults);
 	}
 
-	/**
-	 * Register a custom encoder or decoder.
-	 */
-	public CustomCodecConfigurer customCodecs() {
+	@Override
+	public CustomCodecsConfigurer customCodecs() {
 		return this.customCodecs;
 	}
 
 
-	/**
-	 * Prepare a list of HTTP message readers.
-	 */
+	@Override
 	public List<HttpMessageReader<?>> getReaders() {
-
 		List<HttpMessageReader<?>> result = new ArrayList<>();
 
-		addDefaultTypedReaders(result);
-		customCodecs().addTypedReadersTo(result);
+		this.defaultCodecs.addTypedReadersTo(result);
+		this.customCodecs.addTypedReadersTo(result);
 
-		addDefaultObjectReaders(result);
-		customCodecs().addObjectReadersTo(result);
+		this.defaultCodecs.addObjectReadersTo(result);
+		this.customCodecs.addObjectReadersTo(result);
 
 		// String + "*/*"
-		defaultCodecs().addStringReaderTo(result);
+		this.defaultCodecs.addStringReaderTo(result);
 		return result;
 	}
 
-	/**
-	 * Add built-in, concrete, Java type readers.
-	 */
-	protected void addDefaultTypedReaders(List<HttpMessageReader<?>> result) {
-		defaultCodecs().addReaderTo(result, ByteArrayDecoder.class, ByteArrayDecoder::new);
-		defaultCodecs().addReaderTo(result, ByteBufferDecoder.class, ByteBufferDecoder::new);
-		defaultCodecs().addReaderTo(result, DataBufferDecoder.class, DataBufferDecoder::new);
-		defaultCodecs().addReaderTo(result, ResourceDecoder.class, ResourceDecoder::new);
-		defaultCodecs().addStringReaderTextOnlyTo(result);
-	}
-
-	/**
-	 * Add built-in, Object-based readers.
-	 */
-	protected void addDefaultObjectReaders(List<HttpMessageReader<?>> result) {
-		if (jaxb2Present) {
-			defaultCodecs().addReaderTo(result, Jaxb2XmlDecoder.class, Jaxb2XmlDecoder::new);
-		}
-		if (jackson2Present) {
-			defaultCodecs().addReaderTo(result, Jackson2JsonDecoder.class, Jackson2JsonDecoder::new);
-		}
-	}
-
 	/**
 	 * Prepare a list of HTTP message writers.
 	 */
+	@Override
 	public List<HttpMessageWriter<?>> getWriters() {
 
 		List<HttpMessageWriter<?>> result = new ArrayList<>();
 
-		addDefaultTypedWriter(result);
-		customCodecs().addTypedWritersTo(result);
+		this.defaultCodecs.addTypedWritersTo(result);
+		this.customCodecs.addTypedWritersTo(result);
 
-		addDefaultObjectWriters(result);
-		customCodecs().addObjectWritersTo(result);
+		this.defaultCodecs.addObjectWritersTo(result);
+		this.customCodecs.addObjectWritersTo(result);
 
 		// String + "*/*"
-		defaultCodecs().addStringWriterTo(result);
+		this.defaultCodecs.addStringWriterTo(result);
 		return result;
 	}
 
-	/**
-	 * Add built-in, concrete, Java type readers.
-	 */
-	protected void addDefaultTypedWriter(List<HttpMessageWriter<?>> result) {
-		defaultCodecs().addWriterTo(result, ByteArrayEncoder.class, ByteArrayEncoder::new);
-		defaultCodecs().addWriterTo(result, ByteBufferEncoder.class, ByteBufferEncoder::new);
-		defaultCodecs().addWriterTo(result, DataBufferEncoder.class, DataBufferEncoder::new);
-		defaultCodecs().addWriterTo(result, ResourceHttpMessageWriter::new);
-		defaultCodecs().addStringWriterTextPlainOnlyTo(result);
-	}
 
 	/**
-	 * Add built-in, Object-based readers.
+	 * Default implementation for {@link CodecConfigurer.DefaultCodecsConfigurer}.
 	 */
-	protected void addDefaultObjectWriters(List<HttpMessageWriter<?>> result) {
-		if (jaxb2Present) {
-			defaultCodecs().addWriterTo(result, Jaxb2XmlEncoder.class, Jaxb2XmlEncoder::new);
-		}
-		if (jackson2Present) {
-			defaultCodecs().addWriterTo(result, Jackson2JsonEncoder.class, Jackson2JsonEncoder::new);
-		}
-	}
-
-
-	/**
-	 * A registry and a factory for built-in HTTP message readers and writers.
-	 */
-	public abstract static class DefaultCodecConfigurer {
+	abstract static class AbstractDefaultCodecsConfigurer
+			implements CodecConfigurer.DefaultCodecsConfigurer {
 
 		private boolean suppressed = false;
 
@@ -188,23 +136,51 @@ public abstract class AbstractCodecConfigurer {
 
 		private final Map<Class<?>, HttpMessageWriter<?>> writers = new HashMap<>();
 
-
-		/**
-		 * Override the default Jackson {@code Decoder}.
-		 * @param decoder the decoder to use
-		 */
+		@Override
 		public void jackson2Decoder(Jackson2JsonDecoder decoder) {
 			this.readers.put(Jackson2JsonDecoder.class, new DecoderHttpMessageReader<>(decoder));
 		}
 
-		/**
-		 * Override the default Jackson {@code Encoder} for JSON.
-		 * @param encoder the encoder to use
-		 */
+		@Override
 		public void jackson2Encoder(Jackson2JsonEncoder encoder) {
 			this.writers.put(Jackson2JsonEncoder.class, new EncoderHttpMessageWriter<>(encoder));
 		}
 
+		public void addTypedReadersTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result, ByteArrayDecoder.class, ByteArrayDecoder::new);
+			addReaderTo(result, ByteBufferDecoder.class, ByteBufferDecoder::new);
+			addReaderTo(result, DataBufferDecoder.class, DataBufferDecoder::new);
+			addReaderTo(result, ResourceDecoder.class, ResourceDecoder::new);
+			addStringReaderTextOnlyTo(result);
+		}
+
+		protected void addTypedWritersTo(List<HttpMessageWriter<?>> result) {
+			addWriterTo(result, ByteArrayEncoder.class, ByteArrayEncoder::new);
+			addWriterTo(result, ByteBufferEncoder.class, ByteBufferEncoder::new);
+			addWriterTo(result, DataBufferEncoder.class, DataBufferEncoder::new);
+			addWriterTo(result, ResourceHttpMessageWriter::new);
+			addStringWriterTextPlainOnlyTo(result);
+		}
+
+
+		protected void addObjectReadersTo(List<HttpMessageReader<?>> result) {
+			if (jaxb2Present) {
+				addReaderTo(result, Jaxb2XmlDecoder.class, Jaxb2XmlDecoder::new);
+			}
+			if (jackson2Present) {
+				addReaderTo(result, Jackson2JsonDecoder.class, Jackson2JsonDecoder::new);
+			}
+		}
+
+		protected void addObjectWritersTo(List<HttpMessageWriter<?>> result) {
+			if (jaxb2Present) {
+				addWriterTo(result, Jaxb2XmlEncoder.class, Jaxb2XmlEncoder::new);
+			}
+			if (jackson2Present) {
+				addWriterTo(result, Jackson2JsonEncoder.class, Jackson2JsonEncoder::new);
+			}
+		}
+
 
 		// Accessors for internal use...
 
@@ -292,10 +268,11 @@ public abstract class AbstractCodecConfigurer {
 		}
 	}
 
+
 	/**
-	 * Registry and container for custom HTTP message readers and writers.
+	 * Default implementation of CustomCodecsConfigurer.
 	 */
-	public static class CustomCodecConfigurer {
+	private static class CustomCodecConfigurer implements CodecConfigurer.CustomCodecsConfigurer {
 
 		private final List<HttpMessageReader<?>> typedReaders = new ArrayList<>();
 
@@ -306,47 +283,28 @@ public abstract class AbstractCodecConfigurer {
 		private final List<HttpMessageWriter<?>> objectWriters = new ArrayList<>();
 
 
-		/**
-		 * Add a custom {@code Decoder} internally wrapped with
-		 * {@link DecoderHttpMessageReader}).
-		 * @param decoder the decoder to add
-		 */
+		@Override
 		public void decoder(Decoder<?> decoder) {
 			reader(new DecoderHttpMessageReader<>(decoder));
 		}
 
-		/**
-		 * Add a custom {@code Encoder}, internally wrapped with
-		 * {@link EncoderHttpMessageWriter}.
-		 * @param encoder the encoder to add
-		 */
+		@Override
 		public void encoder(Encoder<?> encoder) {
 			writer(new EncoderHttpMessageWriter<>(encoder));
 		}
 
-		/**
-		 * Add a custom {@link HttpMessageReader}. For readers of type
-		 * {@link DecoderHttpMessageReader} consider using the shortcut
-		 * {@link #decoder(Decoder)} instead.
-		 * @param reader the reader to add
-		 */
+		@Override
 		public void reader(HttpMessageReader<?> reader) {
 			boolean canReadToObject = reader.canRead(ResolvableType.forClass(Object.class), null);
 			(canReadToObject ? this.objectReaders : this.typedReaders).add(reader);
 		}
 
-		/**
-		 * Add a custom {@link HttpMessageWriter}. For readers of type
-		 * {@link EncoderHttpMessageWriter} consider using the shortcut
-		 * {@link #encoder(Encoder)} instead.
-		 * @param writer the writer to add
-		 */
+		@Override
 		public void writer(HttpMessageWriter<?> writer) {
 			boolean canWriteObject = writer.canWrite(ResolvableType.forClass(Object.class), null);
 			(canWriteObject ? this.objectWriters : this.typedWriters).add(writer);
 		}
 
-
 		// Internal methods for building a list of custom readers or writers...
 
 		protected void addTypedReadersTo(List<HttpMessageReader<?>> result) {

spring-web/src/main/java/org/springframework/http/codec/DefaultServerCodecConfigurer.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2002-2017 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
+ *
+ *      http://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.http.codec;
+
+import java.util.List;
+
+import org.springframework.core.codec.Encoder;
+import org.springframework.core.codec.StringDecoder;
+import org.springframework.http.codec.json.Jackson2JsonEncoder;
+
+/**
+ * Default implementation of {@link ServerCodecConfigurer}.
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0
+ */
+class DefaultServerCodecConfigurer extends DefaultCodecConfigurer implements ServerCodecConfigurer {
+
+	public DefaultServerCodecConfigurer() {
+		super(new DefaultServerDefaultCodecsConfigurer());
+	}
+
+	@Override
+	public ServerDefaultCodecsConfigurer defaultCodecs() {
+		return (ServerDefaultCodecsConfigurer) super.defaultCodecs();
+	}
+
+
+	/**
+	 * Default implementation of {@link ServerCodecConfigurer.ServerDefaultCodecsConfigurer}.
+	 */
+	private static class DefaultServerDefaultCodecsConfigurer
+			extends AbstractDefaultCodecsConfigurer
+			implements ServerCodecConfigurer.ServerDefaultCodecsConfigurer {
+
+		@Override
+		public void serverSentEventEncoder(Encoder<?> encoder) {
+			HttpMessageWriter<?> writer = new ServerSentEventHttpMessageWriter(encoder);
+			getWriters().put(ServerSentEventHttpMessageWriter.class, writer);
+		}
+
+		@Override
+		public void addTypedReadersTo(List<HttpMessageReader<?>> result) {
+			super.addTypedReadersTo(result);
+			addReaderTo(result, FormHttpMessageReader::new);
+		}
+
+		@Override
+		protected void addObjectWritersTo(List<HttpMessageWriter<?>> result) {
+			super.addObjectWritersTo(result);
+			addServerSentEventWriterTo(result);
+		}
+
+
+		private void addServerSentEventWriterTo(List<HttpMessageWriter<?>> result) {
+			addWriterTo(result, () -> findWriter(ServerSentEventHttpMessageWriter.class, () -> {
+				Encoder<?> encoder = null;
+				if (jackson2Present) {
+					encoder = findEncoderWriter(
+							Jackson2JsonEncoder.class, Jackson2JsonEncoder::new).getEncoder();
+				}
+				return new ServerSentEventHttpMessageWriter(encoder);
+			}));
+		}
+
+		@Override
+		protected void addStringReaderTextOnlyTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result,
+					() -> new DecoderHttpMessageReader<>(StringDecoder.textPlainOnly(true)));
+		}
+
+		@Override
+		protected void addStringReaderTo(List<HttpMessageReader<?>> result) {
+			addReaderTo(result,
+					() -> new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
+		}
+
+	}
+
+}

spring-web/src/main/java/org/springframework/http/codec/ServerCodecConfigurer.java

@@ -13,13 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.http.codec;
 
-import java.util.List;
-
 import org.springframework.core.codec.Encoder;
-import org.springframework.core.codec.StringDecoder;
-import org.springframework.http.codec.json.Jackson2JsonEncoder;
 
 /**
  * Helps to configure a list of server-side HTTP message readers and writers
@@ -35,72 +32,37 @@ import org.springframework.http.codec.json.Jackson2JsonEncoder;
  * @author Rossen Stoyanchev
  * @since 5.0
  */
-public class ServerCodecConfigurer extends AbstractCodecConfigurer {
-
-
-	public ServerCodecConfigurer() {
-		super(new ServerDefaultCodecConfigurer());
-	}
-
+public interface ServerCodecConfigurer extends CodecConfigurer {
 
+	/**
+	 * {@inheritDoc}
+	 * <p>Overriden to return {@link ServerDefaultCodecsConfigurer}.
+	 */
 	@Override
-	public ServerDefaultCodecConfigurer defaultCodecs() {
-		return (ServerDefaultCodecConfigurer) super.defaultCodecs();
-	}
+	ServerDefaultCodecsConfigurer defaultCodecs();
 
 
-	@Override
-	protected void addDefaultTypedReaders(List<HttpMessageReader<?>> result) {
-		super.addDefaultTypedReaders(result);
-		defaultCodecs().addReaderTo(result, FormHttpMessageReader::new);
-	}
-
-
-	@Override
-	protected void addDefaultObjectWriters(List<HttpMessageWriter<?>> result) {
-		super.addDefaultObjectWriters(result);
-		defaultCodecs().addServerSentEventWriterTo(result);
+	/**
+	 * Creates a new instance of the {@code ServerCodecConfigurer}.
+	 * @return the created instance
+	 */
+	static ServerCodecConfigurer create() {
+		return new DefaultServerCodecConfigurer();
 	}
 
 
 	/**
-	 * Extension of {@code DefaultCodecConfigurer} with extra server options.
+	 * Extension of {@link DefaultCodecConfigurer} with extra server options.
 	 */
-	public static class ServerDefaultCodecConfigurer extends DefaultCodecConfigurer {
+	interface ServerDefaultCodecsConfigurer extends DefaultCodecsConfigurer {
 
 		/**
 		 * Configure the {@code Encoder} to use for Server-Sent Events.
 		 * <p>By default the {@link #jackson2Encoder} override is used for SSE.
 		 * @param encoder the encoder to use
 		 */
-		public void serverSentEventEncoder(Encoder<?> encoder) {
-			HttpMessageWriter<?> writer = new ServerSentEventHttpMessageWriter(encoder);
-			getWriters().put(ServerSentEventHttpMessageWriter.class, writer);
-		}
+		void serverSentEventEncoder(Encoder<?> encoder);
 
-
-		// Internal methods for building a list of default readers or writers...
-
-		@Override
-		protected void addStringReaderTextOnlyTo(List<HttpMessageReader<?>> result) {
-			addReaderTo(result, () -> new DecoderHttpMessageReader<>(StringDecoder.textPlainOnly(true)));
-		}
-
-		@Override
-		protected void addStringReaderTo(List<HttpMessageReader<?>> result) {
-			addReaderTo(result, () -> new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
-		}
-
-		private void addServerSentEventWriterTo(List<HttpMessageWriter<?>> result) {
-			addWriterTo(result, () -> findWriter(ServerSentEventHttpMessageWriter.class, () -> {
-				Encoder<?> encoder = null;
-				if (jackson2Present) {
-					encoder = findEncoderWriter(
-							Jackson2JsonEncoder.class, Jackson2JsonEncoder::new).getEncoder();
-				}
-				return new ServerSentEventHttpMessageWriter(encoder);
-			}));
-		}
 	}
 
 }