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 object) {
super(object, MediaType.APPLICATION_CBOR);
Assert.isInstanceOf(CBORFactory.class, object.getFactory(), "CBORFactory required");
}
/**
* {@inheritDoc}
* <p>The {@code ObjectMapper} must be configured with a {@code CBORFactory} instance.
*/
@Override
public void set(ObjectMapper object2) {
Assert.isInstanceOf(CBORFactory.class, object2.getFactory(), "CBORFactory required");
super.setObjectMapper(object2);
}
}
Run 1
The code is highly readable with a clear, logical structure. It follows standard Java conventions, with package, imports, and class declaration in proper order. Nesting is minimal—only one class and no deeply nested blocks. Intent is explicit through comprehensive Javadoc comments, clear method names, and descriptive parameter names. Code length is appropriate, avoiding unnecessary verbosity while including essential documentation. Action granularity is good, with one action per line in methods, though the constructor initializer could be split for marginally better clarity but is still readable. Reading flow is natural, with constructors and overridden methods logically arranged. The only slight deductions are for minor parameter naming inconsistencies ('object' vs 'object2') and a slightly complex constructor chaining line, but overall this is exemplary Spring framework code that clearly expresses purpose and usage.
Run 2
The code is highly readable with clear structure, minimal nesting, and explicit intent. The class has a single responsibility (CBOR message conversion) and follows consistent Spring patterns. Constructors and the overridden method are short, with assertions validating preconditions clearly. Each line performs a single action, and the reading flow is natural: imports, Javadoc, class declaration, constructors, then method override. The Javadoc documentation is thorough, referencing relevant classes and usage guidance. Minor deductions: the 'object' and 'object2' parameter names are slightly awkward, and the import ordering is not alphabetical. Overall, an excellent example of maintainable Spring framework code.
Run 3
The code is highly readable. It has a clear, logical structure with standard package/import declarations, concise class-level Javadoc, and well-documented constructors and methods. Nesting is minimal—only single-level method bodies with assertion checks. Intent is explicit: it defines a deprecated CBOR message converter and validates the ObjectMapper's factory. Code length is appropriate, with no unnecessary verbosity. Each method performs one clear action per line (assertion, delegation, assignment). Reading flow is natural, from class documentation to constructors and override. Minor deductions: the '@SuppressWarnings("removal")' is slightly opaque without context, and the inherited 'set' method's parameter name 'object2' is awkward. However, these do not significantly impact overall clarity.
Run 1
Code Structure: The class is logically organized into constructors and a configuration method, with clear separation of responsibilities. Nesting: There is no nested control flow, making each method easy to scan. Clarity of intent: Documentation, descriptive class names, and explicit CBORFactory validation explain the converter's purpose well. However, the method name set and parameter names object and object2 are vague; set also conflicts with the apparent setObjectMapper override intent. Code length: Implementation is concise, although documentation occupies most of the snippet. Action granularity: Each statement performs one primary action; the builder chain is short and understandable. Reading flow: Default construction, custom construction, and subsequent configuration follow a natural order. Missing spacing after the package declaration and an extra blank line introduce minor formatting inconsistencies.
Run 2
Code Structure: Constructors and the mapper setter are logically organized, with validation close to configuration. Nesting: Flat methods contain no branching or deeply nested blocks. Clarity of intent: Javadoc, CBOR-specific types, and explicit assertions explain the converter's purpose, but the generic method name set and parameter names object/object2 obscure the mapper configuration intent. The @Override annotation on set also appears inconsistent with the superclass API suggested by super.setObjectMapper. Code length: Implementation is concise; documentation is useful, though comparatively lengthy. Action granularity: Each statement performs one clear action, with only straightforward builder chaining. Reading flow: Imports, class documentation, constructors, and setter follow a natural sequence; minor spacing inconsistencies and weak naming slightly interrupt readability.
Run 3
Code Structure: Logically organized into constructors and a configuration method, with clear separation of responsibilities. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: Documentation clearly describes CBOR conversion and factory requirements, but the generic method name set and parameter names object/object2 obscure the ObjectMapper configuration purpose. The @Override on set also appears inconsistent with the superclass API suggested by super.setObjectMapper. Code length: Implementation is concise; documentation is useful but somewhat repetitive. Action granularity: Each statement performs one distinct action, making validation and delegation easy to distinguish. Reading flow: Constructors followed by configuration provide a natural progression, although inconsistent naming and minor whitespace issues interrupt an otherwise clean presentation.