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;
/**
* Implementation of {@link org.springframework.http.converter.HttpMessageConverter
* HttpMessageConverter} that can read and write the <a href="https://cbor.io/">CBOR</a>
* data format using <a href="https://github.com/FasterXML/jackson-dataformats-binary/tree/master/cbor">
* the dedicated Jackson 2.x extension</a>.
*
* <p>By default, this converter supports the {@link MediaType#APPLICATION_CBOR_VALUE}
* media type. This can be overridden by setting the {@link #setSupportedMediaTypes
* supportedMediaTypes} property.
*
* <p>The default constructor uses the default configuration provided by
* {@link Jackson2ObjectMapperBuilder}.
*
* @author Sebastien Deleuze
* @since 5.0
* @deprecated since 7.0 in favor of {@link JacksonCborHttpMessageConverter}
*/
@Deprecated(since = "7.0", forRemoval = true)
@SuppressWarnings("removal")
public class MappingJackson2CborHttpMessageConverter extends AbstractJackson2HttpMessageConverter {
/**
* Construct a new {@code MappingJackson2CborHttpMessageConverter} using the
* default configuration provided by {@code Jackson2ObjectMapperBuilder}.
*/
public MappingJackson2CborHttpMessageConverter() {
this(Jackson2ObjectMapperBuilder.cbor().build());
}
/**
* Construct a new {@code MappingJackson2CborHttpMessageConverter} with a
* custom {@link ObjectMapper} (must be configured with a {@code CBORFactory}
* instance).
* <p>You can use {@link Jackson2ObjectMapperBuilder} to build it easily.
* @see Jackson2ObjectMapperBuilder#cbor()
*/
public MappingJackson2CborHttpMessageConverter(ObjectMapper objectMapper) {
super(objectMapper, MediaType.APPLICATION_CBOR);
Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
}
/**
* {@inheritDoc}
* <p>The {@code ObjectMapper} must be configured with a {@code CBORFactory} instance.
*/
@Override
public void setObjectMapper(ObjectMapper objectMapper) {
Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
super.setObjectMapper(objectMapper);
}
}
Run 1
This code is exceptionally readable. Structure is logical with clear class-level Javadoc explaining purpose, deprecation, and usage. Imports are clean. Nesting is essentially flat; no complex conditional or loop structures exist. Intent is unambiguous: the class provides CBOR message conversion via Jackson, with clear constructors and a setter. Code length is minimal and focused, avoiding unnecessary boilerplate. Each method performs one clear action or delegates appropriately, and the constructor chaining is concise. The reading flow is natural from class documentation to constructors to override methods. Assertions are used effectively to enforce preconditions without clutter.
Run 2
The code is highly readable. It follows a logical structure with clear Javadoc, constructors, and a single overridden method. Nesting is minimal and flow is natural. The purpose is unequivocal: a Spring HTTP message converter for CBOR using Jackson. Code length is concise and appropriate, with little redundancy. Each constructor performs one primary action, and the override clearly validates the ObjectMapper before delegating to the superclass. Minor improvements could include grouping imports or clarifying the rationale for the assertion, but overall the intent, structure, and flow are excellent.
Run 3
The code is highly readable due to its clear structure and logical organization. The class has a single responsibility, and the constructors are short and focused. Nesting is minimal, with no deep indentation or conditional complexity. Intent is clearly expressed through meaningful method names and Javadoc. The action granularity is appropriate, with one action per line in key operations like constructor delegation and validation. The reading flow is natural, guiding the reader from class overview to specific methods. Minor deductions for slight repetition in validation logic and the deprecation annotations adding noise, but overall the code is concise and easy to understand.
Run 1
Code Structure: Logically organized into imports, class documentation, constructors, and an overridden setter. Nesting: Flat method bodies with no nested control flow. Clarity of intent: Descriptive names, explicit CBORFactory validation, and useful documentation clearly communicate purpose and configuration requirements. Code length: Implementation is concise; documentation is somewhat verbose but informative. Action granularity: Each statement performs a single clear action, with constructor delegation avoiding duplicated initialization. Reading flow: Natural progression from default construction to custom configuration and mapper replacement. Minor spacing inconsistencies and long documentation links slightly reduce readability.
Run 2
Code Structure: Logically organized into constructors and an overridden setter, with configuration validation placed alongside initialization. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory checks, and useful Javadoc clearly communicate purpose and requirements. Code length: Implementation is concise; documentation is somewhat verbose but relevant. Action granularity: Each statement performs one main action, with short builder chaining that remains understandable. Reading flow: Imports, class documentation, constructors, and setter follow a natural order. Minor formatting inconsistencies, including extra blank lines and no separation after the package declaration, slightly reduce polish.
Run 3
Code Structure: Logically organized into constructors and an overridden setter, with shared conversion behavior delegated to the superclass. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory validation, and helpful Javadoc clearly communicate purpose and configuration requirements. Code length: Implementation is concise; documentation is somewhat verbose but useful, and repeated validation is minor. Action granularity: Each statement performs one clear action; constructor chaining and the builder expression are straightforward. Reading flow: Natural progression from class documentation to default construction, custom construction, and mapper replacement. Minor formatting inconsistencies, such as extra blank lines and no separation between the package declaration and imports, slightly reduce polish.