Phind.com. AI -

 I have found a AI site  https://www.phind.com/ where i give the following question: 

java code in quarkus and kafka to produce "working" class using avro with topic "working" using cronos expression from 30 seconds interval , also create client to listen if the message was send to the topic

ANSWER | PHIND INSTANT MODEL

To achieve your goal of producing a "working" class using Avro in Quarkus with Kafka, targeting a topic named "working", and setting up a consumer to listen for messages sent to this topic with a cron schedule every 30 seconds, follow these steps:

Step 1: Add Dependencies

First, ensure you have the necessary dependencies in your pom.xml file for Quarkus, Kafka, and Avro support.

<dependencies>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-kafka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.avro</groupId>
        <artifactId>avro</artifactId>
    </dependency>
    <!-- Include other necessary Quarkus extensions -->
</dependencies>

Step 2: Define Your Avro Schema

Create an Avro schema for your "working" class. This example assumes a simple class structure; adjust according to your needs.

// Working.avsc
{
  "namespace": "com.example",
  "type": "record",
  "name": "Working",
  "fields": [
    {"name": "id", "type": "string"},
    {"name": "status", "type": "string"}
  ]
}

Generate Java classes from this schema using Avro tools or a plugin like maven-avro-plugin.

Step 3: Produce Messages

Implement a producer that sends messages to the "working" topic. Use a cron schedule to control the frequency of message production.

import io.smallrye.reactive.messaging.kafka.Record;
import org.apache.avro.generic.GenericRecord;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.time.Duration;
import java.util.concurrent.TimeUnit;

@Path("/produce")
@ApplicationScoped
public class Producer {

    @Inject
    @KafkaClient("kafka-client")
    Channel<KStream<String, GenericRecord>> channel;

    public void start() {
        // Schedule the producer to run every 30 seconds
        Timer.scheduleAtFixedRate(this::sendMessages, Duration.ofSeconds(30), Duration.ofSeconds(30));
    }

    private void sendMessages() {
        try {
            var working = new Working();
            working.setId("123");
            working.setStatus("working");

            Record<String, GenericRecord> record = Record.of("key", working);
            channel.send(record).await().indefinitely();

            System.out.println("Message sent successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Step 4: Consume Messages

Set up a consumer to listen for messages on the "working" topic. Use a cron schedule to trigger consumption every 30 seconds.

import io.smallrye.reactive.messaging.annotations.Blocking;
import io.smallrye.reactive.messaging.annotations.Channel;
import io.smallrye.reactive.messaging.annotations.Consumer;
import io.smallrye.reactive.messaging.annotations.OnPartitionOffset;
import org.apache.avro.generic.GenericRecord;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class Consumer {

    @Channel("kafka-client")
    @Consumer(blocking = Blocking.BLOCK_IF_NO_MESSAGES)
    KStream<String, GenericRecord> stream;

    @OnPartitionOffset
    void consume(String partition, Long offset) {
        System.out.println("Consumed message from partition " + partition + " at offset " + offset);
    }
}

Step 5: Configure Quarkus Application Properties

Configure your application.properties file to set up Kafka clients and topics.

# Kafka configuration
quarkus.kubernetes.deployment.enabled=true
quarkus.kafka.bootstrap.servers=localhost:9092
quarkus.kafka.clients.producer.topic=working
quarkus.kafka.clients.consumer.topic=working
quarkus.kafka.clients.consumer.group-id=my-group

# Cron scheduling
quarkus.scheduler.cron-expressions=0/30 * * * *

This setup uses Quarkus' reactive messaging capabilities to produce and consume messages with Avro serialization. Adjust configurations and code as needed for your specific requirements.