Building a Simple Kafka Producer and Consumer using Python

Abhinav Nath — Sat, 01 Jun 2024 06:53:34 +0000

Let's create a simple mini project to interact with Kafka using Python.

We will build a simple message Producer and Consumer. Mini projects like this are helpful when you quickly want to test some behaviour of Kafka. So let's get started.

First off, let's spin up all the required components using this docker-compose.yml. It will start Zookeeper, Kafka and Kafdrop containers in your system.

Let's create our message Producer now.

We need to import KafkaProducer from the kafka library.

We have to specify the address of our Kafka server (which we created in the above step) while creating a KafkaProducer.

We need to pass these minimum parameters in the producer.send() method:

Topic name : we will use the name my_test_topic
value : the message itself
key (optional) : the key of the message


from kafka import KafkaProducer

bootstrap_servers = ['localhost:29092']
topic_name = 'my_test_topic'

producer = KafkaProducer(bootstrap_servers = bootstrap_servers)

future = producer.send(topic_name, key=b'1', value=b'This is message 1')

metadata = future.get()

print('message sent successfully on topic %s partition %s' % (metadata.topic, metadata.partition))

When we run our Producer, the specified Kafka topic (my_test_topic) gets created automatically and the message is sent to the topic.

Let's create the Consumer now. We need the server and topic name as above.

from kafka import KafkaConsumer
import sys

bootstrap_servers = ['localhost:29092']
topic_name = 'my_test_topic'

consumer = KafkaConsumer(
                         topic_name,
                         bootstrap_servers = bootstrap_servers,
                         auto_offset_reset = 'earliest',
                         enable_auto_commit = True,
                         group_id = 'my-group-1'
                        )

try:
    for message in consumer:
        print ("Message received - %s:%d:%d: key=%s value=%s" % (message.topic, message.partition, message.offset, message.key, message.value))
except KeyboardInterrupt:
    sys.exit()

Run the Consumer and it will receive the message sent by the Producer.

Thanks for reading! The source code is available in this GitHub repo.

Java Tidbits: Compare your Strings wisely!

Abhinav Nath — Sat, 25 May 2024 07:29:54 +0000

Welcome to the first installment of Java Tidbits, a series where I share small and simple Java tips to help with day-to-day development and help developers avoid common mistakes.

Let's begin

In Java, string comparison is a fundamental task, yet it often leads to subtle bugs if not done correctly. A common mistake among both new and experienced Java developers is using the .equals() method improperly during String comparisons.

In this blog, we'll explore why "SOME_STRING".equals(someObj.getText()) is a safer and more reliable way of comparing strings than someObj.getText().equals("SOME_STRING").

Understanding `.equals()` in Java

The equals() method in Java is used to compare the content of two strings for equality. Unlike the == operator, which checks if two references point to the same object, .equals() compares the actual characters in the strings.

String str1 = new String("hello");
String str2 = new String("hello");

System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2)); // true

The Common Pitfall

A common pattern you might see is:

if (someObj.getText().equals("SOME_STRING")) {
    // do something
}

At first glance, this seems perfectly fine. However, this approach has a hidden danger: if someObj.getText() returns null, it will throw a NullPointerException!

To avoid the risk of a NullPointerException, it is better to write the comparison as:

if ("SOME_STRING".equals(someObj.getText())) {
    // do something
}

Here's why this is better:

Null Safety: When "SOME_STRING" is a string literal, it is guaranteed to be non-null. Therefore, calling .equals() on it ensures that the method is always invoked on a valid object, even if someObj.getText() returns null. This prevents the dreaded NullPointerException.
Readability and Intent: Writing "SOME_STRING".equals(someObj.getText()) makes it immediately clear that you are comparing a constant value against a variable value. This enhances readability and intent of the code.
Consistency: Adopting this pattern consistently across your codebase helps in maintaining uniformity and reduces the chances of null-related bugs.

Conclusion

Both new and experienced developers can overlook this simple yet crucial detail. It's an easy mistake to make, especially when you're confident that the method (like someObj.getText()) won't return null.

Facing a NullPointerException because of this mistake can lead to the coding equivalent of slipping on a banana peel. It is an embarrassing stumble that can be easily avoided with a bit of defensive programming!