糟糕！我被kafka包围了

环境配置
spring:
kafka:
bootstrap-servers: localhost:9092 # 端口
producer:
# 发生错误后，消息重发的次数。
retries: 1
#当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。
batch-size: 16384
# 设置生产者内存缓冲区的大小。
buffer-memory: 33554432
# 键的序列化方式
key-serializer: org.apache.kafka.common.serialization.StringSerializer
# 值的序列化方式
value-serializer: org.apache.kafka.common.serialization.StringSerializer
# acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
# acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
# acks=all ：只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
acks: 1

…
#消费者通过加入同一个群组来协同工作，实现消息的并行处理或消息的可靠传递#（即至少一次消费保证）。koshi-group就是这个群组的名字。当有多个消费者##实例共享同一个群组ID时，Kafka会确保每个消息只被该群组中的一个消费者消##费。

配置主题

kafka:
topic:
group: koshi-group
user: koshi-topic
建立消息模板类
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.ExecutionException;

@Component
public class GenericEventPublisher {

private static final Logger log = LoggerFactory.getLogger(GenericEventPublisher.class);

private final KafkaTemplate<String, String> kafkaTemplate;

@Autowired
public GenericEventPublisher(KafkaTemplate<String, String> kafkaTemplate) {
    this.kafkaTemplate = kafkaTemplate;
}

/**
 * 发布事件消息到Kafka。
 * @param topic Kafka主题
 * @param key 消息键（可选）
 * @param eventMessage 事件消息对象，将被转换为JSON字符串
 * @throws ExecutionException 如果发送操作引发执行时异常
 * @throws InterruptedException 如果当前线程在等待时被中断
 */
public void publish(String topic, String key, T eventMessage) throws ExecutionException, InterruptedException {
    try {
        String messageJson = JSON.toJSONString(eventMessage);
        ListenableFuture<RecordMetadata> future = kafkaTemplate.send(topic, key, messageJson);
        future.addCallback(
            success -> log.info("发送MQ消息成功, topic: {}, key: {}, message: {}", topic, key, messageJson),
            failure -> log.error("发送MQ消息失败, topic: {}, key: {}, message: {}", topic, key, messageJson, failure)
        );
        // 如果需要同步等待发送结果，可以使用future.get()
    } catch (Exception e) {
        log.error("发送MQ消息异常, topic: {}, message: {}", topic, JSON.toJSONString(eventMessage), e);
        throw e;
    }
}

}
事件定义类
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderCreatedEvent {
private String orderId;
private String userId;
private String productName;
private int quantity;
// 其他可能的属性…
}
发布事件
@Service
public class OrderService {

@Autowired
private GenericEventPublisher<OrderCreatedEvent> eventPublisher;

public void createOrder(Order order) {
    // 逻辑处理，创建订单...

    // 订单创建成功后，发布事件
    OrderCreatedEvent event = new OrderCreatedEvent(order.getOrderId(), order.getUserId(), order.getProductName(), order.getQuantity());
    try {
        eventPublisher.publish("order.created", order.getOrderId().toString(), event);
        log.info("Order created event published. Order ID: {}", order.getOrderId());
    } catch (ExecutionException | InterruptedException e) {
        log.error("Failed to publish order created event.", e);
        // 可能需要回滚事务或进行错误处理
    }
}

}
监听消息队列
import org.springframework.kafka.annotation.KafkaListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSON;
import com.koshi.event.OrderCreatedEvent;

@Service
public class OrderEventListener {

private static final Logger log = LoggerFactory.getLogger(OrderEventListener.class);

@KafkaListener(topics = "order.created", groupId = "order-group")
public void listenForOrderEvents(String message) {
    try {
        OrderCreatedEvent event = JSON.parseObject(message, OrderCreatedEvent.class);
        log.info("Received OrderCreatedEvent: {}", event);
        // 这里执行实际的业务逻辑，比如更新数据库、发送邮件通知等
    } catch (Exception e) {
        log.error("Error processing OrderCreatedEvent: ", e);
    }
}

}