Source code
package org.apache.kafka.connect.converters;
import org.apache.kafka.common.config.ConfigDef;
import org.apache.kafka.common.errors.SerializationException;
import org.apache.kafka.common.serialization.Deserializer;
import org.apache.kafka.common.serialization.Serializer;
import org.apache.kafka.common.utils.Utils;
import org.apache.kafka.common.utils.internals.AppInfoParser;
import org.apache.kafka.connect.data.Schema;
import org.apache.kafka.connect.data.SchemaAndValue;
import org.apache.kafka.connect.errors.DataException;
import org.apache.kafka.connect.storage.Converter;
import org.apache.kafka.connect.storage.ConverterType;
import org.apache.kafka.connect.storage.HeaderConverter;
import org.apache.kafka.connect.storage.StringConverterConfig;
import java.util.HashMap;
import java.util.Map;
/**
* {@link Converter} and {@link HeaderConverter} implementation that only supports serializing to and deserializing from number values.
* It does support handling nulls. When converting from bytes to Kafka Connect format, the converter will always return the specified
* schema.
* <p>
* This implementation currently does nothing with the topic names or header keys.
*/
abstract class NumberConverter<T extends Number> implements Converter, HeaderConverter {
private final Serializer<T> serializer;
private final Deserializer<T> deserializer;
private final String typeName;
private final Schema schema;
/**
* Create the converter.
*
* @param typeName the displayable name of the type; may not be null
* @param schema the optional schema to be used for all deserialized forms; may not be null
* @param serializer the serializer; may not be null
* @param deserializer the deserializer; may not be null
*/
protected NumberConverter(String typeName, Schema schema, Serializer<T> serializer, Deserializer<T> deserializer) {
this.typeName = typeName;
this.schema = schema;
this.serializer = serializer;
this.deserializer = deserializer;
assert this.serializer != null;
assert this.deserializer != null;
assert this.typeName != null;
assert this.schema != null;
}
@Override
public String version() {
return AppInfoParser.getVersion();
}
@Override
public ConfigDef config() {
return NumberConverterConfig.configDef();
}
@Override
public void configure(Map<String, ?> configs) {
NumberConverterConfig conf = new NumberConverterConfig(configs);
boolean isKey = conf.type() == ConverterType.KEY;
serializer.configure(configs, isKey);
deserializer.configure(configs, isKey);
}
@Override
public void configure(Map<String, ?> configs, boolean isKey) {
Map<String, Object> conf = new HashMap<>(configs);
conf.put(StringConverterConfig.TYPE_CONFIG, isKey ? ConverterType.KEY.getName() : ConverterType.VALUE.getName());
configure(conf);
}
@SuppressWarnings("unchecked")
protected T cast(Object value) {
return (T) value;
}
@Override
public byte[] fromConnectData(String topic, Schema schema, Object value) {
try {
return serializer.serialize(topic, value == null ? null : cast(value));
} catch (ClassCastException e) {
throw new DataException("Failed to serialize to " + typeName + " (was " + value.getClass() + "): ", e);
} catch (SerializationException e) {
throw new DataException("Failed to serialize to " + typeName + ": ", e);
}
}
@Override
public SchemaAndValue toConnectData(String topic, byte[] value) {
try {
return new SchemaAndValue(schema, deserializer.deserialize(topic, value));
} catch (SerializationException e) {
throw new DataException("Failed to deserialize " + typeName + ": ", e);
}
}
@Override
public byte[] fromConnectHeader(String topic, String headerKey, Schema schema, Object value) {
return fromConnectData(topic, schema, value);
}
@Override
public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) {
return toConnectData(topic, value);
}
@Override
public void close() {
Utils.closeQuietly(this.serializer, "number converter serializer");
Utils.closeQuietly(this.deserializer, "number converter deserializer");
}
}
Run 1
The code is highly readable with a clear, logical structure. The class hierarchy and field declarations are well-organized, and method implementations are concise. Nesting is minimal—only conditional/ternary and try-catch blocks are used. Intent is clear from descriptive method/field names and Javadoc. Action granularity is excellent: most operations take one line, except for concise one-liners in `configure` and `fromConnectData` that still remain readable. Reading flow is natural, with methods grouped by interface responsibilities. Minor deductions: the `cast` method suppresses a warning and has a potentially confusing generic T parameter; the `configure` method has a blank line before the closing brace; and the constructor uses assertions instead of explicit argument validation, which slightly obscures runtime intent.
Run 2
The code is generally well-structured and readable. It has clear class and method organization, meaningful names, and reasonable Javadoc. Methods are concise and each performs a specific action. However, there are some issues that reduce clarity: the 'schema' parameter in 'fromConnectData' and 'fromConnectHeader' is unused, which may confuse readers about its purpose. The 'cast' method uses unchecked suppression without additional clarity on safety. The 'configure' method contains an unused local variable 'conf' and delegates in a way that slightly obscures flow. Nesting is minimal, and error handling is explicit. Overall, the code is approachable but could be improved by removing unused parameters and simplifying configuration delegation.
Run 3
The code is well-structured and readable. It has a clear class purpose, logical organization, and flat nesting. Method names are descriptive, and each action is generally one per line. The constructor uses asserts for validation, which is concise but may be less explicit than throwing exceptions. Minor issues include a blank line inside configure(), a long import for 'Utils', and the use of 'assert' which can be disabled. The try-catch blocks are simple and error handling is clear. Overall it is concise, maintainable, and easy to follow, but a few minor style inconsistencies and reliance on assertions prevent a top score.
Run 1
Code Structure: Fields, constructor, configuration, conversion, and cleanup methods are logically organized, with header conversion delegating to existing methods. Nesting: Minimal nesting; short try/catch blocks keep control flow straightforward. Clarity of intent: Descriptive names, documentation, and explicit exception messages communicate the converter’s purpose well. The unchecked cast and StringConverterConfig reference slightly obscure type safety and configuration intent. Code length: Concise methods and delegation avoid unnecessary duplication; documentation is proportionate. Action granularity: Statements generally perform one action per line, although serialization combines null handling, casting, and delegation in one expression. Reading flow: Consistent method patterns make the class easy to scan, with minor formatting issues such as missing separation before an annotation and an extra blank line in configure.
Run 2
Code Structure: Well-organized fields, constructor, configuration, conversion, and cleanup methods; header conversion delegates cleanly to shared logic. Nesting: Shallow, with only straightforward try/catch blocks and ternary expressions. Clarity of intent: Descriptive names, interface overrides, and documentation make the numeric converter's purpose clear, though the unchecked cast and StringConverterConfig constant slightly obscure implementation intent. Code length: Concise methods and minimal duplication keep the class compact; constructor documentation is somewhat repetitive. Action granularity: Statements generally perform one action per line, with modest expression complexity in serialization and configuration. Reading flow: Methods follow a natural lifecycle and conversion sequence. Minor formatting inconsistencies, including missing separation before one override and an extra blank line in configure, slightly reduce polish.
Run 3
Code Structure: Well-organized class with focused methods, grouped dependencies, and header conversion delegated to existing conversion methods. Nesting: Shallow, limited to straightforward try/catch blocks. Clarity of intent: Descriptive names, constructor documentation, and explicit exception messages make the converter's purpose clear; the unchecked generic cast and StringConverterConfig reference introduce minor ambiguity. Code length: Concise, with little duplication and appropriately short methods. Action granularity: Generally one action per line, though serialization combines null handling, casting, and delegation in one expression. Reading flow: Natural progression from construction through configuration, conversion, and cleanup. Minor formatting inconsistencies, including missing blank lines between some declarations and an extra blank line in configure, slightly reduce polish.