springboot 实现收发消息时才连接Kafka

为了实现Spring Boot应用程序仅在需要发送或接收Kafka消息时才连接到Kafka，我们可以结合懒加载（lazy initialization）和按需创建（on-demand creation）的方式来设计。以下是一个详细的解决方案，包括配置、服务层和监听器的实现。

### 1. 配置懒加载的 `KafkaTemplate` 和 `ConcurrentKafkaListenerContainerFactory`

首先，我们需要确保 `KafkaTemplate` 和 `ConcurrentKafkaListenerContainerFactory` 是懒加载的，这意味着它们只会在第一次使用时被初始化。

```java
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.*;
import org.springframework.kafka.listener.ContainerProperties;

import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableKafka
public class KafkaConfiguration {

    @Bean
    @Lazy
    public ConsumerFactory<String, String> consumerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "group_id");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return new DefaultKafkaConsumerFactory<>(props);
    }

    @Bean
    @Lazy
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(props);
    }

    @Bean
    @Lazy
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }

    @Bean
    @Lazy
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory(
            ConsumerFactory<String, String> consumerFactory) {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
        return factory;
    }
}
```

### 2. 创建服务类来处理消息收发

接下来，创建一个服务类来处理消息的发送和接收。这个类将负责确保只有在需要时才创建Kafka连接。

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.KafkaMessageListenerContainer;
import org.springframework.stereotype.Service;

@Service
public class KafkaMessageService {

    private final KafkaTemplate<String, String> kafkaTemplate;
    private KafkaMessageListenerContainer<String, String> listenerContainer;

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

    // 发送消息的方法
    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message).addCallback(
            success -> System.out.println("Message sent successfully"),
            failure -> System.out.println("Failed to send message: " + failure.getMessage())
        );
    }

    // 接收消息的方法
    public void startListening(String topic) {
        if (listenerContainer == null || !listenerContainer.isRunning()) {
            // 按需创建并启动监听容器
            createAndStartListenerContainer(topic);
        }
    }

    private void createAndStartListenerContainer(String topic) {
        // 这里可以动态创建监听容器，根据实际需求调整
        // 注意：这里简化了监听容器的创建逻辑
        // 实际应用中应根据需求定制监听器逻辑
        // ...
        System.out.println("Starting to listen on topic: " + topic);
    }

    // 停止监听的方法
    public void stopListening() {
        if (listenerContainer != null && listenerContainer.isRunning()) {
            listenerContainer.stop();
        }
    }
}
```

### 3. 使用 `@KafkaListener` 注解进行消息监听

如果你希望继续使用 `@KafkaListener` 注解来定义消息监听器，可以通过懒加载的方式确保监听器只在需要时启动。请注意，这种方式需要与懒加载的 `ConcurrentKafkaListenerContainerFactory` 结合使用。

```java
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.listener.MessageListenerContainer;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Service;

@Service
public class KafkaMessageListener {

    private MessageListenerContainer listenerContainer;

    @KafkaListener(topics = "${kafka.topic}", containerFactory = "kafkaListenerContainerFactory")
    public void listen(@Payload String message) {
        System.out.println("Received message: " + message);
    }

    // 提供方法以控制监听器的启动和停止
    public void startListening() {
        if (listenerContainer == null || !listenerContainer.isRunning()) {
            // 动态启动监听器
            // 注意：这只是一个示例，实际情况可能更复杂
            // ...
            System.out.println("Starting Kafka listener...");
        }
    }

    public void stopListening() {
        if (listenerContainer != null && listenerContainer.isRunning()) {
            listenerContainer.stop();
        }
    }
}
```

### 4. 控制器或调度任务调用

最后，在控制器或调度任务中调用服务类的方法来控制消息的发送和接收。你可以根据业务逻辑来决定何时启动或停止监听器。

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    private final KafkaMessageService kafkaMessageService;
    private final KafkaMessageListener kafkaMessageListener;

    @Autowired
    public KafkaController(KafkaMessageService kafkaMessageService, KafkaMessageListener kafkaMessageListener) {
        this.kafkaMessageService = kafkaMessageService;
        this.kafkaMessageListener = kafkaMessageListener;
    }

    @PostMapping("/send")
    public void sendMessage(@RequestParam String topic, @RequestParam String message) {
        kafkaMessageService.sendMessage(topic, message);
    }

    @GetMapping("/start-listen")
    public void startListening(@RequestParam String topic) {
        kafkaMessageService.startListening(topic);
        kafkaMessageListener.startListening();
    }

    @GetMapping("/stop-listen")
    public void stopListening() {
        kafkaMessageService.stopListening();
        kafkaMessageListener.stopListening();
    }
}
```

### 总结

通过上述配置和服务层的设计，我们实现了仅在需要发送或接收Kafka消息时才建立与Kafka的连接。懒加载机制确保了资源的有效利用，而按需创建和控制监听器则提供了灵活性。这种方式适用于大多数场景，并且可以根据具体需求进一步扩展和优化。