Kafka入门笔记

最新推荐文章于 2024-05-27 23:43:50 发布
最新推荐文章于 2024-05-27 23:43:50 发布
阅读量44 收藏
点赞数
文章标签： kafka 笔记 linq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45550937/article/details/133745938
版权

Kafka学习应用笔记

定义

应用场景

  • 缓冲/消峰
  • 解耦
  • 异步通信

两种模式

  • 点对点模式
  • 发布/订阅模式

1.1 下载kafka

官网地址：https://kafka.apache.org/downloads

kafka_2.13-3.5.1.tgz

在这里插入图片描述

1.2 上传至服务器并解压

tar -zxvf  kafka_2.13-3.5.1.tgz

1.3 修改配置文件

1.3.1 修改server.properties

broker.id=0
port=9092 #端口号

listeners=PLAINTEXT://192.168.48.128:9092 #设置本机IP
advertised.listeners=PLAINTEXT://192.168.48.128:9092
advertised.host.name=192.168.48.128
host.name=192.168.48.128

log.dirs=/wb/kafka/logs #日志存放路径，上面创建的目录
zookeeper.connect=localhost:2181 #zookeeper地址和端口，单机配置部署，localhost:2181

1.3.2 修改启动脚本

防止内存太小起不来服务
在这里插入图片描述

1.4 启动zookeeper

启动命令

/wb/kafka/kafka_2.13-3.5.1/bin/zookeeper-server-start.sh /wb/kafka/kafka_2.13-3.5.1/config/zookeeper.properties &

1.5 启动kafka

 sh /wb/kafka/kafka_2.13-3.5.1/bin/kafka-server-start.sh /wb/kafka/kafka_2.13-3.5.1/config/server.properties  &

1.6 验证进程

ps -ef | grep zookeeper
ps -ef | grep kafka
jps

1.7 常用命令

版本高的用：–bootstrap-server

版本低的用：–zookeeper

注意点

  • 监听设置的ip下面则需要ip
# 创建topic
sh kafka-topics.sh --bootstrap-server localhost:9092 --create --topic heima --partitions 2 --replication-factor 1
# 查看topic
sh kafka-topics.sh --list --bootstrap-server localhost:9092

1.8 kafkatool管理工具

下载地址：https://www.kafkatool.com/download.html

本地软件： offsetexplorer_64bit.exe

在这里插入图片描述

1.9 springboot集成Kafka

  1. Spring Boot 版本和 Spring-Kafka 的版本对应关系：https://spring.io/projects/spring-kafka
| Spring for Apache Kafka Version | Spring Integration for Apache Kafka Version | kafka-clients       |
| ------------------------------- | ------------------------------------------- | ------------------- |
| 2.2.x                           | 3.1.x                                       | 2.0.0, 2.1.0        |
| 2.1.x                           | 3.0.x                                       | 1.0.x, 1.1.x, 2.0.0 |
| 2.0.x                           | 3.0.x                                       | 0.11.0.x, 1.0.x     |
| 1.3.x                           | 2.3.x                                       | 0.11.0.x, 1.0.x     |
| 1.2.x                           | 2.2.x                                       | 0.10.2.x            |
| 1.1.x                           | 2.1.x                                       | 0.10.0.x, 0.10.1.x  |
| 1.0.x                           | 2.0.x                                       | 0.9.x.x             |
| N/A*                            | 1.3.x                                       | 0.8.2.2             |

2.Spring-Kafka 官方文档：https://docs.spring.io/spring-kafka/docs/2.2.0.RELEASE/reference/html/

1.9.1 pom

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

1.9.2 配置文件

spring:
  kafka:
    bootstrap-servers: 192.168.48.128:9092
    producer:
      # 发生错误后，消息重发的次数。
      retries: 0
      # 键的序列化方式
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      # 值的序列化方式
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

      properties:
        # 配置拦截器多个使用,分割
        interceptor.classes: com.spring.demo.kafka.interceptor.CustomProducerInterceptor
    consumer:
      group-id: test
      # 键的反序列化方式
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      # 值的反序列化方式
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      properties:
        # 配置拦截器多个使用,分割
        interceptor.classes: com.spring.demo.kafka.interceptor.CustomConsumerInterceptor
    listener:
      # 但消费者监听的topic不存在时，保证能够是项目启动
      missing-topics-fatal: false

1.9.3 配置类

常量池

/**
 * kafka 常量池
 *
 */
public interface KafkaConsts {
    /**
     * 默认分区大小
     */
    Integer DEFAULT_PARTITION_NUM = 3;

    /**
     * Topic 名称
     */
    String TOPIC_TEST = "test";
}

配置类

import com.spring.demo.constants.KafkaConsts;
import lombok.AllArgsConstructor;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
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;

/**
 * kafka配置类
 */
@Configuration
@EnableConfigurationProperties({KafkaProperties.class})
@EnableKafka
@AllArgsConstructor
public class KafkaConfig {
    private final KafkaProperties kafkaProperties;

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

    @Bean
    public ProducerFactory<String, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(kafkaProperties.buildProducerProperties());
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(KafkaConsts.DEFAULT_PARTITION_NUM);
        factory.setBatchListener(true);
        factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }

    @Bean
    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(kafkaProperties.buildConsumerProperties());
    }

    @Bean("ackContainerFactory")
    public ConcurrentKafkaListenerContainerFactory<String, String> ackContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
        factory.setConcurrency(KafkaConsts.DEFAULT_PARTITION_NUM);
        return factory;
    }

}

1.9.4 消费者


import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import java.util.Optional;

/**
 * kafka消费者
 */
@Component
@Slf4j
public class KafkaConsumer {

    @KafkaListener(topics = {"test-kafka"}, groupId = "test")
    public void consumer(ConsumerRecord<?, ?> record) {
        Optional<?> kafkaMessage = Optional.ofNullable(record.value());
        if (kafkaMessage.isPresent()) {
            Object message = kafkaMessage.get();
            log.info("----------------- record =" + record);
            log.info("------------------ message =" + message);
        }
    }
}

1.9.5 生产者

import lombok.RequiredArgsConstructor;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;


/**
 * kafka生产者
 */
@Component
@RequiredArgsConstructor
public class KafkaProducer {

    private final KafkaTemplate kafkaTemplate;

    /**
     * kafka消息发送
     */
    public void send(String topic){
        kafkaTemplate.send(topic,"123");
    }
}

1.9.6 测试

import com.spring.demo.core.annotation.Anonymous;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test/kafka")
public class TestKafka {

    @Autowired
    private KafkaProducer producer;

    @Anonymous
    @GetMapping("/send/{topic}")
    public void send(@PathVariable String topic) {
        producer.send(topic);
    }
}

1.9.7 效果

在这里插入图片描述

1.10 扩展

1.10.1 消费者拦截器

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerInterceptor;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 消费者拦截器
 */
@Slf4j
@Component
public class CustomConsumerInterceptor implements ConsumerInterceptor<Object,Object> {
    @Override
    public ConsumerRecords onConsume(ConsumerRecords<Object,Object> records) {
        // 消息进行预处理、日志记录、性能监控等操作，并不会改变消息的内容

//        records.forEach(record ->{
//            if (StringUtils.equals("test-kafka", record.topic())){
//                String jsonStr = record.value().toString();
//                JSONObject jsonObject = JSONObject.parseObject(jsonStr);
//                String data = JSON.toJSONString(jsonObject.getOrDefault("data", StringUtils.EMPTY));
//                record = new ConsumerRecord<>(record.topic(), record.partition(), record.offset(), record.key(), data);
//
//            }
//        });

        return records;
    }

    @Override
    public void close() {

    }

    @Override
    public void onCommit(Map map) {

    }

    @Override
    public void configure(Map<String, ?> map) {

    }
}

1.10.2 生产者拦截器

import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.stereotype.Component;

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

/**
 * 生产者拦截器
 */
@Slf4j
@Component
public class CustomProducerInterceptor implements ProducerInterceptor {
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        // 在发送消息前的自定义逻辑
        log.info("Before sending message: {}", record.value());

        Map<String, Object> recordMap = new HashMap<>();
        recordMap.put("data", record.value());
        recordMap.put("author", "wb");
        recordMap.put("version", "1.0.0");
        // 可以修改消息内容或其他属性
        record = new ProducerRecord<>(record.topic(), record.partition(), record.key(), JSON.toJSONString(recordMap));
        return record;
    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        // 在消息发送完成后的自定义逻辑
        if (exception == null) {
            System.out.println("Message sent successfully: " + metadata.offset());
        } else {
            System.out.println("Failed to send message: " + exception.getMessage());
        }
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> map) {

    }
}

1.10.3 开机自启

在 /lib/systemd/system/ 目录下创建 zookeeper服务和kafka服务 的配置文件。

1.10.3.1 zookeeper.service
[Unit]
Description=Zookeeper service
After=network.target

[Service]
Type=simple
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/opt/java/jdk-11.0.1/bin"
User=root
Group=root
ExecStart=/wb/kafka/kafka_2.13-3.5.1/bin/zookeeper-server-start.sh /wb/kafka/kafka_2.13-3.5.1/config/zookeeper.properties
ExecStop=/wb/kafka/kafka_2.13-3.5.1/bin/zookeeper-server-stop.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target
1.10.3.2 kafka.service
[Unit]![在这里插入图片描述](https://img-blog.csdnimg.cn/c0abf52c1a1f4547bbb843de6e51aab1.png#pic_center)

Description=Apache Kafka server (broker)
After=network.target  zookeeper.service

[Service]
Type=simple
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/opt/java/jdk-11.0.1/bin"
User=root
Group=root
ExecStart=/wb/kafka/kafka_2.13-3.5.1/bin/kafka-server-start.sh /wb/kafka/kafka_2.13-3.5.1/config/server.properties
ExecStop=/wb/kafka/kafka_2.13-3.5.1/bin/kafka-server-stop.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target
1.10.3.3 刷新配置
systemctl daemon-reload
1.10.3.4 启动

加入开机自启

systemctl enable zookeeper

systemctl enable kafka

关闭开机自启

systemctl disabled kafka

systemctl disabled zookeeper

其他命令

# 状态
systemctl status zookeeper 
# 启动
systemctl start  zookeeper 
# 关闭
systemctl stop   zookeeper
菜鸟程序员ayy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第一章 kafka入门笔记
hankin的博客
10-19 418
一、Kafka简介 1、什么是Kafka kafka最初是LinkedIn的一个内部基础设施系统。最初开发的起因是LinkedIn虽然有了数据库和其他系统可以用来存储数据，但是缺乏一个可以帮助处理持续数据流的组件。所以在设计理念上，开发者不想只是开发一个能够存储数据的系统，如关系数据库Nosql数据库、搜索引擎等等，更希望把数据看成一个持续变化和不断增长的流，并基于这样的想法构建出一个数据系统...
Kafka学习笔记.pdf
09-10
Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多订阅者，基于zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web/nginx日志、访问日志，消息服务等等，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。
kafka一小时入门精讲笔记.zip
02-05
kafka
Kafka学习笔记.doc
02-14
Kafka学习笔记，包括Kafka术语、学习过程中单机版Kafka安装与配置、基于Docker的Kafka集群安装与配置、kafka消息机制与原理、学习方法
kafka入门笔记（基本概念和相关问题）
codedecentt的博客
10-08 799
kafka基础理论入门
kafka入门笔记
dark868的专栏
10-04 199
环境：win10 （linux下其实一样） 下载：https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/ 注意：这里不要下载 src版本，没法启动的 安装：因为下载的是tgz文件，所以不需要安装，解压到相应的地方就可以了。 启动： 1、启动内置 zookeeper bin\windows\zookeeper-server-start.bat c...
Kafka 入门笔记
DanielSYC的博客
02-12 1507
kafka 入门笔记
Kafka入门笔记(四) -- kafka消费者
qq_34424698的博客
02-08 1043
kafka 消费者
Kafka入门笔记(一) --kafka概述+kafka集群搭建
qq_34424698的博客
01-22 1129
kafka概述+kafka 集群搭建
11_Kafka.docx
06-18
Kakka 入门学习笔记。这个整体上是一个基础的入门笔记。其基本被裁剪到 https://blog.csdn.net/dec_sun/article/category/8872963 这个模块中。如果在晚上观看不便，可以下载看之。
Kafka快速入门视频课程
06-16
本课程从零开始，以通俗易懂的方式讲解Kafka技术，手把手教你掌握每一个知识点。 课程内容包括：消息系统、Kafka简介、安装Kafka、配置Kafka、Kafka...教学全程采用笔记+代码案例的形式讲解，通俗易懂！！！ 讲师介绍
kafka入门笔记与golang客户端
qzcsu的博客
10-24 720
kafka入门笔记与golang客户端(2021年/10月) kafka是一个分布式流处理平台，常常以消息中间件的角色各大平台。与之类似的产品有，Apache ActiveMQ、RabbitMQ、RocketMQ等。而kafka常常被用在大数据相关的一些领域。关于更详细的介绍可以参考中文官网 kafka的一些特色 同一个partition中的消息消费是有序的 尽管现在kafka官方宣布将来的版本不会依赖zookeeper做注册中心，但是在当前最新的2.8版本中，官方教程还是使用的zookeeper，也许在
Kafka入门笔记(二) --kafka常用命令
qq_34424698的博客
01-23 545
kafka常用命令
Kafka入门学习笔记
weixin_40569590的博客
12-23 333
1-kafka介绍1.1-什么是kafka？1.2-kafka特点1.3-kafka基本概念2-kafka架构2.1-kafka部署架构2.2-kafka集群架构2.3-kafka存储结构2.3.1-Topic中partition存储分布2.3.2-partiton中文件存储方式2.3.3-partiton中segment文件存储结构2.3.4-Segment中message存储结构2.3.5-segment索引文件、数据文件的关系2.3.6-Replication 存储副本3-kafk
Kafka线上集群部署方案怎么做？no.6
飘然渡沧海的博客
05-27 799
最后是社区的支持度。这一点虽然不是什么明显的差别，但如果不了解的话可能比前两个因素对你的影响更大。简单来说就是，社区目前对Windows平台上发现的Kafka Bug不做任何承诺。虽然口头上依然保证尽力去解决，但根据我的经验，Windows上的Bug一般是不会修复的。
【夏之以寒-Kafka专栏 02】什么情况下会发生 QueueFullException？
最新发布
weixin_40736233的博客
05-27 348
QueueFullException是一个异常，通常在消息队列（Message Queue）中使用，当尝试将消息放入队列时，如果队列已满，则可能会抛出此异常。
Kafka
weixin_61015632的博客
05-27 207
它可以看作是一个消息队列服务，但与传统消息队列相比，具有更高的吞吐量、更好的可扩展性和持久性。（Kafka Cluster）：这相当于广播电台的设施，包括发射塔、控制室等。（Consumers）：消费者就是听众，也是信息的接收者。在Kafka中，消费者是指那些从。，不同的分区可以分布在Kafka集群的不同服务器上，以提高系统的吞吐量和可用性。为了通俗地理解Kafka，我们可以把它比作一个“大型的广播电台”，在Kafka中，消息是由生产者发布，消费者读取的。在Kafka中，消息被分类存储在不同的主题中，
kafka的安装
沉下心,苦磨炼
05-27 336
性能压测kafka
kafka学习笔记尚硅谷
09-27
kafka学习笔记尚硅谷中提到了启动Kafka和停止Kafka的相关命令。启动Kafka的命令是在终端中运行mykafka.sh start命令，例如：[hyj@hadoop102 kafka-3.0.0]$ mykafka.sh start。而停止Kafka的命令是在终端中运行bin/...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值