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 due to its clear class-level Javadoc, logical constructor chaining, and minimal nesting. Intent is explicit: it defines a deprecated CBOR message converter. Methods are concise and perform single actions, with assertions placed clearly before delegating to the parent class. Structure follows typical Spring style, with imports and annotations organized predictably. The only minor drawback is slight repetition of the CBORFactory assertion, but this aids clarity without harming flow.
Run 3
The code is highly readable. Structure is logical with clear separation between constructors and overridden method. Nesting is minimal — only one-level depth within methods. Intent is explicit: a CBOR message converter with an ObjectMapper validated to use CBORFactory. Code is concise with no redundant logic. Each method performs one focused action per line, aided by assertions and delegating calls. Reading flow is natural, moving from default constructor to custom constructor to overridden setter. Javadocs are informative and deprecation is clearly noted.
Run 1
Code Structure: Clearly organized into imports, class documentation, constructors, and an overridden setter. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory validation, and useful documentation clearly communicate the converter's purpose and requirements. Code length: Implementation is concise; documentation is somewhat longer than the executable code but provides relevant context. Action granularity: Each statement performs a distinct action on its own line. Reading flow: Natural progression from default construction to custom configuration and setter validation. Minor spacing inconsistencies and lengthy fully qualified documentation links slightly reduce visual polish.
Run 2
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, detailed Javadoc, and explicit CBORFactory validation clearly communicate purpose and constraints. Code length: Implementation is concise; documentation is extensive but useful, with minor repetition of the factory requirement. Action granularity: Each statement performs a distinct action; the builder chain is compact and understandable. Reading flow: Natural progression from default construction to custom configuration and subsequent mapper updates. Minor formatting inconsistencies, such as extra blank lines and no separation after the package declaration, slightly reduce polish.
Run 3
Code Structure: Logically organized into a default constructor, custom constructor, and mapper setter, with consistent validation. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory checks, and informative Javadoc clearly communicate purpose and requirements. Code length: Implementation is concise; documentation is longer than the executable code but remains useful. Action granularity: Each statement performs one clear action; the short builder chain is easy to follow. Reading flow: Natural progression from class documentation to construction and configuration. Minor formatting issues, including missing separation after the package declaration and an extra blank line before the setter documentation, slightly reduce polish.