java发送数据到kafka

于 2024-09-05 21:25:37 发布
阅读量1.1k 收藏 22
点赞数 8
文章标签： linq c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33192454/article/details/141939629
版权 
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaException;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class KafkaTransactionalProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.1.1:9000,4.4.4.4:8888");
        props.put("security.protocol", "SASL_PLAINTEXT");
        props.put("sasl.mechanism", "SCRAM-SHA-256");
        props.put("sasl.kerberos.service.name", "target");
        props.put("sasl.jaas.config", "org.apache.kafka.common.security.scram.ScramLoginModule required username=\"ee\" password=\"eres\";");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, "true");
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "my-unique-transactional-id"); // 自定义唯一事务ID

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        try {
            producer.initTransactions(); // 初始化事务
            producer.beginTransaction(); // 开始事务

            String topic = "your_topic";
            String message = "{\"key\": \"value\"}"; // 要发送的消息
            ProducerRecord<String, String> record = new ProducerRecord<>(topic, message);
            
            producer.send(record, new Callback() {
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception != null) {
                        System.err.println("Error sending message: " + exception.getMessage());
                    } else {
                        System.out.println("Message sent successfully to topic " + metadata.topic() +
                                           " partition " + metadata.partition() +
                                           " with offset " + metadata.offset());
                    }
                }
            });

            producer.commitTransaction(); // 提交事务
        } catch (KafkaException e) {
            producer.abortTransaction(); // 事务失败，回滚
            e.printStackTrace();
        } finally {
            producer.close();
        }
    }
}
把这些代码改成一个独立的应用服务有自己的端口通过post请求传递json报文，然后给kafka发送消息

要将 Kafka 生产者代码改成一个独立的应用服务，能够通过 POST 请求接收 JSON 报文并将其发送到 Kafka，你可以使用 Spring Boot 框架来实现这个功能。Spring Boot 提供了便捷的 REST API 开发和配置管理功能。

以下是一个基于 Spring Boot 的示例项目，展示了如何实现这个需求：

1. 创建 Spring Boot 项目

首先，你需要创建一个 Spring Boot 项目。如果你使用 Spring Initializr，可以选择以下依赖：

  • Spring Web
  • Spring Kafka

2. 添加 Maven 依赖

在 pom.xml 文件中，确保包含以下依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>
</dependencies>

3. 配置 Kafka 生产者

在 application.properties 文件中配置 Kafka 生产者属性：

spring.kafka.producer.bootstrap-servers=10.1.1.1:9000,4.4.4.4:8888
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.enable-idempotence=true
spring.kafka.producer.acks=all
spring.kafka.producer.transaction-id-prefix=my-unique-transactional-id
spring.kafka.producer.properties.security.protocol=SASL_PLAINTEXT
spring.kafka.producer.properties.sasl.mechanism=SCRAM-SHA-256
spring.kafka.producer.properties.sasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username="ee" password="eres";
spring.kafka.producer.properties.sasl.kerberos.service.name=target

4. 实现 Kafka 生产者服务

创建一个 KafkaProducerService 类来处理消息发送：

package com.example.kafkaproducer.service;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    private final KafkaTemplate<String, String> kafkaTemplate;

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

    public void sendMessage(String topic, String message) {
        kafkaTemplate.executeInTransaction(kafkaTemplate -> {
            kafkaTemplate.send(topic, message).addCallback(new org.springframework.util.concurrent.ListenableFutureCallback<>() {
                @Override
                public void onSuccess(RecordMetadata result) {
                    System.out.println("Message sent successfully to topic " + result.topic() +
                                       " partition " + result.partition() +
                                       " with offset " + result.offset());
                }

                @Override
                public void onFailure(Throwable ex) {
                    System.err.println("Error sending message: " + ex.getMessage());
                }
            });
            return null;
        });
    }
}

5. 创建 REST Controller

实现一个 REST 控制器来处理 POST 请求：

package com.example.kafkaproducer.controller;

import com.example.kafkaproducer.service.KafkaProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class KafkaController {

    private final KafkaProducerService kafkaProducerService;

    @Autowired
    public KafkaController(KafkaProducerService kafkaProducerService) {
        this.kafkaProducerService = kafkaProducerService;
    }

    @PostMapping("/send")
    public String sendMessage(@RequestBody String message) {
        String topic = "your_topic";
        kafkaProducerService.sendMessage(topic, message);
        return "Message sent to Kafka";
    }
}

6. 启动 Spring Boot 应用

在你的 Application 类中启动 Spring Boot 应用：

package com.example.kafkaproducer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class KafkaProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaProducerApplication.class, args);
    }
}

7. 运行应用并测试

启动 Spring Boot 应用后，你可以通过 POST 请求将 JSON 消息发送到 http://localhost:8080/api/send，比如使用 curl：

curl -X POST http://localhost:8080/api/send -H "Content-Type: application/json" -d '{"key": "value"}'

这样，Kafka 生产者服务就可以通过 REST API 接收消息并将其发送到 Kafka 了。

上面的用java的1.8实现

如果你使用 Java 1.8，你可以按照以下步骤来实现一个独立的应用服务，该服务通过 POST 请求接收 JSON 报文并将其发送到 Kafka。我们将不使用 Spring Boot，而是使用更基础的 Java Servlet 技术来完成这个任务。

1. 创建 Maven 项目

确保你的 pom.xml 包含必要的依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Starter Kafka -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>

    <!-- JSON处理 -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version>
    </dependency>
</dependencies>

2. 配置 Kafka 生产者

创建 KafkaProducerConfig 类来配置 Kafka 生产者：

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class KafkaProducerConfig {

    public static Properties getProducerProperties() {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.1.1:9000,4.4.4.4:8888");
        props.put("security.protocol", "SASL_PLAINTEXT");
        props.put("sasl.mechanism", "SCRAM-SHA-256");
        props.put("sasl.kerberos.service.name", "target");
        props.put("sasl.jaas.config", "org.apache.kafka.common.security.scram.ScramLoginModule required username=\"ee\" password=\"eres\";");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, "true");
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "my-unique-transactional-id");
        return props;
    }
}

3. 实现 Kafka 生产者 Servlet

创建 KafkaProducerServlet 类来处理 POST 请求并将消息发送到 Kafka：

import com.google.gson.Gson;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/api/send")
public class KafkaProducerServlet extends HttpServlet {

    private KafkaProducer<String, String> producer;

    @Override
    public void init() throws ServletException {
        super.init();
        producer = new KafkaProducer<>(KafkaProducerConfig.getProducerProperties());
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String topic = "your_topic";
        StringBuilder stringBuilder = new StringBuilder();
        String line;
        while ((line = req.getReader().readLine()) != null) {
            stringBuilder.append(line);
        }

        String message = stringBuilder.toString();

        ProducerRecord<String, String> record = new ProducerRecord<>(topic, message);
        producer.send(record, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception != null) {
                    System.err.println("Error sending message: " + exception.getMessage());
                } else {
                    System.out.println("Message sent successfully to topic " + metadata.topic() +
                                       " partition " + metadata.partition() +
                                       " with offset " + metadata.offset());
                }
            }
        });

        resp.setContentType("text/plain");
        resp.getWriter().write("Message sent to Kafka");
    }

    @Override
    public void destroy() {
        super.destroy();
        if (producer != null) {
            producer.close();
        }
    }
}

4. 配置 web.xml

如果你不使用注解，可以在 web.xml 中配置 Servlet：

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>KafkaProducerServlet</servlet-name>
        <servlet-class>com.example.KafkaProducerServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>KafkaProducerServlet</servlet-name>
        <url-pattern>/api/send</url-pattern>
    </servlet-mapping>

</web-app>

5. 部署和运行

将你的应用打包成一个 WAR 文件并部署到支持 Servlet 的服务器（如 Apache Tomcat）。然后，你可以通过 POST 请求将 JSON 消息发送到 http://localhost:8080/your-app/api/send。

例如，使用 curl 来测试：

bashcurl -X POST http://localhost:8080/your-app/api/send -H "Content-Type: application/json" -d '{"key": "value"}'

这样，你就完成了将 Kafka 生产者代码改成一个独立的应用服务，通过 POST 请求接收 JSON 报文并发送到 Kafka 的任务。

上面的用java的1.8springboot实现

要使用 Java 1.8 和 Spring Boot 实现一个独立的应用服务，通过 POST 请求接收 JSON 报文并将其发送到 Kafka，你可以按照以下步骤进行。

1. 创建 Spring Boot 项目

可以使用 Spring Initializr 来创建一个新的 Spring Boot 项目。选择以下依赖：

  • Spring Web
  • Spring Kafka

2. 添加 Maven 依赖

在 pom.xml 文件中添加 Kafka 和 Spring Boot 相关的依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Starter Kafka -->
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>

    <!-- JSON处理 -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version>
    </dependency>
</dependencies>

3. 配置 Kafka 生产者

在 application.properties 文件中配置 Kafka 生产者属性：

spring.kafka.producer.bootstrap-servers=10.1.1.1:9000,4.4.4.4:8888
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.enable-idempotence=true
spring.kafka.producer.acks=all
spring.kafka.producer.transaction-id-prefix=my-unique-transactional-id
spring.kafka.producer.properties.security.protocol=SASL_PLAINTEXT
spring.kafka.producer.properties.sasl.mechanism=SCRAM-SHA-256
spring.kafka.producer.properties.sasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username="ee" password="eres";
spring.kafka.producer.properties.sasl.kerberos.service.name=target

4. 创建 Kafka 生产者服务

创建一个 KafkaProducerService 类来处理消息发送：

package com.example.kafkaproducer.service;

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    private final KafkaTemplate<String, String> kafkaTemplate;

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

    public void sendMessage(String topic, String message) {
        kafkaTemplate.executeInTransaction(kafkaTemplate -> {
            kafkaTemplate.send(topic, message).addCallback(new ListenableFutureCallback<>() {
                @Override
                public void onSuccess(RecordMetadata result) {
                    System.out.println("Message sent successfully to topic " + result.topic() +
                                       " partition " + result.partition() +
                                       " with offset " + result.offset());
                }

                @Override
                public void onFailure(Throwable ex) {
                    System.err.println("Error sending message: " + ex.getMessage());
                }
            });
            return null;
        });
    }
}

5. 创建 REST Controller

创建一个 REST 控制器来处理 POST 请求：

package com.example.kafkaproducer.controller;

import com.example.kafkaproducer.service.KafkaProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class KafkaController {

    private final KafkaProducerService kafkaProducerService;

    @Autowired
    public KafkaController(KafkaProducerService kafkaProducerService) {
        this.kafkaProducerService = kafkaProducerService;
    }

    @PostMapping("/send")
    public String sendMessage(@RequestBody String message) {
        String topic = "your_topic";
        kafkaProducerService.sendMessage(topic, message);
        return "Message sent to Kafka";
    }
}

6. 启动 Spring Boot 应用

在你的 Application 类中启动 Spring Boot 应用：

package com.example.kafkaproducer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class KafkaProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaProducerApplication.class, args);
    }
}

7. 运行应用并测试

启动 Spring Boot 应用后，你可以通过 POST 请求将 JSON 消息发送到 http://localhost:8080/api/send，例如使用 curl：

package com.example.kafkaproducer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class KafkaProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaProducerApplication.class, args);
    }
}

额外提示

  1. 异常处理: 在实际应用中，你可能需要添加更完善的异常处理和日志记录。
  2. 安全性: 确保你的应用具有适当的安全配置，尤其是对外暴露的 API。

这样，你就完成了使用 Java 1.8 和 Spring Boot 实现 Kafka 生产者服务的任务，通过 POST 请求接收 JSON 报文并将其发送到 Kafka。

public void onSuccess(RecordMetadata result) { 我这个继承的参数不是RecordMetadata result

如果你的 onSuccess 方法的参数不是 RecordMetadata result，那么你可能在使用 ListenableFutureCallback 接口的实现时遇到了问题。在 Kafka 的生产者 API 中，ListenableFutureCallback 接口通常用于处理 send 方法的回调。

请确保你正确地实现了 ListenableFutureCallback 接口。以下是一个完整的示例，展示了如何实现 Kafka 生产者的回调处理，包括 onSuccess 和 onFailure 方法。

完整示例：KafkaProducerService 类

在这个示例中，我们将使用 ListenableFutureCallback 处理 Kafka 生产的结果。

package com.example.kafkaproducer.service;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Service
public class KafkaProducerService {

    private final KafkaTemplate<String, String> kafkaTemplate;

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

    public void sendMessage(String topic, String message) {
        kafkaTemplate.executeInTransaction(kafkaTemplate -> {
            kafkaTemplate.send(topic, message).addCallback(new ListenableFutureCallback<>() {
                @Override
                public void onSuccess(RecordMetadata result) {
                    System.out.println("Message sent successfully to topic " + result.topic() +
                                       " partition " + result.partition() +
                                       " with offset " + result.offset());
                }

                @Override
                public void onFailure(Throwable ex) {
                    System.err.println("Error sending message: " + ex.getMessage());
                }
            });
            return null;
        });
    }
}

关键点

  1. KafkaTemplate 的回调: 使用 kafkaTemplate.send().addCallback 方法可以处理消息发送的结果。addCallback 方法接受一个 ListenableFutureCallback 对象来处理成功和失败的回调。

  2. 实现 ListenableFutureCallback: ListenableFutureCallback 是 Spring 提供的接口，用于处理异步操作的成功和失败结果。你需要实现 onSuccess 和 onFailure 方法。

  3. ProducerRecord 和 RecordMetadata: ProducerRecord 用于构建消息记录，RecordMetadata 用于接收发送消息后的元数据。

使用 Callback 接口的示例

如果你直接使用 Kafka 的 Callback 接口而不是 Spring 的 ListenableFutureCallback，示例如下：

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.RecordMetadata;

public class KafkaProducerCallback implements Callback {
    @Override
    public void onCompletion(RecordMetadata metadata, Exception exception) {
        if (exception != null) {
            System.err.println("Error sending message: " + exception.getMessage());
        } else {
            System.out.println("Message sent successfully to topic " + metadata.topic() +
                               " partition " + metadata.partition() +
                               " with offset " + metadata.offset());
        }
    }
}

然后在 KafkaProducerService 中使用这个 Callback 类：

public void sendMessage(String topic, String message) {
    kafkaTemplate.executeInTransaction(kafkaTemplate -> {
        kafkaTemplate.send(topic, message).addCallback(new KafkaProducerCallback());
        return null;
    });
}

这样，你就可以确保 Kafka 消息发送的结果被正确地处理，无论是成功还是失败。

public void onSuccess(RecordMetadata result) { 我这个继承的参数shi Object o怎么回事

如果你在实现 Kafka 生产者的回调时遇到了 onSuccess 方法的参数类型为 Object o 的问题，这可能是由于使用了不同的回调接口或配置。

在 Kafka 中，send 方法的回调接口通常是 Callback，其 onCompletion 方法的签名如下：

void onCompletion(RecordMetadata metadata, Exception exception);

如果你的实现中 onSuccess 方法的参数类型是 Object，可能你在使用的是与 Kafka 原生 API 不匹配的回调接口或在自定义实现时出现了问题。

确保使用正确的回调接口

以下是如何正确实现 Kafka 的 Callback 接口，并处理 onSuccess 和 onFailure 方法：

1. Kafka Callback 接口的正确实现
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.clients.producer.ProducerRecord;

public class KafkaProducerCallback implements Callback {
    @Override
    public void onCompletion(RecordMetadata metadata, Exception exception) {
        if (exception != null) {
            System.err.println("Error sending message: " + exception.getMessage());
        } else {
            System.out.println("Message sent successfully to topic " + metadata.topic() +
                               " partition " + metadata.partition() +
                               " with offset " + metadata.offset());
        }
    }
}
2. 使用 Kafka Callback 的 send 方法

在 Kafka 生产者服务中使用上述回调：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducerService {

    private final KafkaTemplate<String, String> kafkaTemplate;

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

    public void sendMessage(String topic, String message) {
        kafkaTemplate.executeInTransaction(kafkaTemplate -> {
            kafkaTemplate.send(topic, message).addCallback(new KafkaProducerCallback());
            return null;
        });
    }
}

自定义实现中的 Object o 问题

如果你看到 onSuccess(Object o)，这可能是你在自定义回调或在其他上下文中使用了不同的回调接口。请检查以下几点：

  1. 检查回调接口类型：确保你的回调接口实现的是 Kafka 的 Callback 接口，而不是其他的接口或自定义接口。

  2. 回调方法的签名：确保 onSuccess 方法的签名与 Callback 接口的要求匹配。如果你的代码中 onSuccess 方法接受 Object 类型的参数，可能需要更改为 RecordMetadata 类型。

  3. 代码示例：确保在代码中，send 方法的回调处理与 Kafka 的回调接口一致。

结论

确保你使用的回调接口正确且实现了 Kafka 的 Callback 接口，以便 onCompletion 方法可以正确处理消息的发送结果。如果你遇到不同类型的回调接口，可能需要检查代码的其他部分或依赖项以确保一致

qq_33192454
关注
java向kafka推送数据_Java kafka消息的发送与接收
weixin_39522103的博客
12-19 1370
一.项目工程结构二.详细代码KafkaUtils.javapackage com.bijian.study;import java.util.Arrays;import java.util.Date;import java.util.Properties;import org.apache.kafka.clients.consumer.Consumer;import org.apache.kafk...
在Java中发送kafka消息
qq_38515961的博客
05-06 9929
文章目录一、kafka API简介二、引入kafka java客户端依赖三、发送消息 一、kafka API简介 kafka包含5个核心api： Producer API用来让应用程序发送流数据到kafka集群中的主题。 Consumer API用来让应用程序读取kafka集群主题中的流数据。 Streams API 用来从输入主题到输出主题转换流数据。 Connect API 用来实现连接器，持续的从数据源或应用程序推送数据到kafka，或从kafka中拉取数据。 AdminClient API用来管理
kafka用java收发消息
最新发布
IT深耕十余载，大道之简
05-23 1196
Kafka 是一个分布式流处理平台，它允许你发布和订阅记录流，类似于消息队列或企业消息系统。下面我将为你展示如何使用 Java 来发送（生产者）和接收（消费者）Kafka 中的消息。
kafka 发送和接收消息-Java版
07-29
kafka 发送和接收消息-Java版
Java使用kafka发送和生产消息的示例
08-27
本篇文章主要介绍了Java使用kafka发送和生产消息的示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
csv-kafka-json:一个简单的Java程序以JSON格式将CSV文件发送到Kafka主题
05-26
- Kafka主题：指定要发送数据的主题名称。 - CSV文件路径：指定要处理的CSV文件的位置。 - JSON编码设置：如是否保留原始CSV格式，或者如何处理特殊字符等。 通过这个程序，用户可以方便地将CSV数据实时导入到Kafka...
java mysql发送数据到kafka，消费数据之后将数据保存进hive
weixin_44366140的博客
06-17 1061
一.连接mysql public class JdbcToMysql { private static Connection connection = JdbcConnecMysql.getConnection(); private static PreparedStatement ps; private static ResultSet resultSet; public static List<Table> getData(String tables) {
java 发送数据到flume_flume接收http请求，并将数据写到kafka
weixin_39848007的博客
02-13 932
flume接收http请求，并将数据写到kafka，spark消费kafka的数据。是数据采集的经典框架。直接上flume的配置：source : httpchannel : filesink : kafkaxx :~/software/flume1.8/conf$ cat http-file-kafka.conf# example.conf: A single-node Flume config...
Kafka-Java客户端数据生产流程解析，从发送类型实现代码到序列化器实现代码！
2401_84415615的博客
04-19 1249
**自定义序列化器*/@Override@Overridetry {= null) {} else {= null) {} else {@Override使用自定义的序列化器Company company = Company.builder().name(“kafka”) .address(“北京”).build();
java 向kafka推送消息
qq_39382867的博客
02-16 3041
import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerConfig; import org.apache.kafka.clients.producer.ProducerRecord; import org.apache.kafka.common.serialization.IntegerSerializer; import org.apache.kaf.
kafka应用场景_Kafka系列文章之Kafka是什么第1篇
weixin_39788451的博客
12-03 121
前言如果有幸目睹过系统从零到一的演变过程，大家估计都会有一种感叹，就是随着业务复杂度和流量的不断上升，系统变得越来越难以维护，面对高额的维护成本，攻城师们不得不对现有架构进行改造升级，以便使得系统更适合当下业务的发展。说到架构改造升级，那到底该怎么改造呢？从哪里入手比较合适呢？这是一个比较大的话题，一两句话没办法讲述清楚，但是有一个出发点肯定是没有错的，就是为了更好的适应业务的发展需要进...
java客户端发消息到kafka
congge_study的博客
02-27 8582
java客户端发消息到kafka
Java实现kafka消息发送（仅做入门）
左撇子帕布
03-09 5805
1. 小声哔哔 kafka消息发送有三种方式，发送并忘记、同步发送和异步发送，下面直接使用代码演示，当然这里的实现代码仅做入门学习参考，真正的生产环境必然涉及多线程生产消息，配置统一规划等情况。 2. 发送并忘记 首先写一个简单的消费者代码作为结果验证： package com.coline.middleware.kafka.consumer; import org.a...
java Kafka生产者推送数据与消费者接收数据（参数配置以及案例）_java实现kafka消息发送和接收
2401_84164721的博客
04-08 1070
以上大数据开发知识点，真正体系化！**
java发送kafka事务消息
congge_study的博客
02-28 7265
java发送kafka事务消息
本地搭建kafka并用java实现发送消费消息
小趴菜的小蛋泡
09-25 988
调用send发送1-100消息到指定Topic test。需要启动上面的操作 启动kafka 建立主题，启动zk。发送kafka的测试，消费者直接消费。首先下载一个可视化软件。
Kafka-Java一：Spring实现kafka消息的简单发送_kafka发送对象消息
2301_76348344的博客
04-30 486
/ 配置消息 键值的序列化规则。// 配置消息 键值的序列化规则。// 配置kafka地址。// 配置kafka地址。
kafka 往cdh 6的kafka写数据成功
weixin_34198881的博客
02-11 593
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值