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 and highly readable. It has a clear class hierarchy, logical organization with constructors and overridden methods, and minimal nesting. Each method has a single, clear purpose, and the actions are concise—one primary operation per line. The use of Javadoc comments and meaningful method names (e.g., canDecode, decode) enhances clarity of intent. The code length is appropriate, avoiding unnecessary verbosity while maintaining completeness. Reading flow is natural: the constructors lead to the overridden methods, each returning or throwing clear exceptions. Minor deductions include slightly long import statements and a single-line method that could be more readable if split, but overall the code is highly maintainable and understandable.
Run 2
The code demonstrates strong readability. Structure is logical with clear class-level documentation and separated constructors. Nesting is minimal. Intent of each method is explicit, especially the stream-decoding limitation. Length is appropriate, with no unnecessary verbosity. Most lines perform a single action, and the try/finally cleanly isolates resource release. Minor deductions: the parameter list in the 'decode' method is long but acceptable; the override annotation on a throwing method is slightly unusual. Overall, the class is easy to follow and maintain.
Run 3
The code is well-structured, with clear class-level documentation explaining its purpose and limitations. Imports are organized and the class hierarchy is logical. Methods are concise, serve single purposes, and follow standard naming conventions. Nesting is minimal: the only nested block is a try-finally with a single statement each. Intent is evident from method names and the Javadoc. Exception handling and resource release are handled correctly in the finally block. Minor readability deductions: the overridden decode method signature is somewhat long due to multiple parameters and annotations, and the method throws UnsupportedOperationException with minimal elaboration, though the class-level Javadoc covers it. Overall, the code is highly readable.
Run 1
Code Structure: Well organized into constants, state, constructors, and decoder overrides, with helpful documentation. Nesting: Minimal nesting; the try/finally block is straightforward. Clarity of intent: Descriptive names and explicit documentation clearly explain JSON decoding and unsupported streaming. Code length: Concise implementation with proportionate documentation, though long method signatures reduce scanability. Action granularity: Statements generally perform one action per line; the nested reader construction and parsing expression slightly compress multiple operations. Reading flow: Natural progression from configuration to capability checks and decoding, with explicit buffer cleanup. Minor formatting issues, including ungrouped imports and long lines, prevent a top score.
Run 2
Code Structure: Well organized into constants, a dependency field, constructors, capability checking, and decoding methods. Nesting: Minimal, with only a straightforward try/finally block. Clarity of intent: Descriptive names and useful Javadoc clearly explain JSON conversion and the unsupported streaming mode. Code length: Concise, with little unnecessary implementation code. Action granularity: Most lines perform one clear action, although reader creation, stream access, and deserialization are combined in one expression. Reading flow: Conventional class organization and explicit buffer cleanup make the implementation easy to follow. Minor readability drawbacks include long method signatures, tightly packed imports, and the need to distinguish two overloaded decode methods.
Run 3
Code Structure: Logically organized into constants, state, constructors, and decoder overrides. Nesting: Minimal; the only control structure is a straightforward try/finally. Clarity of intent: Descriptive names and useful documentation clearly explain Gson decoding and the unsupported streaming operation. Code length: Concise implementation with proportionate documentation, though method signatures are long. Action granularity: Statements generally perform one action each; the nested reader creation in the parsing call slightly compresses multiple operations. Reading flow: Natural progression from configuration to capability checks and decoding, with explicit buffer cleanup. Minor readability drawbacks include crowded imports, long unwrapped signatures, and similarly named decode overloads requiring attention to their parameter types.