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 and highly readable. It follows clear organization with imports, a single class, and logical method ordering. The class has a single responsibility (Gson-based JSON decoding) and uses flat, minimal nesting. Method names and Javadoc clearly communicate intent, and the constructors document their parameters. The decode method is concise and performs one logical action per line, with proper resource cleanup in a finally block. The only minor issues are the lengthy fully-qualified exception reference and the somewhat long package import lines, but these don't significantly impair readability. Overall, the code is exemplary in clarity and structure.
Run 3
The code is well-structured with clear separation of constructors, overridden methods, and a private static field. Nesting is minimal (only a try-finally block), and each action is generally on its own line. Intent is clearly conveyed through Javadoc and method names. The class is concise and focused, though the decode method's chained call within a single line slightly reduces readability. The unsupported stream decoding method is explicit, improving clarity. Overall, the code follows Spring conventions and is easy to follow.
Run 1
Code Structure: Logically organized into constants, a dependency field, constructors, and decoder overrides. Nesting: Very shallow, with only a straightforward try/finally block. Clarity of intent: Descriptive names and useful Javadoc clearly explain Gson decoding and the lack of streaming support; buffer cleanup is explicit. Code length: Concise implementation with proportionate documentation, though method signatures are long. Action granularity: Statements generally perform one action per line, but the nested reader creation and parsing call compress several operations into one expression. Reading flow: Natural progression from configuration to capability checks and decoding, slightly hindered by ungrouped imports and long lines.
Run 2
Code Structure: Logically organized into constants, a dependency field, constructors, and decoding overrides. Nesting: Very shallow; the only control-flow block is a straightforward try/finally. Clarity of intent: Descriptive names and useful documentation clearly explain Gson decoding and unsupported streaming behavior. Code length: Concise implementation with little redundancy, though method signatures are long. Action granularity: Statements generally perform one action per line; the decoding return combines reader construction, stream access, and parsing, slightly increasing cognitive load. Reading flow: Consistent formatting and conventional method ordering make the class easy to follow. Dense imports and unwrapped method signatures slightly reduce visual readability.
Run 3
Code Structure: Logically organized into constants, state, constructors, capability checks, and decoding methods. Nesting: Minimal, with only a straightforward try/finally block. Clarity of intent: Descriptive names and useful documentation clearly explain Gson decoding and the streaming limitation; the purpose of excluding CharSequence targets is less explicit. 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 in the parsing call adds slight density. Reading flow: Conventional Java ordering and consistent indentation make the class easy to follow, with minor formatting weaknesses in import separation and line wrapping.