Kafka基本入门使用

天地归墟

已于 2023-11-02 17:39:22 修改

阅读量341

点赞数

文章标签： kafka linq 分布式

于 2023-11-02 17:36:56 首次发布

本文链接：https://blog.csdn.net/qq_40806882/article/details/134187765

版权

安装kafka

1、官方下载地址：http://kafka.apache.org/downloads.html

2、解压安装包

tar -zxvf kafka_2.12-3.4.0.tgz -C /usr/local

cd /usr/local
mv kafka_kafka_2.12-3.4.0/ kafka

3、进入到kafka 目录，修改配置文件

 cd /usr/local/kafka/config/
 vim server.properties

输入以下内容：

#broker 的全局唯一编号，不能重复，只能是数字。
broker.id=0
#处理网络请求的线程数量
num.network.threads=3
#用来处理磁盘 IO 的线程数量
num.io.threads=8
#发送套接字的缓冲区大小
socket.send.buffer.bytes=102400
#接收套接字的缓冲区大小
socket.receive.buffer.bytes=102400
#请求套接字的缓冲区大小
socket.request.max.bytes=104857600
#kafka 运行日志(数据)存放的路径，路径不需要提前创建，kafka 自动帮你创建，可以
配置多个磁盘路径，路径与路径之间可以用"，"分隔
log.dirs=/data/kafka
#topic 在当前 broker 上的分区个数
num.partitions=1
#用来恢复和清理 data 下数据的线程数量
num.recovery.threads.per.data.dir=1
# 每个 topic 创建时的副本数，默认时 1 个副本
offsets.topic.replication.factor=1
#segment 文件保留的最长时间，超时将被删除
log.retention.hours=168
#每个 segment 文件的大小，默认最大 1G
log.segment.bytes=1073741824
# 检查过期数据的时间，默认 5 分钟检查一次是否数据过期
log.retention.check.interval.ms=300000
#配置连接 Zookeeper 集群地址（在 zk 根目录下创建/kafka，方便管理）
zookeeper.connect=hadoop102:2181,hadoop103:2181,hadoop104:2181/kafka
#设置消息长度
max.message.bytes=104857600

4、分发安装包

xsync kafka/

分别在 hadoop103 和 hadoop104 上修改配置文件/home/software/kafka/config/server.properties中的 broker.id=1、broker.id=2

注：broker.id 不得重复，整个集群中唯一

5、配置环境变量

在/etc/profile.d/my_env.sh 文件中增加 kafka 环境变量配置

sudo vim /etc/profile.d/my_env.sh

vim /etc/profile
 
#KAFKA_HOME
export KAFKA_HOME=/usr/local/kafka
export PATH=$PATH:$KAFKA_HOME/bin

#刷新一下环境变量。
source /etc/profile

#分发环境变量文件到其他节点，并 source。

6、启动集群

先启动 Zookeeper 集群，然后启动 Kafka。

zk.sh start

#在kafka上所有集群
sh bin/kafka-server-start.sh -daemon config/server.properties

#真实路径启动
/usr/local/kafka_2.12-3.4.0/bin/kafka-server-start.sh -daemon /usr/local/kafka_2.12-3.4.0/config/server.properties

7、关闭集群

#在kafka上所有集群
sh bin/kafka-server-stop.sh

**注意：**停止 Kafka 集群时，一定要等 Kafka 所有节点进程全部停止后再停止 Zookeeper集群。因为 Zookeeper 集群当中记录着 Kafka 集群相关信息，Zookeepe集群一旦先停止，Kafka 集群就没有办法再获取停止进程的信息，只能手动杀死 Kafka 进程了

8、kafak一次性启动停止脚本

#!/bin/bash

case $1 in
"start")
  for i in 192.168.31.120 192.168.31.121 192.168.31.122
  do
    echo "--- start $i kafka ---"
    ssh $i "/usr/local/kafka_2.12-3.4.0/bin/kafka-server-start.sh -daemon /usr/local/kafka_2.12-3.4.0/config/server.properties"
  done
;;

"stop")
  for i in 192.168.31.120 192.168.31.121 192.168.31.122
  do
    echo "--- stop $i kafka ---"
    ssh $i "/usr/local/kafka_2.12-3.4.0/bin/kafka-server-stop.sh"
  done
;;
esac

chmod 777 kf.sh

常见命令

主题：kafka-topics.sh
在这里插入图片描述

cd  /usr/local/kafka_2.12-3.4.0/bin/

#查看topics
sh kafka-topics.sh --bootstrap-server 192.168.31.120:9092 --list
#老版本查看，如果版本老于2.2，应该用--zookeeper,并且端口号是2181
sh kafka-topics.sh --zookeeper 10.66.90.100:2181 --list

#创建一个名称为first的topic，设置其有一个分区，3个分区副本
sh kafka-topics.sh --bootstrap-server 192.168.31.120:9092 --topic first --create --partitions 1 --replication-factor 3


#查看first分区详情
sh kafka-topics.sh --bootstrap-server 192.168.31.120:9092 --describe first

#修改：增加分区数到3（注意分区数只能增加，不能减少）
sh kafka-topics.sh --bootstrap-server 192.168.31.120:9092 --topic first  --alter --partitions 3

生产者：kafka-console-producer.sh

#连接到first主题，发送数据
sh kafka-console-producer.sh --bootstrap-server 192.168.31.120:9092 --topic first

消费者：kafka-console-consumer.sh

#连接到first主题，消费数据（这里的消费是增量的消费数据，从连接到topic开始计算，之后topic中的新数据会被消费）
sh kafka-console-consumer.sh --bootstrap-server 192.168.31.120:9092 --topic first

#连接到first主题，消费数据（包含历史数据）
sh kafka-console-consumer.sh --bootstrap-server 192.168.31.122:9092 --topic first --from-beginning

sh bkafka-console-consumer.sh --bootstrap-server 10.66.90.100:9092 --topic  alleria_input_event --from-beginning

java整合

依赖

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
        </dependency>

java

生成者

producer生产者异步发送：

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.StringSerializer;

import java.util.Properties;

public class KafkaTestMain {
    public static void main(String[] args) {
        //1、属性配置
        Properties properties = new Properties();
        //连接kafka集群 bootstrap-server
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.31.120:9092,192.168.31.121:9092");
        //指定key和value序列化器
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //2、创建kafka producer生产者
        KafkaProducer<String, String> stringStringKafkaProducer = new KafkaProducer<String, String>(properties);

        //3、指定topic并发送数据
        stringStringKafkaProducer.send(new ProducerRecord<>("first", "hello"));

        //4、关闭资源
        stringStringKafkaProducer.close();
    }
}

producer回调异步发送：

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

import java.util.Objects;
import java.util.Properties;

public class KafkaTestMain {
    public static void main(String[] args) {
        //1、属性配置
        Properties properties = new Properties();
        //连接kafka集群 bootstrap-server
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.31.120:9092,192.168.31.121:9092");
        //指定key和value序列化器
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //2、创建kafka producer生产者
        KafkaProducer<String, String> stringStringKafkaProducer = new KafkaProducer<String, String>(properties);

        //3、指定topic并发送数据
        stringStringKafkaProducer.send(new ProducerRecord<>("first", "hello"), new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                //异常消息为null，代表发送正常
                if (Objects.isNull(e)){
                    System.out.println("主题："+recordMetadata.topic());
                    System.out.println("分区："+recordMetadata.partition());
                }
            }
        });

        //4、关闭资源
        stringStringKafkaProducer.close();
    }
}

同步发送

//添加get方法抛出异常，变为同步发送，必须将上一个消息发送完毕后，才能发送下一条数据 
stringStringKafkaProducer.send(new ProducerRecord<>("first", "hello")).get();

消费者

自定义分区器

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

/***
 * 自定义分区器
 */
public class MyPartitioner implements Partitioner {
    /***
     * 分区方法
     * @param s topic
     * @param o key
     * @param bytes 序列化后的key
     * @param o1 value
     * @param bytes1 序列化后的value
     * @param cluster
     * @return
     */
    @Override
    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {
        //获取数据
        String value = o1.toString();

        //包含hello字符的value，发送到1号分区
        if (value.contains("hello")) {
            return 1;
        }
        return 0;
    }

    @Override
    public void close() {

    }

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

    }
}

调用：

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

import java.util.Objects;
import java.util.Properties;

public class KafkaTestMain {
    public static void main(String[] args) {
        //1、属性配置
        Properties properties = new Properties();
        //连接kafka集群 bootstrap-server
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.31.120:9092,192.168.31.121:9092");
        //指定key和value序列化器
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //关联自定义分区
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "com.example.kafkademo.kafka.java.MyPartitioner");

        //2、创建kafka producer生产者
        KafkaProducer<String, String> stringStringKafkaProducer = new KafkaProducer<String, String>(properties);

        //3、指定topic并发送数据
        stringStringKafkaProducer.send(new ProducerRecord<>("first", "h"), new Callback() {
            @Override
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                //异常消息为null，代表发送正常
                if (Objects.isNull(e)) {
                    System.out.println("主题：" + recordMetadata.topic());
                    System.out.println("分区：" + recordMetadata.partition());
                }
            }
        });

        //4、关闭资源
        stringStringKafkaProducer.close();
    }
}

springboot整合

依赖

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

配置：

spring:
  kafka:
    bootstrap-servers: 192.168.31.120:9092,192.168.31.121:9092,192.168.31.122:9092
    consumer:
      group-id: test

service：

@Service
public class MessageServiceKafka {
    @Autowired
    KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String str) {
        kafkaTemplate.send("first", str);
//        kafkaTemplate.flush();
        System.out.println("send over");
    }

    public void receive() {
    }

}

listener:

@Component
public class MessageListener {
    @KafkaListener(topics = {"first"})
    public void onMessage(ConsumerRecord<String, String> consumerRecord) {
        String value = consumerRecord.value();
        System.out.println("record:" + value);

    }
}

kafka报错：java.net.UnknownHostException: kafkahost

#修改hosts文件，添加主机名称
C:\Windows\System32\drivers\etc

天地归墟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Kafka基本入门使用

**** 自定义分区器/**** 分区方法* @param bytes 序列化后的key* @param bytes1 序列化后的value* @return//获取数据 String value = o1 . toString();//包含hello字符的value，发送到1号分区 if(value . contains("hello")) {return 1;} return 0;> map) {} }/**** 自定义分区器/**** 分区方法。
复制链接

扫一扫