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 clear, logical structure with imports, class-level Javadoc, constructor documentation, and method overrides. Nesting is minimal, with only simple conditional-less logic. Intent is explicit through descriptive names, annotations, and Javadoc. Length is appropriate—concise but complete. Each action is generally on its own line, aiding clarity. Reading flow is natural, starting with class documentation and constructors, then method overrides. The only minor drawback is the deprecated status and nested generics in the class declaration, which slightly reduce initial readability.
Run 3
The code is highly readable. It follows a logical structure with a clear class declaration, imports, and documentation. Nesting is minimal, with only simple method bodies. The intent of each constructor and method is explicit, particularly regarding the CBORFactory requirement. Code length is concise and appropriate for the functionality. Each action is on its own line, especially the assertions and constructor delegations. The reading flow is natural, moving from default constructor to custom constructor to overridden setter. Deprecation annotations and Javadoc are informative without clutter.
Run 1
Code Structure: Logically organized with 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 constraints. Code length: Implementation is concise; documentation is somewhat longer than the logic but adds relevant context. Action granularity: Each statement performs one clear action; constructor chaining keeps initialization simple. Reading flow: Natural progression from default construction to custom configuration and mapper replacement. Minor formatting inconsistencies, including an extra blank line and no separation after the package declaration, slightly reduce polish.
Run 2
Code Structure: Logically organized into constructors and an overridden setter, with consistent validation. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive names, explicit CBOR factory checks, and helpful documentation clearly communicate purpose and requirements. Code length: Implementation is concise; documentation is somewhat verbose but useful. Action granularity: Each statement occupies its own line; constructor delegation and validation remain easy to distinguish. Reading flow: Natural progression from class documentation to default construction, custom construction, and configuration. Minor formatting issues, including no blank line after the package declaration and an extra blank line before the setter documentation, slightly reduce polish.
Run 3
Code Structure: Clearly organized imports, class documentation, constructors, and overridden setter; responsibilities are tightly focused. Nesting: Flat methods with no conditional or loop nesting. Clarity of intent: Descriptive names, explicit CBORFactory validation, and helpful documentation make the converter's purpose and configuration requirements clear. Code length: Implementation is concise; documentation is somewhat lengthy relative to the small class, and validation is repeated, but neither significantly impairs readability. Action granularity: Each statement performs one clear operation; constructor delegation and builder chaining remain easy to understand. Reading flow: Natural progression from default construction to custom configuration and subsequent mapper replacement. Minor spacing inconsistencies and long declaration/documentation lines slightly reduce polish.