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 well-structured and readable. It has a clear single responsibility (number conversion), follows a flat class layout, and uses meaningful names like NumberConverter, cast, fromConnectData, and toConnectData. Nesting is minimal, with only small try-catch blocks that are easy to follow. Most methods perform a single logical action or a short sequence. The constructor uses assertions to document non-null expectations, and Javadocs add clarity. Minor issues: some methods (e.g., configure) could be slightly more compact, and the cast method's @SuppressWarnings is necessary but slightly noisy. Overall, the code is highly maintainable and understandable.
Run 3
The code is generally readable and well-structured. It has a clear purpose (number conversion), flat methods with good action granularity, and descriptive naming. The constructor and methods are concise, and error handling is centralized. Minor deductions include the use of `assert` for argument validation (which can be disabled in production) instead of `Objects.requireNonNull`, a slightly overloaded ternary in `fromConnectData`, and an unnecessary empty line in `configure`. Additionally, the `cast` method is simple but relies on unchecked casting, which is acceptable given the `@SuppressWarnings`. Overall, the reading flow is logical, and the code is easy to follow.
Run 1
Code Structure: Fields, construction, configuration, conversion, and cleanup are logically organized into focused methods. Nesting: Minimal nesting; short try/catch blocks keep control flow straightforward. Clarity of intent: Descriptive names, interface overrides, and documentation make the converter's purpose clear. The unchecked generic cast and use of StringConverterConfig in a numeric converter introduce minor ambiguity. Code length: Concise overall, with header methods delegating to existing conversion logic rather than duplicating it. Action granularity: Statements generally perform one action per line, although nested calls and a ternary expression slightly compress serialization logic. Reading flow: Natural and consistent, with minor formatting issues such as missing separation between methods and an extra blank line. Long signatures and error-message expressions slightly reduce scanability.
Run 2
Code Structure: Well-organized class with focused methods for configuration, conversion, header delegation, and cleanup. Nesting: Minimal; only straightforward try/catch blocks and inline conditionals. Clarity of intent: Descriptive names, explicit types, and useful documentation make the purpose clear, though the unchecked generic cast and StringConverterConfig reference require extra interpretation. Code length: Concise overall, with delegation avoiding duplicated conversion logic. Action granularity: Generally one action per line; a few long expressions combine casting, serialization, or configuration selection. Reading flow: Natural progression from initialization to configuration, conversion, and cleanup. Minor formatting inconsistencies, such as missing spacing between methods and an extra blank line in configure, slightly reduce polish.
Run 3
Code Structure: Responsibilities are organized into small, focused methods, with header conversion delegating to data conversion to avoid duplication. Nesting: Very shallow; only straightforward try/catch blocks and inline conditional expressions. Clarity of intent: Descriptive names, interface overrides, and useful documentation make the converter's purpose clear. The unchecked cast and reference to StringConverterConfig within a numeric converter slightly reduce clarity. Code length: Concise for the functionality provided, with little unnecessary code. Action granularity: Statements generally perform one action per line; serialization expressions combine a few closely related operations without becoming difficult to follow. Reading flow: Fields, construction, configuration, conversion, and cleanup follow a natural sequence. Minor formatting inconsistencies, including missing separation between methods and an extra blank line, slightly interrupt the otherwise clean presentation.