Source code
package org.springframework.http.converter.cbor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.cbor.CBORFactory;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.Assert;
@Deprecated(since = "7.0", forRemoval = true)
@SuppressWarnings("removal")
public class MappingJackson2CborHttpMessageConverter extends AbstractJackson2HttpMessageConverter {
public MappingJackson2CborHttpMessageConverter() {
this(Jackson2ObjectMapperBuilder.cbor().build());
}
public MappingJackson2CborHttpMessageConverter(ObjectMapper objectMapper) {
super(objectMapper, MediaType.APPLICATION_CBOR);
Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
}
@Override
public void setObjectMapper(ObjectMapper objectMapper) {
Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
super.setObjectMapper(objectMapper);
}
}
Run 1
The code is highly readable with clear structure and intent. It follows Spring framework conventions with proper annotations and clean class organization. The two constructors are concise and delegate appropriately, with validation clearly expressed via Assert statements. Nesting is minimal, and each action is on its own line, enhancing readability. The import section and class declaration are clean. Minor deductions: multiple blank lines (likely formatting artifacts) slightly disrupt reading flow, and the override method setObjectMapper could benefit from a brief Javadoc explaining why validation is needed. Overall, the code demonstrates strong readability through logical organization, concise implementation, and clear purpose.
Run 2
The code is generally clear and well-structured. It follows a logical organization with a single public class extending a Spring abstract converter, two constructors, and one overridden setter method. Nesting is minimal, with no conditional blocks or loops. Intent is clear: it provides a Jackson-based CBOR message converter with validation that the ObjectMapper uses a CBORFactory. Action granularity is appropriate, with each assertion and super call on its own line. The reading flow is natural, moving from constructor overloads to the setter override. However, readability is slightly reduced by excessive blank lines between annotations and the class declaration, as well as within the constructors, which disrupts visual flow. The code length is concise overall, though the blank-line formatting creates unnecessary whitespace. The annotations (@Deprecated, @SuppressWarnings) are clear. If formatting were tightened, the score would be higher.
Run 3
The code is highly readable. It follows a clear, logical structure with package declaration followed by imports, class definition, constructors, and overridden methods. There is no excessive nesting. Intent is clear: a Spring HTTP message converter for CBOR using Jackson. The code is concise—no unnecessary methods or logic. Each action is on its own line, and assertions are clearly stated. The substantial vertical whitespace between methods slightly reduces reading flow, but overall the code is clean and easy to understand.
Run 1
Code Structure: Logically organized into imports, class annotations, constructors, and an overridden setter. Nesting: Shallow, with no nested control flow. Clarity of intent: Descriptive names, CBOR-specific configuration, and explicit factory validation clearly communicate purpose. Code length: Implementation is concise, but excessive blank lines unnecessarily inflate its visual length. Action granularity: Each statement performs one clear action; constructor delegation and validation are easy to distinguish. Reading flow: Conventional Java ordering supports natural reading, though large whitespace gaps interrupt continuity. Overall, the code is highly readable but would benefit from normalized spacing.
Run 2
Code Structure: Imports, class annotations, constructors, and the overridden setter are logically organized. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Descriptive names, APPLICATION_CBOR, and explicit factory validation clearly communicate the converter's purpose. Code length: Implementation is concise, but excessive blank lines unnecessarily stretch the file. Action granularity: Each statement performs a distinct action; constructor delegation and validation remain easy to follow. Reading flow: The progression from default construction to configurable construction and mapper replacement is natural, though large whitespace gaps interrupt continuity. Minor duplicated validation does not significantly impair readability.
Run 3
Code Structure: Imports, class declaration, constructors, and override are logically organized. Nesting: Flat method bodies make the code easy to follow. Clarity of intent: Descriptive names, explicit CBOR media type, and factory validation clearly convey purpose. Code length: The implementation is concise, but excessive blank lines unnecessarily lengthen the presentation. Action granularity: Each statement performs a distinct action on its own line; constructor chaining remains easy to understand. Reading flow: The default constructor, configurable constructor, and setter form a natural progression, though large whitespace gaps interrupt scanning. Minor duplication of factory validation is straightforward and does not significantly impair readability.