仅生产者绑定的Kafka Streams咨询：能否无消费直接发消息？

完全可以，但更推荐用Spring Cloud Stream的普通生产者绑定（而非Kafka Streams）来适配你的场景——毕竟Kafka Streams本质是流处理框架，主打消费-处理-生产的流式链路，单纯用来发消息属于大材小用。

方案一：Spring Cloud Stream普通生产者（更适配） #

不需要依赖Kafka Streams，直接定义输出绑定即可实现仅生产者功能：

1. 配置application.yml：

spring:
  cloud:
    stream:
      kafka:
        binder:
          brokers: localhost:9092 # 替换为你的Kafka集群地址
      bindings:
        output-topic: # 自定义输出绑定名称
          destination: your-target-topic # 要发送的目标Kafka Topic名
          content-type: application/json # 根据你的数据格式调整（如text/plain）

2. 创建生产者服务：

import org.springframework.cloud.stream.function.StreamBridge;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class KafkaBatchProducer {

    private final StreamBridge streamBridge;

    public KafkaBatchProducer(StreamBridge streamBridge) {
        this.streamBridge = streamBridge;
    }

    public void sendBatchRecords(List<Record> records) {
        records.forEach(record -> 
            streamBridge.send("output-topic", record)
        );
    }
}

3. 在REST接口中触发发送：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
public class RecordPublishController {

    private final KafkaBatchProducer batchProducer;

    public RecordPublishController(KafkaBatchProducer batchProducer) {
        this.batchProducer = batchProducer;
    }

    @PostMapping("/publish-records")
    public void publishBatchRecords(@RequestBody List<Record> records) {
        batchProducer.sendBatchRecords(records);
    }
}

这个方案完全匹配你的需求：仅作为生产者，通过REST请求触发批量消息发送，是Spring Cloud Stream最原生的生产者用法，轻量且贴合场景。

方案二：硬用Kafka Streams实现（不推荐） #

如果一定要基于Kafka Streams实现，也可以通过创建空流源绕过消费环节，但逻辑会很生硬：

1. 配置Kafka Streams：

spring:
  kafka:
    streams:
      bootstrap-servers: localhost:9092
      application-id: rest-producer-demo

2. 编写发送逻辑：

import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.List;
import java.util.concurrent.CompletableFuture;

@Component
public class KafkaStreamsBatchSender {

    private final KafkaStreams kafkaStreams;

    public KafkaStreamsBatchSender(StreamsBuilder streamsBuilder) {
        // 创建一个指向不存在的dummy Topic的空流，避免实际消费数据
        streamsBuilder.stream("dummy-empty-topic");
        this.kafkaStreams = new KafkaStreams(streamsBuilder.build(), null);
    }

    @PostConstruct
    public void startStreams() {
        kafkaStreams.start();
    }

    public void sendBatch(List<Record> records) {
        CompletableFuture.runAsync(() -> {
            records.forEach(record -> 
                kafkaStreams.send(producerRecord -> 
                    new ProducerRecord<>("your-target-topic", record)
                )
            );
        });
    }
}

这种方式存在明显弊端：Kafka Streams会一直尝试消费不存在的dummy-empty-topic，且框架本身的资源开销完全没必要，纯粹为了用Kafka Streams而强行适配。

总结 #

优先选择方案一：Spring Cloud Stream普通生产者绑定，既满足你通过REST触发批量发送到Kafka的需求，又避免了不必要的资源浪费。

内容的提问来源于stack exchange，提问作者quintin