Custom SerDes in Kafka - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to implement the serialize method in a custom Kafka Serializer.

Kafka

public byte[] serialize(String topic, [1] data) {
    if (data == null) {
        return null;
    }
    return data.getBytes(StandardCharsets.UTF_8);
}

Drag options to blanks, or click blank then click option'

Aint

BString

Cbyte[]

DObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using int or Object as the data type causes compile errors.

Using byte[] as input is incorrect because serialize expects the original data type.

The serialize method takes the data to serialize, which is a String in this example, so the parameter type should be String.

2fill in blank

medium

Complete the code to implement the deserialize method in a custom Kafka Deserializer.

Kafka

public String deserialize(String topic, [1] data) {
    if (data == null) {
        return null;
    }
    return new String(data, StandardCharsets.UTF_8);
}

Drag options to blanks, or click blank then click option'

AObject

BString

Cint

Dbyte[]

Attempts:

3 left

💡 Hint

Common Mistakes

Using String as input causes errors because data is raw bytes.

Using int or Object as input is incorrect.

The deserialize method receives the data as a byte array, so the parameter type must be byte[].

3fill in blank

hard

Fix the error in the custom Serializer class declaration.

Kafka

public class CustomSerializer implements Serializer<[1]> {
    // implementation
}

Drag options to blanks, or click blank then click option'

AString

BInteger

Cbyte[]

DObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using byte[] or Object as generic type causes mismatch errors.

Using Integer when data is String causes type errors.

The Serializer interface should be parameterized with the data type you want to serialize, here String.

4fill in blank

hard

Fill both blanks to complete the custom Deserializer class declaration and method signature.

Kafka

public class CustomDeserializer implements Deserializer<[1]> {
    @Override
    public [2] deserialize(String topic, byte[] data) {
        if (data == null) return null;
        return new String(data, StandardCharsets.UTF_8);
    }
}

Drag options to blanks, or click blank then click option'

AString

Bbyte[]

DObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using byte[] as generic type or return type causes errors.

Mixing Object and String types causes type mismatch.

The Deserializer generic type and the deserialize method return type must both be String to match the data type.

5fill in blank

hard

Fill all three blanks to complete the custom SerDes class with serializer, deserializer, and configure method.

Kafka

public class CustomSerDes implements Serializer<[1]>, Deserializer<[2]> {

    @Override
    public byte[] serialize(String topic, [3] data) {
        if (data == null) return null;
        return data.getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public [2] deserialize(String topic, byte[] data) {
        if (data == null) return null;
        return new String(data, StandardCharsets.UTF_8);
    }

    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        // configuration code if needed
    }

    @Override
    public void close() {
        // cleanup code if needed
    }
}

Drag options to blanks, or click blank then click option'

AString

Bbyte[]

DObject

Attempts:

3 left

💡 Hint

Common Mistakes

Using byte[] or Object as generic or parameter types causes type errors.

Mismatch between generic types and method parameter/return types.

The SerDes class handles String data type for both serializer and deserializer, so all generic and parameter types are String.

Practice

1.

What is the main purpose of a custom SerDes in Kafka?

easy

A. To manage Kafka topic partitions

B. To speed up Kafka brokers

C. To control how data is converted to bytes and back

D. To monitor Kafka consumer lag

Solution

1. Step 1: Understand SerDes role

   SerDes stands for serializer-deserializer, which converts data to bytes and back.

2. Step 2: Identify main purpose

   Custom SerDes lets you control this conversion for special or complex data.

3. Final Answer:

   To control how data is converted to bytes and back -> Option C

4. Quick Check:

   Custom SerDes = Data conversion control [OK]

Hint: SerDes = Serializer + Deserializer for data [OK]

Common Mistakes:

• Confusing SerDes with Kafka broker settings
• Thinking SerDes manages partitions
• Assuming SerDes monitors consumer lag

2.

Which interface must you implement to create a custom serializer in Kafka?

easy

A. Serializer<T>

B. Consumer<T>

C. Producer<T>

D. Deserializer<T>

Solution

1. Step 1: Recall serializer interface

   Kafka requires implementing Serializer<T> to convert objects to bytes.

2. Step 2: Match interface to purpose

   Deserializer<T> is for reading bytes back, not serialization.

3. Final Answer:

   Serializer<T> -> Option A

4. Quick Check:

   Serializer interface = Serializer<T> [OK]

Hint: Serializer interface handles object to bytes [OK]

Common Mistakes:

• Choosing Deserializer for serialization
• Confusing Producer/Consumer with SerDes
• Using wrong generic interface

3.

Given this serializer code snippet, what will serialize() return for input "hello"?

public byte[] serialize(String topic, String data) {
    return data == null ? null : data.getBytes(StandardCharsets.UTF_8);
}

medium

A. [104, 101, 108, 108, 111]

B. null

C. ["h", "e", "l", "l", "o"]

D. Throws NullPointerException

Solution

1. Step 1: Understand serialize method

   If data is not null, it returns UTF-8 bytes of the string.

2. Step 2: Convert "hello" to bytes

   "hello" in UTF-8 bytes is [104, 101, 108, 108, 111].

3. Final Answer:

   [104, 101, 108, 108, 111] -> Option A

4. Quick Check:

   "hello" bytes = [104,101,108,108,111] [OK]

Hint: String.getBytes(UTF-8) returns byte array [OK]

Common Mistakes:

• Thinking it returns characters array
• Assuming null is returned for non-null input
• Expecting exception on valid input

4.

Identify the error in this deserializer code snippet:

public String deserialize(String topic, byte[] data) {
    return new String(data);
}

medium

A. No error, code is correct

B. Method should return byte[] not String

C. Parameter 'topic' is unused

D. Missing charset in String constructor

Solution

1. Step 1: Check String constructor usage

   Using new String(byte[]) without charset uses platform default, which can cause bugs.

2. Step 2: Identify best practice

   Always specify charset like StandardCharsets.UTF_8 for consistent decoding.

3. Final Answer:

   Missing charset in String constructor -> Option D

4. Quick Check:

   Specify charset in String(byte[]) [OK]

Hint: Always specify charset when converting bytes to String [OK]

Common Mistakes:

• Ignoring charset causes wrong decoding
• Thinking unused parameter is an error
• Assuming return type must be byte[]

5.

You want to send a complex object Person{name, age} through Kafka. Which approach best uses custom SerDes?

1. Create a PersonSerializer that converts Person to JSON bytes.
2. Create a PersonDeserializer that converts JSON bytes back to Person.
3. Register these SerDes in Kafka producer and consumer configs.

What is the main benefit of this approach?

hard

A. It speeds up Kafka message delivery

B. It allows sending complex objects as bytes safely and readably

C. It automatically partitions topics by age

D. It removes the need for Kafka brokers

Solution

1. Step 1: Understand custom SerDes for complex objects

   Serializing to JSON bytes lets complex objects be sent as byte arrays.

2. Step 2: Recognize benefit of JSON format

   JSON is readable and widely supported, making data safe and easy to deserialize.

3. Step 3: Confirm Kafka config usage

   Registering SerDes ensures Kafka knows how to convert data on send and receive.

4. Final Answer:

   It allows sending complex objects as bytes safely and readably -> Option B

5. Quick Check:

   Custom SerDes + JSON = safe complex data transfer [OK]

Hint: Use JSON SerDes for complex object safety [OK]

Common Mistakes:

• Thinking SerDes speeds up Kafka internals
• Assuming SerDes controls topic partitions
• Believing Kafka brokers are not needed