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 well-structured with clear separation of concerns. The class has a single responsibility (number conversion) and methods are concise. Nesting is minimal—only in try-catch blocks. Clarity of intent is good due to descriptive method names and Javadoc comments. Action granularity is mostly one action per line. Reading flow is natural, with methods logically ordered. Minor issues: some blank lines are missing between methods, and the configure method contains an unnecessary blank line at the end. The cast method is trivial but adds a slight indirection. Overall, very readable.
Run 2
The code demonstrates strong readability overall. Structure is logical, following a standard converter implementation pattern with clear field declarations and constructor documentation. Nesting is minimal, limited to a single try-catch in each conversion method. Intent is explicit through descriptive method names, JavaDoc, and type parameters. Code length is appropriate - no unnecessary verbosity beyond standard exception handling. Action granularity is mostly one action per line, particularly in the configure and constructor methods. Reading flow is natural with methods grouped by interface implementation. Minor deductions: the assert statements could be replaced with constructor validation, the cast method is trivial, and the fromConnectData method has a slightly dense ternary expression. These are minor issues that don't significantly impact comprehension.
Run 3
The code is well-structured with a single, focused class that clearly implements Converter and HeaderConverter for numeric types. It maintains flat nesting throughout, with no deeply nested logic or conditionals beyond simple ternary expressions. Intent is explicit—each method has a clear purpose, and field names like serializer, deserializer, and typeName are descriptive. Code length is appropriate; no unnecessary verbosity or duplication, though some repetition could be reduced by consolidating error messages. Action granularity is mostly good, with one logical operation per line, though a few lines combine multiple assertions or method calls. Reading flow is natural: methods are logically ordered from construction to configuration to core conversion operations, and exception handling follows a predictable pattern. Minor deductions for slightly compacted lines (e.g., multiple assert statements, chained catch-and-rethrow with exception wrapping) and the unused schema parameter in fromConnectData, which could confuse intent. Overall, it is highly readable and maintainable.
Run 1
Code Structure: Fields, construction, configuration, conversion, and cleanup are logically organized into focused methods. Nesting: Shallow try/catch blocks and a simple ternary keep complexity low. Clarity of intent: Descriptive names, interface overrides, documentation, and informative exceptions make the purpose clear; the unchecked cast and StringConverterConfig reference introduce minor ambiguity. Code length: Concise overall, with header conversion delegating to existing methods rather than duplicating logic. Action granularity: Most lines perform one action, although nested serialization calls and the configuration ternary compress several operations. Reading flow: Consistent method patterns support natural reading, with minor disruptions from long lines and uneven blank-line spacing.
Run 2
Code Structure: Well-organized class with focused methods, grouped fields, and header conversion delegated to existing data conversion methods. Nesting: Minimal; try/catch blocks are shallow and straightforward. Clarity of intent: Descriptive names, interface overrides, and Javadoc clearly communicate numeric conversion behavior. The unchecked cast and use of StringConverterConfig in a numeric converter introduce minor ambiguity. Code length: Concise, with little duplication and appropriately short methods. Action granularity: Statements generally perform one action per line, though serialization and configuration expressions combine several operations. Reading flow: Natural progression from construction and configuration to conversion and cleanup. Minor formatting inconsistencies, including missing spacing between methods and an extra blank line, slightly reduce polish.
Run 3
Code Structure: Responsibilities are cleanly separated into configuration, conversion, header delegation, and cleanup methods. Nesting: Minimal nesting, limited to straightforward try/catch blocks. Clarity of intent: Descriptive names, generic typing, and documentation make the converter's purpose clear; the unchecked cast and use of StringConverterConfig in a number converter introduce minor ambiguity. Code length: Concise methods and delegation avoid unnecessary duplication, while constructor documentation adds useful context. Action granularity: Each statement performs one clear action, though serialization combines null handling, casting, and delegation in one expression. Reading flow: Methods follow a natural lifecycle order, and formatting is mostly consistent; missing spacing between some sections and an extra blank line slightly interrupt the flow.