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 with clear class-level Javadoc, well-structured constructors, and minimal nesting. Each method performs a single logical action, and lines are concise. The deprecated annotation and constructor chaining are idiomatic. Minor deductions: the class-level Javadoc is somewhat verbose, and the import list could be grouped more explicitly, but overall clarity and intent are strong.
Run 3
The code is highly readable: it has a clear class-level Javadoc, logical constructor chaining, and minimal nesting. Each method performs a single clear action (delegation, assertion, or override). The structure follows standard Spring patterns, and the use of Assert and MediaType constants makes intent explicit. The only minor deductions are for the long imports and class declaration line, which slightly affect visual scanning, but overall the flow is natural and concise.
Run 1
Code Structure: Clearly organized imports, class documentation, constructors, and overridden setter; responsibilities are narrowly scoped. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names, explicit CBOR factory validation, and useful documentation make the converter's purpose and configuration requirements clear. Code length: Implementation is concise; documentation is somewhat longer than the logic but provides relevant context. Action granularity: Each statement performs one clear action, with straightforward constructor delegation and validation. Reading flow: Natural progression from default construction to custom configuration and mapper replacement. Minor spacing inconsistencies and long identifiers slightly reduce visual compactness, but readability is excellent overall.
Run 2
Code Structure: Logically organized into constructors and an overridden setter, with consistent validation. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory assertions, and informative Javadoc clearly explain purpose and constraints. Code length: Implementation is concise; documentation is somewhat verbose but useful. Action granularity: Each statement performs one clear action; constructor delegation and builder chaining remain easy to understand. Reading flow: Natural progression from class documentation to default construction, custom construction, and configuration. Minor formatting inconsistencies, including missing separation after the package declaration and an extra blank line before the setter documentation, slightly reduce polish.
Run 3
Code Structure: Clearly 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 thorough Javadoc make the converter's purpose and configuration requirements clear. Code length: Implementation is concise; documentation is extensive but relevant, with minor repetition. Action granularity: Each statement performs one primary action; the builder chain is short and readable. Reading flow: Natural progression from default construction to custom configuration and mapper replacement. Minor formatting issues, including no separation after the package declaration and an extra blank line before the setter documentation, slightly reduce polish.