Kafka消息队列

最新推荐文章于 2023-08-13 18:54:22 发布
最新推荐文章于 2023-08-13 18:54:22 发布
阅读量446 收藏
点赞数 1
文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118315/article/details/109404294
版权

概述

Apache Kafka是Apache软件基金会的开源的流处理平台，该平台提供了消息的订阅与发布的消息队列，一般用作系统间解耦、异步通信、削峰填谷等场景。

同时Kafka又提供了Kafka streaming插件包实现了实时在线流处理。相比较一些专业的流处理框架不同，Kafka Streaming计算是运行在应用端，具有简单、入门要求低、部署方便等优点。总体来说Kafka这门课程需要大家掌握以下两个方面：

  • 消息队列Message Queue
  • Kafka Streaming 流处理
    在这里插入图片描述

消息队列是一种在分布式和大数据开发中不可或缺的中间件。在分布式或者大数据开发中通常使用消息队列进行缓冲、系统间解耦和削峰填谷等业务场景，常见的消息队列服务工作模式大致会分为两大类：
在这里插入图片描述

  • 至多一次：消息生产者将数据写入消息系统，然后由消费者负责去拉去消息服务器中的消息，一旦消息被确认消费之后 ，由消息服务器主动删除队列中的数据，这种消费方式一般只允许被一个消费者消费，并且消息队列中的数据不允许被重复消费。

  • 没有限制：同上诉消费形式不同，生产者发不完数据以后，该消息可以被多个消费者同时消费，并且同一个消费者可以多次消费消息服务器中的同一个记录。主要是因为消息服务器一般可以长时间存储海量消息。

基础架构

日志&分区

Kafka集群以Topic形式负责分类集群中的Record，每一个Record属于一个Topic，生产者负责发送数据到Kafka集群中的某一个Topic中，同时消费者可以订阅kafka集群中的Topic.
在这里插入图片描述

每个Topic底层都会对应一组分区的日志用于持久化Topic中的Record。在Kafka集群中，Topic的每一个日志的分区都一定会有1个Borker担当该分区的Leader，其他的Broker担当该分区的follower，Leader负责分区数据的读写操作，follower负责同步改分区的数据。这样如果分区的Leader宕机，改分区的其他follower会选取出新的leader继续负责该分区数据的读写。其中集群的中Leader的监控和Topic的部分元数据是存储在Zookeeper中。
在这里插入图片描述

生产者

生产者将数据发布到他们选择的Topic。生产者负责选择将记录分配给Topic中的哪个Partition。可以以round-robin方式完成此操作，仅是为了平衡负载，也可以根据某些语义分区功能（例如基于记录中的Key）进行此操作

Kafka中所有消息是通过Topic为单位进行管理，每个Kafka中的Topic通常会有多个订阅者，负责订阅发送到改Topic中的数据。每个在Kafka 集群中的Topic，Kafka负责管理改Topic的一组日志分区：
在这里插入图片描述

每组日志分区是一个有序的不可变的的日志序列，分区中的每一个Record都被分配了唯一的序列编号称为是offset，Kafka 集群会持久化所有发布到Topic中的Record信息，改Record的持久化时间是通过配置文件指定,默认是168小时。

log.retention.hours=168

Kafka底层会定期的check日志文件，然后将过期的数据从log中移除，由于Kafka使用硬盘存储日志文件，因此使用Kafka长时间缓存一些日志文件是不存在问题的。

消费组

在消费者消费Topic中数据的时候，每个消费者会维护本次消费对应分区的偏移量，消费者会在消费完一个批次的数据之后，会将本次消费的偏移量提交给Kafka集群，因此对于每个消费者而言可以随意的控制该消费者的偏移量。因此在Kafka中，消费者可以从一个topic分区中的任意位置读取队列数据，由于每个消费者控制了自己的消费的偏移量，因此多个消费者之间彼此相互独立。消费者使用ConsumerGroup名称标记自己，并且发布到Topic的每条记录都会传递到每个订阅ConsumerGroup中的一个消费者实例。如果所有Consumer实例都具有相同的ConsumerGroup，那么Topic中的记录会在该ConsumerGroup中的Consumer实例进行均分消费；如果所有Consumer实例具有不同的ConsumerGroup，则每条记录将广播到所有ConsumerGroup进程。

在这里插入图片描述

更常见的是，我们发现Topic具有少量的Consumer Group，每个ConsumerGroup可以理解为一个“逻辑的订阅者”。每个ConsumerGroup均由许多Consumer实例组成，以实现可伸缩性和容错能力。这无非就是发布-订阅模型，其中订阅者是消费者的集群而不是单个进程。这种消费方式Kafka会将Topic按照分区的方式均分给一个ConsumerGroup下的实例，如果ConsumerGroup下有新的成员介入，则新介入的Consumer实例会去接管ConsumerGroup内其他消费者负责的某些分区，同样如果一下ConsumerGroup下的有其他Consumer实例宕机，则由该ConsumerGroup其他实例接管。

由于Kafka的Topic的分区策略，因此Kafka仅提供分区中记录的有序性，也就意味着相同Topic的不同分区记录之间无顺序。因为针对于绝大多数的大数据应用和使用场景， 使用分区内部有序或者使用key进行分区策略已经足够满足绝大多数应用场景。但是，如果您需要记录全局有序，则可以通过只有一个分区Topic来实现，尽管这将意味着每个ConsumerGroup只有一个Consumer进程。

顺序写入&ZeroCopy

Kafka的特性之一就是高吞吐率，但是Kafka的消息是保存或缓存在磁盘上的，一般认为在磁盘上读写数据是会降低性能的，但是Kafka即使是普通的服务器，Kafka也可以轻松支持每秒百万级的写入请求，超过了大部分的消息中间件，这种特性也使得Kafka在日志处理等海量数据场景广泛应用。Kafka会把收到的消息都写入到硬盘中，防止丢失数据。为了优化写入速度Kafka采用了两个技术， 顺序写和MMFile 。

因为硬盘是机械结构，每次读写都会寻址，然后写入，其中寻址是一个“机械动作”，它是最耗时的。所以硬盘最讨厌随机I/O，最喜欢顺序I/O。为了提高读写硬盘的速度，Kafka就是使用顺序I/O。这样省去了大量的内存开销以及节省了IO寻址的时间。但是单纯的使用顺序写入，Kafka的写入性能也不可能和内存进行对比，因此Kafka的数据并不是实时的写入硬盘中 ，

Kafka充分利用了现代操作系统分页存储来利用内存提高I/O效率。Memory Mapped Files(后面简称mmap)也称为内存映射文件，在64位操作系统中一般可以表示20G的数据文件，它的工作原理是直接利用操作系统的Page来实现文件到物理内存的直接映射。完成MMP映射后，用户对内存的所有操作会被操作系统自动的刷新到磁盘上，极大地降低了IO使用率。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVL7MnG8-1604132386043)(assets/20200104182633932.png)]
Kafka服务器在响应客户端读取的时候，底层使用ZeroCopy技术，直接将磁盘无需拷贝到用户空间，而是直接将数据通过内核空间传递输出，数据并没有抵达用户空间。常规的IO操作流程如下：

在这里插入图片描述

1.用户进程调用read等系统调用向操作系统发出IO请求，请求读取数据到自己的内存缓冲区中。自己进入阻塞状态
2.操作系统收到请求后，进一步将IO请求发送磁盘
3.磁盘驱动器收到内核的IO请求，把数据从磁盘读取到驱动器的缓冲中。此时不占用CPU。当驱动器的缓冲区被读满后，向内核发起中断信号告知自己缓冲区已满
4.内核收到中断，使用CPU时间将磁盘驱动器的缓存中的数据拷贝到内核缓冲区中。
5.如果内核缓冲区的数据少于用户申请的读的数据，重复步骤3跟步骤4，直到内核缓冲区的数据足够多为止。
6.将数据从内核缓冲区拷贝到用户缓冲区，同时从系统调用中返回完成读取任务

缺点：用户的每次IO请求，都需要CPU多次参与。

现代操作系统大都引入了协处理器的概念，也就是说系统在读取的磁盘文件的时候，无需CPU直接参与。而是将数据读取的任务交给DMA控制器，负责辅助CPU完成数据的读取过程。
在这里插入图片描述

1.用户进程调用read等系统调用向操作系统发出IO请求，请求读取数据到自己的内存缓冲区中。自己进入阻塞状态。
2.操作系统收到请求后，进一步将IO请求发送DMA。然后让CPU干别的活去。
3.DMA进一步将IO请求发送给磁盘。
4.磁盘驱动器收到DMA的IO请求，把数据从磁盘读取到驱动器的缓冲中。当驱动器的缓冲区被读满后，向DMA发起中断信号告知自己缓冲区已满。
5.DMA收到磁盘驱动器的信号，将磁盘驱动器的缓存中的数据拷贝到内核缓冲区中。此时不占用CPU。这个时候只要内核缓冲区的数据少于用户申请的读的数据，内核就会一直重复步骤3跟步骤4，直到内核缓冲区的数据足够多为止。
6.当DMA读取了足够多的数据，就会发送中断信号给CPU。
7.CPU手动DMA的信号，知道数据已经准备好，于是将数据从内核拷贝到用户空间，系统调用返回。
跟IO中断模式相比，DMA模式下，DMA就是CPU的一个代理，它负责了一部分的拷贝工作，从而减轻了CPU的负担。DMA的优点就是：中断少，CPU负担低。

在了解底层操作系统的IO操作以后，我们来看一下网络场景。文件在磁盘中数据被copy到内核缓冲区 ->从内核缓冲区copy到用户缓冲区->用户缓冲区copy到内核与socket相关的缓冲区-> 数据从socket缓冲区copy到相关协议引擎发送出去。

在这里插入图片描述

从上图可以看出，默认数据需要从内核到用户在到内核空间的这么一个过程是多余的，所谓ZeroCopy的做法是直接在内核中将数据发送出去，因此节省了1次拷贝。文件在磁盘中数据被copy到内核缓冲区->从内核缓冲区copy到内核与socket相关的缓冲区->数据从socket缓冲区copy到相关协议引擎发送出去。

在这里插入图片描述

Kafka环境搭建

单机环境

  • 安装JDK，配置JAVA_HOME
[root@CentOS ~]# rpm -ivh jdk-8u191-linux-x64.rpm 
warning: jdk-8u191-linux-x64.rpm: Header V3 RSA/SHA256 Signature, key ID ec551f03: NOKEY
Preparing...                ########################################### [100%]
   1:jdk1.8                 ########################################### [100%]
Unpacking JAR files...
	tools.jar...
	plugin.jar...
	javaws.jar...
	deploy.jar...
	rt.jar...
	jsse.jar...
	charsets.jar...
	localedata.jar...
[root@CentOS ~]# vi .bashrc 
JAVA_HOME=/usr/java/latest
CLASSPATH=.
PATH=$PATH:$JAVA_HOME/bin
export JAVA_HOME
export CLASSPATH
export PATH
[root@CentOS ~]# vi .bashrc
  • 配置主机名为CentOS
[root@CentOS ~]# vi /etc/sysconfig/network
NETWORKING=yes
HOSTNAME=CentOS
  • 配置主机名和IP映射
[root@CentOS ~]# ifconfig 
eth0      Link encap:Ethernet  HWaddr 00:0C:29:D3:EA:13  
          inet addr:192.168.52.129  Bcast:192.168.52.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fed3:ea13/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:641 errors:0 dropped:0 overruns:0 frame:0
          TX packets:379 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:56374 (55.0 KiB)  TX bytes:57374 (56.0 KiB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)
[root@CentOS ~]# vi /etc/hosts      
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.52.129 CentOS
  • 关闭防火墙
[root@CentOS ~]# service iptables stop
iptables: Setting chains to policy ACCEPT: filter          [  OK  ]
iptables: Flushing firewall rules:                         [  OK  ]
iptables: Unloading modules:                               [  OK  ]
[root@CentOS ~]# chkconfig iptables off
[root@CentOS ~]# chkconfig --list | grep iptables
iptables       	0:关闭	1:关闭	2:关闭	3:关闭	4:关闭	5:关闭	6:关闭
  • 安装配置Zookeeper
[root@CentOS ~]# tar -zxf zookeeper-3.4.6.tar.gz -C /usr/
[root@CentOS ~]# cd /usr/zookeeper-3.4.6/
[root@CentOS zookeeper-3.4.6]# cp conf/zoo_sample.cfg conf/zoo.cfg
[root@CentOS zookeeper-3.4.6]# vi conf/zoo.cfg 
# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just
# example sakes.
dataDir=/root/zkdata
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
[root@CentOS ~]# mkdir /root/zkdata
  • 启动zookeeper服务
[root@CentOS zookeeper-3.4.6]# ./bin/zkServer.sh 
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Usage: ./bin/zkServer.sh {start|start-foreground|stop|restart|status|upgrade|print-cmd}
[root@CentOS zookeeper-3.4.6]# ./bin/zkServer.sh start zoo.cfg
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@CentOS zookeeper-3.4.6]# 
[root@CentOS zookeeper-3.4.6]# ./bin/zkServer.sh status zoo.cfg
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Mode: standalone
[root@CentOS zookeeper-3.4.6]# jps
1778 Jps
1733 QuorumPeerMain
  • 安装配置Kafka集群
[root@CentOS ~]# tar -zxf kafka_2.11-2.2.0.tgz -C /usr/
[root@CentOS ~]# cd /usr/kafka_2.11-2.2.0/
[root@CentOS kafka_2.11-2.2.0]# vi config/server.properties 
############################# Server Basics #############################

# The id of the broker. This must be set to a unique integer for each broker.
broker.id=0

############################# Socket Server Settings #############################

listeners=PLAINTEXT://CentOS:9092

############################# Log Basics #############################

log.dirs=/usr/kafka-logs

############################# Log Retention Policy #############################

log.retention.hours=168

############################# Zookeeper #############################

zookeeper.connect=CentOS:2181

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-server-start.sh -daemon config/server.properties

  • 测试Kafka服务

    创建Topic

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                                                --create 
                                                --bootstrap-server CentOS:9092  \
                                                --topic topic01  \
                                                --partitions 3 \
                                                --replication-factor 1
                                                
[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                                                --create \
                                                --zookeeper CentOS:2181  \
                                                --topic topic02  \
                                                --partitions 3 \
                                                --replication-factor 1

kafka自2.2.0版本以后,Toipic的管理使用的的是--bootstrap-server不在使用--zookeeper，--partitions:指定分区数、--replication-factor指定副本因子数，该副本因子不能大于可用的broker节点的个数

查看Topic列表

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                                                --bootstrap-server CentOS:9092 \
                                                --list 
topic01
topic02

查看Topic详情

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                                --describe \
                                --bootstrap-server CentOS:9092  \
                                --topic topic01
Topic:topic01   PartitionCount:3        ReplicationFactor:1     Configs:segment.bytes=1073741824
        Topic: topic01  Partition: 0    Leader: 0       Replicas: 0     Isr: 0
        Topic: topic01  Partition: 1    Leader: 0       Replicas: 0     Isr: 0
        Topic: topic01  Partition: 2    Leader: 0       Replicas: 0     Isr: 0

segment.bytes:Kafka底层在存储分区的文件的时候是按照段落存储的，也就是某个分区的文件达到1GB（1073741824 bytes）的时候，系统会生成新的段落，这种设计有助于Broker节点索引文件。Replicas:表示副本集成员broker-id，Isr:表示处于同步中的正常副本集全称(In Synch Replicate)

在这里插入图片描述

订阅topic

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-console-consumer.sh \
                                              --bootstrap-server CentOS:9092 \
                                              --group g1  \
                                              --topic topic01

查看消费组

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh \
															--bootstrap-server CentOS:9092  \
															--describe \
															--group g1

TOPIC  PARTITION CURRENT-OFFSET LOG-END-OFFSET  LAG  CONSUMER-ID  HOST            CLIENT-ID
topic01 0          0               0             0   consumer-** /192.168.52.129  consumer-1

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh 
                              --bootstrap-server CentOS:9092  
                              --describe 
                              --group g1 
                              --members

CONSUMER-ID                  HOST          CLIENT-ID       #PARTITIONS     
consumer-***              /192.168.52.129  consumer-1      1

生产消息

[root@CentOS kafka_2.11-2.2.0]# ./bin/kafka-console-producer.sh \
                                --broker-list CentOS:9092  \
                                --topic topic01
>

集群环境

  • 安装JDK，配置JAVA_HOME
[root@CentOSX ~]# rpm -ivh jdk-8u191-linux-x64.rpm 
warning: jdk-8u191-linux-x64.rpm: Header V3 RSA/SHA256 Signature, key ID ec551f03: NOKEY
Preparing...                ########################################### [100%]
   1:jdk1.8                 ########################################### [100%]
Unpacking JAR files...
	tools.jar...
	plugin.jar...
	javaws.jar...
	deploy.jar...
	rt.jar...
	jsse.jar...
	charsets.jar...
	localedata.jar...
[root@CentOSX ~]# vi .bashrc 
JAVA_HOME=/usr/java/latest
CLASSPATH=.
PATH=$PATH:$JAVA_HOME/bin
export JAVA_HOME
export CLASSPATH
export PATH
[root@CentOSX ~]# vi .bashrc
  • 配置主机名为CentOS
[root@CentOS ~]# vi /etc/sysconfig/network
NETWORKING=yes
HOSTNAME=CentOS[A,B,C]
  • 配置主机名和IP映射
[root@CentOS ~]# vi /etc/hosts      
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
192.168.52.130 CentOSA
192.168.52.131 CentOSB
192.168.52.132 CentOSC
  • 关闭防火墙
[root@CentOSX ~]# service iptables stop
iptables: Setting chains to policy ACCEPT: filter          [  OK  ]
iptables: Flushing firewall rules:                         [  OK  ]
iptables: Unloading modules:                               [  OK  ]
[root@CentOSX ~]# chkconfig iptables off
[root@CentOSX ~]# chkconfig --list | grep iptables
iptables       	0:关闭	1:关闭	2:关闭	3:关闭	4:关闭	5:关闭	6:关闭
  • 安装配置Zookeeper
[root@CentOSX ~]# tar -zxf zookeeper-3.4.6.tar.gz -C /usr/
[root@CentOSX ~]# cd /usr/zookeeper-3.4.6/
[root@CentOSX zookeeper-3.4.6]# cp conf/zoo_sample.cfg conf/zoo.cfg
[root@CentOSX zookeeper-3.4.6]# vi conf/zoo.cfg 
# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just
# example sakes.
dataDir=/root/zkdata
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
server.1=CentOSA::2888:3888
server.2=CentOSA::2888:3888
server.3=CentOSA::2888:3888
[root@CentOSX ~]# mkdir /root/zkdata
[root@CentOSA ~]# echo 1 > /root/zkdata/myid
[root@CentOSB ~]# echo 2 > /root/zkdata/myid
[root@CentOSC ~]# echo 3 > /root/zkdata/myid
  • 启动zookeeper服务
[root@CentOSX zookeeper-3.4.6]# ./bin/zkServer.sh 
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Usage: ./bin/zkServer.sh {start|start-foreground|stop|restart|status|upgrade|print-cmd}
[root@CentOS zookeeper-3.4.6]# ./bin/zkServer.sh start zoo.cfg
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED
[root@CentOS zookeeper-3.4.6]# 
[root@CentOS zookeeper-3.4.6]# ./bin/zkServer.sh status zoo.cfg
JMX enabled by default
Using config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfg
Mode: leader|follower
[root@CentOSX zookeeper-3.4.6]# jps
1778 Jps
1733 QuorumPeerMain
  • 安装配置Kafka集群
[root@CentOSX ~]# tar -zxf kafka_2.11-2.2.0.tgz -C /usr/
[root@CentOSX ~]# cd /usr/kafka_2.11-2.2.0/
[root@CentOSX kafka_2.11-2.2.0]# vi config/server.properties 
############################# Server Basics #############################

# The id of the broker. This must be set to a unique integer for each broker.
broker.id=[0,1,2]

############################# Socket Server Settings #############################

listeners=PLAINTEXT://CentOS[A,B,C]:9092

############################# Log Basics #############################

log.dirs=/usr/kafka-logs

############################# Log Retention Policy #############################

log.retention.hours=168

############################# Zookeeper #############################

zookeeper.connect=CentOSA:2181,CentOSB:2181,CentOSC:2181

[root@CentOSX kafka_2.11-2.2.0]#./bin/kafka-server-start.sh -daemon config/server.properties

Topic管理(集群)

创建
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                    --bootstrap-server CentOS:9092
                    --create \
                    --topic topic01 \
                    --partitions 1 \
                    --replication-factor 3
列表
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                    --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                    --list
topic01
topic02
详情
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                    --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                    --describe \
                    --topic topic01
Topic:topic01	PartitionCount:3	ReplicationFactor:3	Configs:segment.bytes=1073741824
	Topic: topic01	Partition: 0	Leader: 0	Replicas: 0,2,3	Isr: 0,2,3
	Topic: topic01	Partition: 1	Leader: 2	Replicas: 2,3,0	Isr: 2,3,0
	Topic: topic01	Partition: 2	Leader: 0	Replicas: 3,0,2	Isr: 0,2,3
修改
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh \
                    --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                    --alter \
                    --topic topic03 \
                    --partitions 4 \

仅仅只允许用户增加topic的分区数，不允许减小

删除
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-topics.sh 
                    --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 
                    --delete 
                    --topic topic03
订阅
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-console-consumer.sh \
                  --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                  --topic topic01 \
                  --group g1 \
                  --property print.key=true 
                  --property print.value=true 
                  --property key.separator=,
消费组
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh \
                  --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                  --list
                  g1
                  
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-consumer-groups.sh 
                  --bootstrap-server CentOSA:9092,CentOSB:9092,CentOSC:9092 
                  --describe 
                  --group g1

TOPIC PARTITION CURRENT-OFFSET LOG-END-OFFSET LAG CONSUMER-ID    HOST            CLIENT-ID
topic01 1       0              0               0  consumer-1-** /192.168.52.130 consumer-1
topic01 0       0              0               0  consumer-1-** /192.168.52.130 consumer-1
topic01 2       1              1               0  consumer-1-** /192.168.52.130 consumer-1
生产
[root@CentOSA kafka_2.11-2.2.0]# ./bin/kafka-console-producer.sh \
                  --broker-list CentOSA:9092,CentOSB:9092,CentOSC:9092 \
                  --topic topic01

Kafka API实战

依赖

<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
<dependency>
  <groupId>org.apache.kafka</groupId>
  <artifactId>kafka-clients</artifactId>
  <version>2.2.0</version>
</dependency>

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.25</version>
</dependency>

log4j配置

log4j.rootLogger = info,console

log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern =  %p %d{yyyy-MM-dd HH:mm:ss} %c - %m%n

基础篇

消费者
Properties props = new Properties();
//必须配置
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG,"g3");
//默认配置
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
//如果消费者没有订阅过消息，默认会从当前最新的offset位置开始消费，如果用户希望从最早位置消费可以配置为earliest，默认值是latest
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");

Consumer<String,String> consumer= new KafkaConsumer<String,String>(props);
//订阅相关的topic开头的所有消息
consumer.subscribe(Pattern.compile("^topic.*")); //consumer.subscribe(Arrays.asList("topic01"));

//迭代遍历消息队列
try {
    while (true){
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));//抓取数据，指定抓取的周期
        if(records!=null && !records.isEmpty()){//迭代结果
            Iterator<ConsumerRecord<String, String>> recordIterator = records.iterator();
            while (recordIterator.hasNext()){
                ConsumerRecord<String, String> record = recordIterator.next();
                System.out.println(record.key()+"\t"+record.value()+"\t"+record.offset()+"\t"+record.partition()+"\t"+record.timestamp());
            }
        }
    }
} catch (Exception e) {
    consumer.close();
}
生产者
Properties props = new Properties();
//必选参数
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
//默认配置 可选
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);
//优化配置 批处理、缓冲
props.put(ProducerConfig.BATCH_SIZE_CONFIG,1000);//设置分区 批次大小1000 bytes
props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//最多等待1s钟

Producer<String,String> producer= new KafkaProducer<String,String>(props);

for (int i = 0; i < 10; i++) {
    DecimalFormat format = new DecimalFormat("00");
    String key = format.format(i);
    //默认会按照 hash（key）% 分区数
    ProducerRecord<String,String> record=new ProducerRecord<String, String>("topic01",key,"value"+ key);
    producer.send(record);
}
producer.flush();
producer.close();
序列化

反序列化

public class ObjectDeserializer implements Deserializer<Object> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

    @Override
    public Object deserialize(String topic, byte[] data) {
        return SerializationUtils.deserialize(data);
    }

    @Override
    public void close() {
        System.out.println("close");
    }
}

序列化

public class ObjectSerializer implements Serializer<Object> {

    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

    @Override
    public byte[] serialize(String topic, Object data) {
        return SerializationUtils.serialize((Serializable) data);
    }

    @Override
    public void close() {
        System.out.println("close");
    }
}

生产者

//1.创建链接参数
Properties props=new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,ObjectSerializer.class.getName());

//2.创建生产者
KafkaProducer<String,User> producer=new KafkaProducer<String, User>(props);

//3.封装消息队列
for(Integer i=0;i< 10;i++){
  ProducerRecord<String, User> record = new ProducerRecord<>("topic01", "key"+i,new User(i,"user"+i,new Date()));
  producer.send(record);
}
producer.close();

消费者

//1.创建Kafka链接参数
Properties props=new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,ObjectDeserializer.class.getName());
props.put(ConsumerConfig.GROUP_ID_CONFIG,"group01");

//2.创建Topic消费者
KafkaConsumer<String,User> consumer=new KafkaConsumer<String, User>(props);
//3.订阅topic开头的消息队列
consumer.subscribe(Pattern.compile("^topic.*$"));

while (true){
  ConsumerRecords<String, User> consumerRecords = consumer.poll(Duration.ofSeconds(1));
  Iterator<ConsumerRecord<String, User>> recordIterator = consumerRecords.iterator();
  while (recordIterator.hasNext()){
    ConsumerRecord<String, User> record = recordIterator.next();
    String key = record.key();
    User value = record.value();
    long offset = record.offset();
    int partition = record.partition();
    System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
  }
}
自定义分区
public class UserDefinePartitioner  implements Partitioner {
    private AtomicInteger atomicInteger=new AtomicInteger(0);
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        int numPartitions = cluster.partitionsForTopic(topic).size();
        if(keyBytes==null || keyBytes.length==0){
            return atomicInteger.addAndGet(1) & Integer.MAX_VALUE% numPartitions;
        } else {
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    @Override
    public void close() {
        System.out.println("close");
    }

    @Override
    public void configure(Map<String, ?> configs) {
        System.out.println("configure");
    }
}

//1.创建链接参数
Properties props=new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,UserDefinePartitioner.class.getName());

//2.创建生产者
KafkaProducer<String,String> producer=new KafkaProducer<String, String>(props);

//3.封账消息队列
for(Integer i=0;i< 10;i++){
  ProducerRecord<String, String> record = new ProducerRecord<>("topic01",  "value" + i);
  producer.send(record);
}

producer.close();
拦截器
public class UserDefineProducerInterceptor implements ProducerInterceptor {
  @Override
  public ProducerRecord onSend(ProducerRecord record) {
    ProducerRecord wrapRecord = new ProducerRecord(record.topic(), record.key(), record.value());
    wrapRecord.headers().add("user","baizhi edu".getBytes());
    return wrapRecord;
  }

  @Override
  public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
    System.out.println("metadata:"+metadata+",exception:"+exception);
  }

  @Override
  public void close() {
    System.out.println("close");
  }

  @Override
  public void configure(Map<String, ?> configs) {
    System.out.println("configure");
  }
}

//1.创建链接参数
Properties props=new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,UserDefineProducerInterceptor.class.getName());

//2.创建生产者
KafkaProducer<String,String> producer=new KafkaProducer<String, String>(props);

//3.封账消息队列
for(Integer i=0;i< 10;i++){
  ProducerRecord<String, String> record = new ProducerRecord<>("topic01", "key" + i, "value" + i);
  producer.send(record);
}

producer.close();

高级篇

Offset控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AxkOPbFE-1604132386055)(assets/image-20201020100259319.png)]

为了避免消费到重复数据，我们可以考虑使用手动提交offset偏移量，注意在提交的时候我们可以通过record实例获取到当前消费分区的最新偏移量offset，但是需要在提交的时候给每个分区的offset加1，因为提交的offset是消费者下一次读取分区的起始位置。

Properties props = new Properties();
//必须配置
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG,"g3");
//默认配置
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
//如果消费者没有订阅过消息，默认会从当前最新的offset位置开始消费，如果用户希望从最早位置消费可以配置为earliest，默认值是latest
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");

//取消手动提交，此时auto.commit.interval.ms就不在生效
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,5000);


Consumer<String,String> consumer= new KafkaConsumer<String,String>(props);
//订阅相关的topic开头的所有消息
consumer.subscribe(Pattern.compile("^topic.*")); //consumer.subscribe(Arrays.asList("topic01"));

//迭代遍历消息队列
try {
    while (true){
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));//抓取数据，指定抓取的周期
        //存储 分区和offset信息
        Map<TopicPartition,OffsetAndMetadata> offsets=new HashMap<TopicPartition,OffsetAndMetadata>();

        if(records!=null && !records.isEmpty()){//迭代结果
            Iterator<ConsumerRecord<String, String>> recordIterator = records.iterator();
            while (recordIterator.hasNext()){
                ConsumerRecord<String, String> record = recordIterator.next();
                //获取分区和offset
                TopicPartition topicPartition=new TopicPartition(record.topic(),record.partition());
                //必须加1
                OffsetAndMetadata currentOffsetAndMetadata=new OffsetAndMetadata(record.offset()+1);

                offsets.put(topicPartition,currentOffsetAndMetadata);

                System.out.println(record.key()+"\t"+record.value()+"\t"+record.offset()+"\t"+record.partition()+"\t"+record.timestamp());
            }
        }

        //提交偏移量信息
        consumer.commitSync(offsets,Duration.ofSeconds(1));
        offsets.clear();
    }
} catch (Exception e) {
    consumer.close();
}

注意消费端提交的offset必须是下一次读取的起始位置因此提交的分区的offset需要+1操作

Acks&Retries

Kafka生产者在发送完一个的消息之后，要求Broker在规定的额时间内应答，如果没有在规定时间内应答，Kafka生产者会尝试n次重新发送消息。
在这里插入图片描述
如果重试N<=n次成功则认定此消息发送成功，如果N>n次依然失败，则认定本次发送失败，向上层跑出异常。开启重试虽然增强了可靠性，但是可能会导致服务器端存储重复消息。

Properties props = new Properties();
//必选参数
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
//默认配置 可选
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);
//优化配置 批处理、缓冲
props.put(ProducerConfig.BATCH_SIZE_CONFIG,1000);//设置分区 批次大小1000 bytes
props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//最多等待1s钟

// 1:leader写成功即可，相对来说比较安全 相对较快    0:不会等待服务器应答，丢数据 快     -1/all: 必须等所有的ISR节点同步完成后，才会给应答
props.put(ProducerConfig.ACKS_CONFIG,"-1");
// 生产者默认最多等待30s,如果在规定的时间内，服务器没有给出Ack信号，生产者会根据配置的retries次数进行重试
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,1);
props.put(ProducerConfig.RETRIES_CONFIG,5);


Producer<String,String> producer= new KafkaProducer<String,String>(props);

for (int i = 0; i < 10; i++) {
    DecimalFormat format = new DecimalFormat("00");
    String key = format.format(i);
    //默认会按照 hash（key）% 分区数
    ProducerRecord<String,String> record=new ProducerRecord<String, String>("topic01",key,"value"+ key);
    producer.send(record);
}
producer.flush();
producer.close();
幂等性

HTTP/1.1中对幂等性的定义是：一次和多次请求某一个资源对于资源本身应该具有同样的结果（网络超时等问题除外）。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

Methods can also have the property of “idempotence” in that (aside from error or expiration issues) the side-effects of N > 0 identical requests is the same as for a single request.

Kafka在0.11.0.0版本支持增加了对幂等的支持。幂等是针对生产者角度的特性。幂等可以保证上生产者发送的消息，不会丢失，而且不会重复。实现幂等的关键点就是服务端可以区分请求是否重复，过滤掉重复的请求。要区分请求是否重复的有两点：

唯一标识：要想区分请求是否重复，请求中就得有唯一标识。例如支付请求中，订单号就是唯一标识

记录下已处理过的请求标识：光有唯一标识还不够，还需要记录下那些请求是已经处理过的，这样当收到新的请求时，用新请求中的标识和处理记录进行比较，如果处理记录中有相同的标识，说明是重复交易，拒绝掉。

Kafka可能存在多个生产者，会同时产生消息，但对Kafka来说，只需要保证每个生产者内部的消息幂等就可以了，所有引入了PID来标识不同的生产者。

对于Kafka来说，要解决的是生产者发送消息的幂等问题。也即需要区分每条消息是否重复。
Kafka通过为每条消息增加一个Sequence Numbler，通过Sequence Numbler来区分每条消息。每条消息对应一个分区，不同的分区产生的消息不可能重复。所有Sequence Numbler对应每个分区

Broker端在缓存中保存了这seq number，对于接收的每条消息，如果其序号比Broker缓存中序号大于1则接受它，否则将其丢弃。

在这里插入图片描述

Properties props = new Properties();
//必选参数
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
//默认配置 可选
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);
//优化配置 批处理、缓冲
props.put(ProducerConfig.BATCH_SIZE_CONFIG,1000);//设置分区 批次大小1000 bytes
props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//最多等待1s钟

// 1:leader写成功即可，相对来说比较安全 相对较快    0:不会等待服务器应答，丢数据 快     -1/all: 必须等所有的ISR节点同步完成后，才会给应答
props.put(ProducerConfig.ACKS_CONFIG,"-1");
// 生产者默认最多等待30s,如果在规定的时间内，服务器没有给出Ack信号，生产者会根据配置的retries次数进行重试
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,1);
props.put(ProducerConfig.RETRIES_CONFIG,5);

//开启生产者的幂等性，解决retries带来的重复数据 kafka 0.11版本引入新特性
props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);



Producer<String,String> producer= new KafkaProducer<String,String>(props);

for (int i = 0; i <5; i++) {
DecimalFormat format = new DecimalFormat("00");
String key = format.format(i);
//默认会按照 hash（key）% 分区数
ProducerRecord<String,String> record=new ProducerRecord<String, String>("topic01",key,"value"+ key);
producer.send(record);
}
producer.flush();
producer.close();
事务控制

幂等性和重试机制仅仅只能保证分区单条记录的原子性写入，但是如果用户需要实现夸分区的原子性写入此时需要开启kafka的事务控制。

生产者Only

Properties props = new Properties();
//必选参数
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
//默认配置 可选
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);
//优化配置 批处理、缓冲
props.put(ProducerConfig.BATCH_SIZE_CONFIG,1000);//设置分区 批次大小1000 bytes
props.put(ProducerConfig.LINGER_MS_CONFIG,1000);//最多等待1s钟

// 1:leader写成功即可，相对来说比较安全 相对较快   0:不会等待服务器应答，丢数据 快  -1/all: 必须等所有的ISR节点同步完成后，才会给应答
props.put(ProducerConfig.ACKS_CONFIG,"-1");
// 生产者默认最多等待30s,如果在规定的时间内，服务器没有给出Ack信号，生产者会根据配置的retries次数进行重试
props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,5000);
props.put(ProducerConfig.RETRIES_CONFIG,5);

//开启生产者的幂等性，解决retries带来的重复数据 kafka 0.11版本引入新特性
props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);

//1、配置事务ID，要求ID必须唯一
props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id001");

Producer<String,String> producer= new KafkaProducer<String,String>(props);
//2.初始化事务
producer.initTransactions();

try{
    //3.开启事务
    producer.beginTransaction();
    for (int i = 0; i <5; i++) {
        DecimalFormat format = new DecimalFormat("00");
        String key = format.format(i);
        //默认会按照 hash（key）% 分区数
        ProducerRecord<String,String> record=new ProducerRecord<String, String>("topic01",key,"value"+ key);
        producer.send(record);
        if(i==3) {
            int b=i/0;
        }
        producer.flush();
    }
    //4.提交事务
    producer.commitTransaction();
}catch (Exception e){
    System.err.println(e.getMessage());
    //5.终止事务
    producer.abortTransaction();
}


producer.close();

需要注意消费者那边必须升级事务的隔离级别，否则有可能读到生产者未提交的数据。

Properties props = new Properties();
//必须配置
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOS:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG,"g3");
//默认配置
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
//如果消费者没有订阅过消息，默认会从当前最新的offset位置开始消费，如果用户希望从最早位置消费可以配置为earliest，默认值是latest
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");

//取消手动提交，此时auto.commit.interval.ms就不在生效
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,5000);

//如果生产者那边控制了事务，消费这边默认的事务隔离是read_uncommitted,必须配置成read_committed才可以
props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed");

Consumer<String,String> consumer= new KafkaConsumer<String,String>(props);
//订阅相关的topic开头的所有消息
consumer.subscribe(Pattern.compile("^topic.*")); //consumer.subscribe(Arrays.asList("topic01"));

//迭代遍历消息队列
try {
while (true){
ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));//抓取数据，指定抓取的周期
//存储 分区和offset信息
Map<TopicPartition,OffsetAndMetadata> offsets=new HashMap<TopicPartition,OffsetAndMetadata>();

if(records!=null && !records.isEmpty()){//迭代结果
Iterator<ConsumerRecord<String, String>> recordIterator = records.iterator();
while (recordIterator.hasNext()){
ConsumerRecord<String, String> record = recordIterator.next();
//获取分区和offset
TopicPartition topicPartition=new TopicPartition(record.topic(),record.partition());
//必须加1
OffsetAndMetadata currentOffsetAndMetadata=new OffsetAndMetadata(record.offset()+1);

offsets.put(topicPartition,currentOffsetAndMetadata);

System.out.println(record.key()+"\t"+record.value()+"\t"+record.offset()+"\t"+record.partition()+"\t"+record.timestamp());
}
}

//提交偏移量信息
consumer.commitSync(offsets,Duration.ofSeconds(1));
offsets.clear();
}
} catch (Exception e) {
consumer.close();
}

消费者&生产者

在这里插入图片描述

//1.生产者&消费者
KafkaProducer<String,String> producer=buildKafkaProducer();
KafkaConsumer<String, String> consumer = buildKafkaConsumer("group01");

consumer.subscribe(Arrays.asList("topic01"));
producer.initTransactions();//初始化事务

try{
  while(true){
    ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
    Iterator<ConsumerRecord<String, String>> consumerRecordIterator = consumerRecords.iterator();
    //开启事务控制
    producer.beginTransaction();
    Map<TopicPartition, OffsetAndMetadata> offsets=new HashMap<TopicPartition, OffsetAndMetadata>();
    while (consumerRecordIterator.hasNext()){
      ConsumerRecord<String, String> record = consumerRecordIterator.next();
      //创建Record
      ProducerRecord<String,String> producerRecord=new ProducerRecord<String,String>("topic02",record.key(),record.value());
      producer.send(producerRecord);
      //记录元数据
      offsets.put(new TopicPartition(record.topic(),record.partition()),new OffsetAndMetadata(record.offset()+1));
    }
    //提交事务
    producer.sendOffsetsToTransaction(offsets,"group01");
    producer.commitTransaction();
  }
}catch (Exception e){
  producer.abortTransaction();//终止事务
}finally {
  producer.close();
}

public static KafkaProducer<String,String> buildKafkaProducer(){
  Properties props=new Properties();
  props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
  props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
  props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
  props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id");
  return new KafkaProducer<String, String>(props);
}
public static KafkaConsumer<String,String> buildKafkaConsumer(String group){
  Properties props=new Properties();
  props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
  props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
  props.put(ConsumerConfig.GROUP_ID_CONFIG,group);
  props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);
  props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG,"read_committed");

  return new KafkaConsumer<String, String>(props);
}

Kafka架构进阶

Kafka-Eagle(鹰眼)

这是一个监视系统，监视您的kafka群集以及可视的使用者线程，偏移量，所有者等。当您安装Kafka Eagle时，用户可以看到当前的使用者组，对于每个组，他们正在消耗的Topic以及该组在每个主题中的偏移量，滞后，日志大小和位置。这对于了解用户从消息队列消耗的速度以及消息队列增加的速度很有用。

下载地址：https://codeload.github.com/smartloli/kafka-eagle-bin/tar.gz/v1.4.0

安装

[root@CentOS ~]# tar -zxf kafka-eagle-web-1.4.0-bin.tar.gz -C /usr/
[root@CentOS ~]# mv /usr/kafka-eagle-web-1.4.0 /usr/kafka-eagle
[root@CentOS ~]# vi .bashrc
KE_HOME=/usr/kafka-eagle
M2_HOME=/usr/apache-maven-3.6.3
SQOOP_HOME=/usr/sqoop-1.4.7
HIVE_HOME=/usr/apache-hive-1.2.2-bin
JAVA_HOME=/usr/java/latest
HADOOP_HOME=/usr/hadoop-2.9.2/
HBASE_HOME=/usr/hbase-1.2.4/
ZOOKEEPER_HOME=/usr/zookeeper-3.4.6
PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$HBASE_HOME/bin:$M2_HOME/bin:$HIVE_HOME/bin:$SQOOP_HOME/bin:$ZOOKEEPER_HOME/bin:$KE_HOME/bin
CLASSPATH=.
export JAVA_HOME
export PATH
export CLASSPATH
export HADOOP_HOME
export HBASE_HOME
HBASE_CLASSPATH=$(/usr/hbase-1.2.4/bin/hbase classpath)
HADOOP_CLASSPATH=/root/mysql-connector-java-5.1.49.jar
export HADOOP_CLASSPATH
export M2_HOME
export HIVE_HOME
export SQOOP_HOME
export ZOOKEEPER_HOME
export KE_HOME
[root@CentOS ~]# source .bashrc 
[root@CentOS ~]# cd /usr/kafka-eagle/
[root@CentOS kafka-eagle]# vi conf/system-config.properties 

######################################
# multi zookeeper&kafka cluster list
######################################
kafka.eagle.zk.cluster.alias=cluster1
cluster1.zk.list=CentOS:2181

######################################
# zk client thread limit
######################################
kafka.zk.limit.size=25

######################################
# kafka eagle webui port
######################################
kafka.eagle.webui.port=8048

######################################
# kafka offset storage
######################################
cluster1.kafka.eagle.offset.storage=kafka

######################################
# kafka metrics, 30 days by default
######################################
kafka.eagle.metrics.charts=true
kafka.eagle.metrics.retain=30


######################################
# kafka sql topic records max
######################################
kafka.eagle.sql.topic.records.max=5000
kafka.eagle.sql.fix.error=false

######################################
# delete kafka topic token
######################################
kafka.eagle.topic.token=keadmin

######################################
# kafka sasl authenticate
######################################
cluster1.kafka.eagle.sasl.enable=false
cluster1.kafka.eagle.sasl.protocol=SASL_PLAINTEXT
cluster1.kafka.eagle.sasl.mechanism=SCRAM-SHA-256
cluster1.kafka.eagle.sasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username="kafka" password="kafka-eagle";
cluster1.kafka.eagle.sasl.client.id=

######################################
# kafka sqlite jdbc driver address
######################################
#kafka.eagle.driver=org.sqlite.JDBC
#kafka.eagle.url=jdbc:sqlite:/hadoop/kafka-eagle/db/ke.db
#kafka.eagle.username=root
#kafka.eagle.password=www.kafka-eagle.org

######################################
# kafka mysql jdbc driver address
######################################
kafka.eagle.driver=com.mysql.jdbc.Driver
kafka.eagle.url=jdbc:mysql://CentOS:3306/ke?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
kafka.eagle.username=root
kafka.eagle.password=root

[root@CentOS kafka-eagle]# chmod u+x bin/ke.sh

如果需要检测Kafka性能指标需要修改Kafka启动文件

[root@CentOS ~]# cd /usr/kafka_2.11-2.2.0/
[root@CentOS kafka_2.11-2.2.0]# vi bin/kafka-server-start.sh

...
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
    export KAFKA_HEAP_OPTS="-server -Xms2G -Xmx2G -XX:PermSize=128m -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:ParallelGCThreads=8 -XX:ConcGCThreads=5 -XX:InitiatingHeapOccupancyPercent=70"
    export JMX_PORT="9999"
    #export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi

重启Kafka服务使用kafka-server-stop.sh关闭kafka服务！

[root@CentOS kafka-eagle]# ./bin/ke.sh start

在这里插入图片描述

Flume&Kafka

# Name the components on this agent
a1.sources = r1
a1.sinks = k1
a1.channels = c1

# Describe/configure the source
a1.sources.r1.type = netcat
a1.sources.r1.bind = CentOS
a1.sources.r1.port = 44444

# Describe the sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.topic = topic01
a1.sinks.k1.kafka.bootstrap.servers = CentOSA:9092,CentOSB:9092,CentOSC:9092
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = -1
a1.sinks.k1.kafka.producer.linger.ms = 100
a1.sinks.k1.kafka.producer.compression.type = snappy

# Use a channel which buffers events in memory
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100

# Bind the source and sink to the channel
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

Spring Boot & Kafka

  • 引入依赖
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.1.5.RELEASE</version>
</parent>

<dependencies>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>

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

  <!--测试-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>

</dependencies>

@SpringBootTest(classes = {KafkaSpringBootApplication.class})
@RunWith(SpringRunner.class)
public class KafkaTempolateTests {
    @Autowired
    private KafkaTemplate kafkaTemplate;
    @Autowired
    private IOrderService orderService;

    @Test
    public void testOrderService(){
        orderService.saveOrder("001","baizhi edu ");
    }
    @Test
    public void testKafkaTemplate(){
        kafkaTemplate.executeInTransaction(new KafkaOperations.OperationsCallback() {
            @Override
            public Object doInOperations(KafkaOperations kafkaOperations) {
                return kafkaOperations.send(new ProducerRecord("topic01","002","this is a demo"));
            }
        });
    }

}

spring.kafka.bootstrap-servers=CentOSA:9092,CentOSB:9092,CentOSC:9092

spring.kafka.producer.retries=5
spring.kafka.producer.acks=all
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=33554432
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.properties.enable.idempotence=true
spring.kafka.producer.transaction-id-prefix=transaction-id-

spring.kafka.consumer.group-id=group1
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.enable-auto-commit=true
spring.kafka.consumer.auto-commit-interval=100
spring.kafka.consumer.properties.isolation.level=read_committed
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

@SpringBootApplication
@EnableKafkaStreams
@EnableKafka
public class KafkaSpringBootApplication {
    public static void main(String[] args) throws IOException {
        SpringApplication.run(KafkaSpringBootApplication.class,args);
        System.in.read();
    }



    @KafkaListeners(value = {@KafkaListener(topics = {"topic04"})})
    @SendTo(value = {"topic05"})
    public String listenner(ConsumerRecord<?, ?> cr) {
    
        return cr.value()+" baizhi edu";
    }
}

@Transactional
@Service
public class OrderService implements IOrderService {

    @Autowired
    private KafkaTemplate kafkaTemplate;

    @Override
    public void saveOrder(String id,Object message) {
        kafkaTemplate.send(new ProducerRecord("topic04",id,message));
    }
}
weixin_42118315
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
kafka消息队列样例
09-07
kafka消息队列消费者生产者读写样例。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据。
kafka消息队列
MarryOnlyQueen的博客
07-06 3374
kafka介绍 英文文档：kafka官方文档 中文学习文档：kafka中文文档简介 kafka写操作快的原因：kafka的特点 磁盘随机IO和顺序IO的对比：随机和顺序I/O 简介：kafka是一个事件流平台，专门为分布式高吞吐量系统而设计的消息传递系统，相对其他消息系统有更好的吞吐量、内置分区、复制和固有的容错能留，使其更适合处理大规模的消息程序。 kafka的两种模式 点对点：消息被保留在队列中。一个或者多个消费者可以消耗队列中的消息，但是特定消息只能由最多一个消费者消费。消息被消费后将会从队列消
Kafka - 消息队列
weixin_39540280的博客
09-11 327
Kafka 基础概念 Kafka Kafka 已被多家不同类型的公司作为多种类型的数据管道和消息系统使用。行为流数据是几乎所有站点在对其网站使用情况做报表时都要用到的数据中最常规的部分。 包括页面访问量 PV、页面曝光 Expose、页面点击 Click 等行为事件； 实时计算中的 Kafka Source，Dataflow Pipeline； 业务的消息系统，通过发布订阅消息解耦多组微服务，消除峰值； Kafka 是由 LinkedIn 开发并开源的分布式消息系统，因其分布式及高吞吐率...
消息队列: Kafka
Xin Adn Meng
09-11 1237
分布式消息队列: Kafka
kafka消息队列学习笔记
07-02
kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列...
通过pykafka接收Kafka消息队列的方法
09-19
在本文中，我们将深入探讨如何使用Python库`pykafka`来接收Kafka消息队列。`pykafka`是一个强大的工具，它提供了与Apache Kafka交互的能力，使得在Python环境中处理分布式消息传递变得简单。Kafka是一种高吞吐量、...
KOA+egg.js集成kafka消息队列的示例
01-01
系统要求：日志记录，通过kafka进行消息队列控制 思路图： 这里消费者和生产者都由日志系统提供 λ.1 环境准备 ①Kafka 官网下载kafka后，解压 启动zookeeper： bin/zookeeper-server-start.sh config/zookeeper....
最新ELK集群 => KafKa消息队列.pdf
08-23
Apache Kafka 是一个高性能、分布式的实时消息队列系统，它最初由 LinkedIn 开发，后来成为 Apache 软件基金会的顶级项目。Kafka 的设计目标是处理大规模的数据流，它提供了高吞吐量、低延迟的消息传递能力，适合...
springboot整合Kafka消息队列demo源码案例演示
最新发布
07-23
一、简介 二、环境搭建 1、Kafka部署 2、Kafka测试 3、可视化工具 三、工程搭建 1、工程结构 2、依赖管理 3、配置文件 四、基础用法 1、消息生产 2、消息消费 五、参考源码
Kafka 消息队列（高清版）深入理解Kafka：核心设计与实践原理.zip
05-15
《Kafka 消息队列（高清版）深入理解Kafka：核心设计与实践原理》是一本详尽探讨Apache Kafka的书籍，旨在帮助读者深入掌握Kafka的核心设计理念和实际操作技巧。Kafka是一个分布式流处理平台，广泛应用于大数据处理...
基于Kafka消息队列的新一代分布式电量采集方法研究.pdf
08-08
#资源达人分享计划#
kafka安装包、消息队列
12-28
标题中的“kafka安装包、消息队列”指的是Apache Kafka，一个开源的分布式流处理平台，常被用作高吞吐量的消息中间件。Kafka作为一个消息队列，能够高效地处理实时数据流，实现数据的发布和订阅功能。在这个压缩包中...
springboot 整合消息队列kafka(kafka-with-springboot.rar)
08-19
在本文中，我们将深入探讨如何将Spring Boot与Apache Kafka整合，构建一个高效的消息队列系统。Apache Kafka是一个分布式流处理平台，它允许我们处理和存储大量实时数据。Spring Boot简化了Java应用程序的开发，尤其...
Apache Kafka 消息队列篇
L_Mr_ll的博客
12-23 733
概述 Kafka是Apache软件基金会的开源的流处理平台，该平台提供了消息的订阅与发布，能够基于Kafka实现对网络日志流实时在线处理，在这个维度上弥补了Hadoop的离线分析系统的不足。因为基于hadoop的MapReduce系统分析离线数据延迟较高，而且不支持动态数据处理和分析。Kafka的流处理平台不仅仅可以为离线系统储备数据（通常使用Kafka作为数据缓冲），而且Kafka自身也提供了一...
【后端】消息队列--Kafka篇
王大阳的博客
04-02 4252
parition中的消息采用多个小文件段的方式存储，很容易实现消息定期清除或删除已经消费完的文件。通过索引文件可以快速定位message在日志文件中的位置。索引文件通过Mmap技术直接映射到内存中，这样对索引的操作就不需要操作磁盘IO，也减少了数据在内存中的拷贝次数。索引文件采用稀疏存储，可以大幅降低索引文件映射到内存中时占用的内存空间大小。它把所有的消息都变成一个批量的文件，并且进行合理的批量压缩，减少网络IO损耗通过mmap提高I/O速度，写入数据的时候由于。
【ELFK】之消息队列kafka
种一颗树最好的时间是十年前，其次是现在！
09-03 819
kafka是由Linkedin公司开发，是一个分布式，支持分区（partition）、多副本的（repilca），基于zookeeper协调的分布式消息系统。它的最大的特性就是可以实时的处理大量数据以满足各种需求场景，比如：基于hadoop（分布式）的批处理系统，低延迟的实时系统，storm/Spark流式处理引擎，web/nginx日志、访问日志，消息服务等等，用scala语言编写，Linkedin于2010年贡献给了Apache基金会并成为顶级开源 项目。
Kafka消息队列学习（一）
芸兮的博客
08-13 486
Kafka将生产者发布的消息发布到topic中，需要这些消息的消费者可以订阅这些主题。Producer（生产者）: 产生消息的一方。Consumer（消费者）: 消费消息的一方。Broker（代理 / 单个kafka实例）:可以看作是一个独立的Kafka实例。多个Kafka Broker组成一个Kafka Cluster。每个 Broker 中又包含了 Topic 以及 Partition这两个重要的概念Topic（主题）
kafka 消息队列
08-27
Kafka以可持久化的、分布式的、分区的消息日志的形式来存储消息。它的设计目标是能够处理大规模的消息流，并且具备可水平扩展、高吞吐量和低延迟的特性。 Kafka的核心概念包括以下几个部分： 1. Topic：消息的分类...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值