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 is well-structured with clear separation of concerns: class declaration, constants, constructors, and overridden methods. Nesting is minimal, with only a try-finally block inside one method. Intent is clear from descriptive method names and Javadoc comments explaining limitations (no Flux support). Code length is appropriate—no unnecessary verbosity. Action granularity is good; each line performs a single logical action. Reading flow is natural: constructors follow the constant declaration, and overridden methods are grouped logically. Minor deductions: the decode method throws an UnsupportedOperationException without inline explanation (though Javadoc covers it), and the class-level Javadoc is somewhat long. Overall, the code is highly readable.
Run 3
The code is well-structured and readable. It has a clear class hierarchy, sensible constructor overloads, and good Javadoc documentation explaining intent and limitations. Methods are concise, with flat nesting and single-action lines in most places. The `canDecode` and `decode` methods clearly express their purpose. Minor deductions: the `Flux` variant of `decode` simply throws an exception (which is acceptable given documented constraints but still slightly awkward), and the streaming decode method signature is long, though this is standard for Spring decoders. Overall, the code is maintainable and easy to follow.
Run 1
Code Structure: Fields, constructors, capability checks, and decoding methods are logically organized. Nesting: Minimal nesting; the simple try/finally clearly expresses resource cleanup. Clarity of intent: Descriptive names and useful Javadoc explain Gson conversion and unsupported stream decoding, though the two decode overloads require attention to distinguish their roles. Code length: Concise implementation with proportionate documentation and little redundancy. Action granularity: Statements generally perform one action each; the nested reader construction and deserialization expression slightly compress several operations. Reading flow: Consistent formatting and conventional ordering make the class easy to follow, but long method signatures and the ungrouped import block reduce scanability slightly.
Run 2
Code Structure: Clearly organized into constants, a dependency field, constructors, and decoder overrides. Nesting: Minimal, with only a straightforward try/finally block. Clarity of intent: Descriptive names and useful documentation explain Gson conversion, supported MIME types, and the lack of streaming support. Code length: Concise implementation with proportionate documentation and little redundancy. Action granularity: Most statements perform one action; the JSON conversion line combines reader construction, stream access, type resolution, and parsing, slightly increasing cognitive load. Reading flow: Natural progression from configuration to capability checks and decoding, with explicit buffer cleanup. Long method signatures and the unwrapped canDecode expression slightly reduce scanability.
Run 3
Code Structure: Logically organized into constants, state, constructors, and decoder overrides, with clear separation of responsibilities. Nesting: Minimal; the only notable control structure is a straightforward try/finally. Clarity of intent: Descriptive names and useful Javadoc explain Gson-based decoding and the unsupported streaming operation. Code length: Concise implementation with proportionate documentation and little redundancy. Action granularity: Statements generally perform one action per line, although the nested reader creation and parsing expression combines several operations. Reading flow: Natural progression from configuration to capability checks and decoding, with explicit buffer cleanup. Readability is slightly reduced by very long method signatures, tightly packed imports, and inconsistent blank-line spacing.