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 highly readable. It has a clear class structure with logical organization: constants, fields, constructors, and overridden methods are grouped sensibly. Nesting is minimal—only a try-finally block exists, keeping logic flat. Intent is explicit through descriptive method names, Javadoc, and clear exception messages. The code is concise without being cryptic; constructors and overrides are straightforward. Each action is on its own line, improving clarity. Reading flow is natural: class declaration, constants, constructors, then method overrides in logical order. Only minor deductions: the long package/import block is inherent to Java, and the `decode` method signature names like `hints` are standard but slightly vague.
Run 3
The code demonstrates clear structure with logical organization and separation of concerns. Each method has a single responsibility and is properly documented with Javadoc. The nesting is minimal, with only one try-finally block in the decode method. Intent is explicit through descriptive method names and clear constructor overloads. The code is concise and avoids unnecessary verbosity. Action granularity is well-maintained with one operation per line. Reading flow is natural, following a logical progression from class declaration through constructors to method implementations. Minor deductions for the somewhat long method signature in the streaming decode method and the slightly dense constructor delegation pattern.
Run 1
Code Structure: Logically organized into constants, state, constructors, and decoding methods, with helpful documentation. Nesting: Minimal; the only control structure is a straightforward try/finally for buffer cleanup. Clarity of intent: Descriptive names and explicit documentation clearly explain JSON conversion and unsupported stream decoding. Code length: Concise implementation with proportionate documentation, though long method signatures slightly reduce readability. Action granularity: Statements generally perform one action per line; the nested reader creation within fromJson modestly compresses multiple operations. Reading flow: Natural progression from configuration to capability checks and decoding, with consistent formatting overall. Ungrouped imports and lengthy signatures are minor presentation weaknesses.
Run 2
Code Structure: Logically organized into constants, state, constructors, and decoder overrides, with clear separation of responsibilities. Nesting: Minimal; the only block nesting is a straightforward try/finally for buffer cleanup. Clarity of intent: Descriptive names and useful Javadoc explain JSON decoding and the lack of streaming support. Code length: Concise, with little unnecessary implementation code; documentation adds useful context. Action granularity: Statements generally perform one action each, although the decoding expression combines stream access, reader construction, type resolution, and parsing. Reading flow: Natural top-to-bottom progression and consistent formatting make the class easy to follow. Very long method signatures and tightly packed imports slightly reduce scanability.
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 Javadoc clearly explain JSON decoding and the unsupported streaming operation, though character-sequence exclusion is unexplained. Code length: Concise implementation with useful documentation and little redundancy. Action granularity: Statements generally perform one action per line, although reader creation, stream access, and deserialization are combined in one expression. Reading flow: Natural progression and consistent formatting make the class easy to follow; long method signatures and tightly packed imports slightly reduce scanability.