kafka的简单使用

最新推荐文章于 2024-05-22 11:52:35 发布

路西法98

最新推荐文章于 2024-05-22 11:52:35 发布

阅读量969

点赞数 5

文章标签： kafka linq 分布式

本文链接：https://blog.csdn.net/weixin_42594143/article/details/138665911

版权

Kafka是一个分布式的流处理平台，主要用于处理高吞吐量的实时数据流。在Kafka中，有一些重要的概念需要了解，包括以下几个：

Broker：Kafka集群中的每个服务器节点被称为Broker。每个Broker负责处理一部分的消息流量，并且可以与其他Broker协作以实现高可用性和可扩展性。
Topic：Topic是Kafka中消息的逻辑分类单位，类似于消息队列中的队列。每个Topic可以被分成多个Partition，每个Partition都是一个有序的消息队列。
Partition：Partition是Topic的一个分区，每个Partition都是一个有序的消息队列。在Kafka中，每个Partition都被分配到一个Broker上，这个Broker就是该Partition的Leader Broker，其他的Broker则是该Partition的Follower Broker。
Producer：Producer是向Kafka中发送消息的客户端。Producer可以将消息发送到指定的Topic的一个Partition中，也可以让Kafka根据一定的策略自动选择Partition。
Consumer：Consumer是从Kafka中读取消息的客户端。Consumer可以订阅一个或多个Topic，并从指定的Partition中读取消息。
Consumer Group：Consumer Group是一组共同消费一个或多个Topic的Consumer的集合。每个Consumer Group中的Consumer可以消费不同的Partition，但同一个Partition只能被同一个Consumer Group中的一个Consumer消费。
Offset：Offset是Kafka中每个Partition中消息的唯一标识符，用于标识Consumer已经消费到哪个位置。Kafka中的Consumer可以通过指定Offset来读取指定位置的消息，也可以通过自动提交Offset来实现自动恢复。

简单的Spring Boot项目中使用Kafka的示例代码1：

引入Kafka依赖

在项目的pom.xml文件中添加Kafka依赖：

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.7.2</version>
</dependency>

配置Kafka

在application.properties文件中配置Kafka相关参数：

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=my-group
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer

创建Kafka生产者

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

@Service
public class KafkaProducer {

    private static final String TOPIC = "my-topic";

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String message) {
        kafkaTemplate.send(TOPIC, message);
    }
}

创建Kafka消费者

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumer {

    @KafkaListener(topics = "my-topic", groupId = "my-group")
    public void consume(String message) {
        System.out.println("Received message: " + message);
    }
}

测试Kafka

在Controller中注入KafkaProducer，发送消息：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private KafkaProducer kafkaProducer;

    @GetMapping("/send")
    public String sendMessage() {
        kafkaProducer.sendMessage("Hello, Kafka!");
        return "Message sent";
    }
}

启动项目，访问http://localhost:8080/send，可以在控制台看到消费者接收到的消息。

以上是一个简单的Spring Boot项目中使用Kafka的示例代码，实际使用中还需要考虑Kafka的高可用、消息序列化方式等问题。

示例代码2：

在Spring Boot项目中使用Kafka，需要引入Kafka客户端依赖，如下所示：

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.7.1</version>
</dependency>

接下来，我们可以创建一个Kafka生产者和一个Kafka消费者。生产者用于发送消息到Kafka，消费者用于从Kafka订阅消息。以下是一个完整的Kafka示例代码：

@Configuration
@EnableKafka
public class KafkaConfig {

    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(configProps);
    }

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

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        configProps.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
        configProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        configProps.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return new DefaultKafkaConsumerFactory<>(configProps);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }
}

在上面的代码中，我们使用了Spring Kafka提供的一些配置类和注解，包括@EnableKafka、ProducerFactory、KafkaTemplate、ConsumerFactory和ConcurrentKafkaListenerContainerFactory等。

在生产者中，我们创建了一个ProducerFactory对象，用于创建KafkaProducer实例。然后，我们创建了一个KafkaTemplate对象，用于发送消息到Kafka。

在消费者中，我们创建了一个ConsumerFactory对象，用于创建KafkaConsumer实例。然后，我们创建了一个ConcurrentKafkaListenerContainerFactory对象，用于订阅Kafka消息并处理消息。

下面是一个使用Kafka的完整示例代码：

@RestController
public class KafkaController {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @GetMapping("/send/{message}")
    public String sendMessage(@PathVariable String message) {
        kafkaTemplate.send("test-topic", message);
        return "Message sent successfully";
    }

    @KafkaListener(topics = "test-topic", groupId = "group-id")
    public void consumeMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

在上面的代码中，我们创建了一个RestController，其中包含一个发送消息的接口和一个消费消息的方法。在发送消息的接口中，我们使用KafkaTemplate对象发送消息到名为test-topic的Kafka主题。在消费消息的方法中，我们使用@KafkaListener注解订阅名为test-topic的Kafka主题，并处理接收到的消息。

总之，Kafka是一个高吞吐量的分布式发布订阅消息系统，可以处理大量的实时数据流。在Spring Boot项目中使用Kafka，需要引入Kafka客户端依赖，并创建一个Kafka生产者和一个Kafka消费者。在生产者中，我们使用KafkaTemplate对象发送消息到Kafka。在消费者中，我们使用@KafkaListener注解订阅Kafka主题，并处理接收到的消息。

示例代码3:
以下是一个简单的Spring Boot项目中使用Kafka的示例代码：

配置Kafka

在Spring Boot项目中，我们需要在application.properties文件中配置Kafka的相关信息，如下所示：

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=my-group
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

这里配置了Kafka的服务器地址、消费者组ID、自动偏移重置以及生产者的序列化器。

创建Kafka生产者

在Spring Boot项目中，我们可以使用KafkaTemplate来创建Kafka生产者，如下所示：

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;

public void sendMessage(String message) {
    kafkaTemplate.send("my-topic", message);
}

这里使用@Autowired注解来注入KafkaTemplate，然后使用send方法来发送消息到指定的主题。

创建Kafka消费者

在Spring Boot项目中，我们可以使用@KafkaListener注解来创建Kafka消费者，如下所示：

@KafkaListener(topics = "my-topic", groupId = "my-group")
public void receiveMessage(String message) {
    System.out.println("Received message: " + message);
}

这里使用@KafkaListener注解来监听指定的主题和消费者组，然后使用receiveMessage方法来处理接收到的消息。

以上就是一个简单的Spring Boot项目中使用Kafka的示例代码。Kafka是一个分布式消息队列系统，可以用于实现高吞吐量、低延迟的消息传递。在Spring Boot项目中，我们可以使用KafkaTemplate来创建Kafka生产者，使用@KafkaListener注解来创建Kafka消费者，从而实现消息的生产和消费。