Source code
package org.springframework.http.codec.json;
import java.io.InputStreamReader;
import java.util.Map;
import com.google.gson.Gson;
import org.jspecify.annotations.Nullable;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux;
import org.springframework.core.ResolvableType;
import org.springframework.core.codec.AbstractDataBufferDecoder;
import org.springframework.core.codec.Decoder;
import org.springframework.core.codec.DecodingException;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.MediaType;
import org.springframework.util.Assert;
import org.springframework.util.MimeType;
/**
* {@link Decoder} that reads a byte stream into JSON and converts it to Objects with
* <a href="https://google.github.io/gson/">Google Gson</a>.
* <p>{@code Flux<*>} target types are not available because non-blocking parsing is not supported,
* so this decoder targets only {@code Mono<*>} types. Attempting to decode to a {@code Flux<*>} will
* result in a {@link UnsupportedOperationException} being thrown at runtime.
*
* @author Brian Clozel
* @since 7.0
*/
public class GsonDecoder extends AbstractDataBufferDecoder<Object> {
private static final MimeType[] DEFAULT_JSON_MIME_TYPES = new MimeType[] {
MediaType.APPLICATION_JSON,
new MediaType("application", "*+json"),
};
private final Gson gson;
/**
* Construct a new decoder using a default {@link Gson} instance
* and the {@code "application/json"} and {@code "application/*+json"}
* MIME types.
*/
public GsonDecoder() {
this(new Gson(), DEFAULT_JSON_MIME_TYPES);
}
/**
* Construct a new decoder using the given {@link Gson} instance
* and the provided MIME types.
* @param gson the gson instance to use
* @param mimeTypes the mime types the decoder should support
*/
public GsonDecoder(Gson gson, MimeType... mimeTypes) {
super(mimeTypes);
Assert.notNull(gson, "A Gson instance is required");
this.gson = gson;
}
@Override
public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType) {
return super.canDecode(elementType, mimeType) && !CharSequence.class.isAssignableFrom(elementType.toClass());
}
@Override
public Flux<Object> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
throw new UnsupportedOperationException("Stream decoding is currently not supported");
}
@Override
public @Nullable Object decode(DataBuffer buffer, ResolvableType targetType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) throws DecodingException {
try {
return this.gson.fromJson(new InputStreamReader(buffer.asInputStream()), targetType.getType());
}
finally {
DataBufferUtils.release(buffer);
}
}
}
Run 1
The code is well-structured with clear separation between constructors, overridden methods, and field declarations. Nesting is minimal, with only a try-finally block in the decode method. Each method has a single, obvious purpose, and names accurately reflect their behavior. The class-level Javadoc thoroughly explains the Gson decoder's use case and limitations. Imports are organized and specific. Action granularity is appropriate—each logical operation occupies a single line, such as the buffer release in the finally block and the fromJson call. Reading flow is natural: fields, constructors, then overrides. Minor deductions: the decode method combining Gson parsing and buffer release in one method slightly reduces separation of concerns, and exception stack traces could benefit from a message. Overall, highly readable production-quality Spring Framework code.
Run 2
The code is highly readable with clear structure and logical organization. Class responsibilities are well-defined, documentation is thorough, and methods are concise with single responsibilities. Nesting is minimal—only one try-finally block exists. Intent is immediately apparent through descriptive method names and Javadoc. Constructors are properly chained, and the private MIME type array is clearly separated. The decode method efficiently handles resource cleanup in a finally block, demonstrating good action granularity. Reading flow is natural: fields, constructors, then overridden methods in logical order. Minor deductions for the long canDecode condition and the somewhat abrupt UnsupportedOperationException without explanatory message.
Run 3
The code is well-structured and readable. It follows a logical class organization with clear constructors, overridden methods, and concise documentation. The nesting is minimal, and each method performs a single clear action. The intent is easy to understand—decoding JSON using Gson while enforcing Mono-only support. The class length is appropriate, and the flow is natural. Minor deductions: the `decode` method combines Gson invocation with stream handling in one line, slightly reducing action granularity, and the unsupported `Flux` decoding method adds a bit of redundancy. Overall, highly readable with minor room for improvement.
Run 1
Code Structure: Logical organization separates constants, state, constructors, capability checks, and decoding methods. Nesting: Minimal nesting, with only a straightforward try/finally block. Clarity of intent: Descriptive names and useful Javadoc clearly explain Gson decoding and the unsupported streaming operation. Code length: Concise implementation; documentation adds useful context rather than unnecessary bulk. Action granularity: Statements generally perform one action each, although the nested reader construction in fromJson slightly compresses several operations. Reading flow: Methods follow a natural progression, and buffer cleanup is easy to identify. Minor readability drawbacks include long method signatures, ungrouped imports, and slightly inconsistent blank-line spacing.
Run 2
Code Structure: Fields, constructors, and overridden methods are logically organized, with decoding and resource cleanup clearly separated. Nesting: Minimal nesting; the only block structure of note is a straightforward try/finally. Clarity of intent: Descriptive names and useful Javadoc explain Gson integration, supported MIME types, and the streaming limitation. Code length: The implementation is concise, although long method signatures reduce scanability. Action granularity: Statements generally perform one action each; the nested reader construction in the parsing call remains understandable. Reading flow: The class progresses naturally from configuration to capability checks and decoding. Import grouping and wrapping lengthy signatures would improve visual readability.
Run 3
Code Structure: Logically organized into constants, state, constructors, capability checks, and decoding methods. Nesting: Minimal; the only control structure is a straightforward try/finally. Clarity of intent: Descriptive names and useful Javadoc clearly explain Gson decoding and unsupported streaming. Code length: Concise implementation with proportionate documentation, though method signatures are long. Action granularity: Most lines perform one action; the nested reader creation and deserialization expression slightly compress distinct operations. Reading flow: Natural progression and consistent formatting make the class easy to follow, although tightly packed imports and unwrapped signatures reduce visual readability.