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 and follows Spring Framework conventions. It has a clear class hierarchy extending AbstractJackson2HttpMessageConverter, with two well-documented constructors delegating appropriately. The structure is logical with no excessive nesting. Intent is explicit through Javadoc comments explaining the CBOR format support, constructor behaviors, and deprecation rationale. Code length is concise with minimal boilerplate. Action granularity is appropriate, with each line performing a single operation. The reading flow is natural, moving from class-level documentation to constructors to overridden methods. The assertion checks are placed correctly and add clarity. Minor deductions: the @SuppressWarnings annotation adds slight noise, and the inheritance structure requires some familiarity with the parent class to fully understand the implementation.
Run 3
The code is highly readable. It's a simple, well-structured Spring converter class. Imports are clean, and the class has clear, standard Javadoc explaining its purpose, deprecation, and usage. Both constructors are concise and delegate correctly, with meaningful validation via Assert. Methods are short and focused, each performing a single logical action. There is minimal nesting and no convoluted logic. The reading flow is natural: class declaration, constructors, override, validation. Minor deductions: the constructor overloads could be slightly clearer with a comment, but overall the code is exemplary in clarity and maintainability.
Run 1
Code Structure: Logically organized into imports, class documentation, constructors, and an overridden setter. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names, explicit CBORFactory validation, and helpful documentation make the converter's purpose clear. Code length: Implementation is concise; documentation is somewhat lengthy but useful. Action granularity: Each statement performs one clear action, with constructor delegation keeping initialization simple. Reading flow: Natural progression from default construction to custom configuration and mapper replacement. Minor distractions include long documentation links, slightly inconsistent blank-line spacing, and duplicated validation.
Run 2
Code Structure: Logically organized into constructors and an overridden setter, with consistent factory validation. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names, explicit CBOR configuration, and helpful documentation clearly explain purpose and constraints. Code length: Implementation is concise; documentation is somewhat verbose but useful. Action granularity: Each statement performs one primary action, and the short builder chain remains easy to understand. Reading flow: Natural progression from class documentation to default construction, custom construction, and configuration. 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 consistent formatting and useful documentation. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBOR configuration checks, and Javadoc make the converter’s purpose and requirements clear. Code length: Implementation is concise; documentation is somewhat lengthy but relevant, and the repeated validation is minor. Action granularity: Each statement performs one clear action; the chained builder expression is straightforward. Reading flow: Natural progression from class documentation to default construction, custom construction, and mapper replacement. Minor spacing inconsistencies and long documentation lines slightly reduce polish.