kafka入门

惨猴

于 2020-03-09 10:41:19 发布

阅读量146

点赞数

分类专栏：大数据

本文链接：https://blog.csdn.net/qq_37696899/article/details/104745096

版权

大数据专栏收录该内容

8 篇文章 0 订阅

订阅专栏

大数据实施框架_kafka

1. 消息队列

消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，有消息系统来确保信息的可靠传递，消息发布者只管把消息发布到MQ中而不管谁来取，消息使用者只管从MQ中取消息而不管谁发布的，这样发布者和使用者都不用知道对方的存在

1.1 消息队列的应用场景

消息队列在实际应用中包括如下四个场景：

1) 应用耦合：多应用间通过消息队列对同一消息进行处理，避免调用接口失败导致整个过程失败；
2) 异步处理：多应用对消息队列中同一消息进行处理，应用间并发处理消息，相比串行处理，减少处理时间；
3) 限流削峰：广泛应用于秒杀或抢购活动中，避免流量过大导致应用系统挂掉的情况；
4) 消息驱动的系统：系统分为消息队列、消息生产者、消息消费者，生产者负责产生消息，消费者(可能有多个)负责对消息进行处理

1.2 消息队列的两种模式

消息队列包括两种模式，点对点模式（point to point， queue）和发布/订阅模式（publish/subscribe，topic）

2. kafka

kafka是最初由linkedin公司开发的，使用scala语言编写，kafka是一个分布式，分区的，多副本的，多订阅者的日志系统（分布式MQ系统），可以用于搜索日志，监控日志，访问日志等

kafka对消息保存时根据Topic进行归类，发送消息者成为Producer,消息接受者成为Consumer,此外kafka集群有多个kafka实例组成，每个实例(server)成为broker。无论是kafka集群，还是producer和consumer都依赖于zookeeper来保证系统可用性集群保存一些meta信息

kakfa的特点:

可靠性: 分布式, 分区 , 复制和容错等

可扩展性: kakfa消息传递系统轻松缩放, 无需停机

耐用性: kafka使用分布式提交日志, 这个意味着消息会尽可能快速的保存在磁盘上, 因此它是持久的

性能: kafka对于发布和订阅消息都具有高吞吐量, 即使存储了许多TB的消息, 他也爆出稳定的性能

kafka非常快: 保证零停机和零数据丢失

apache kafka是一个分布式发布-订阅消息系统和一个强大的队列，可以处理大量的数据，并使能够将消息从一个端点传递到另一个端点，kafka适合离线和在线消息消费。kafka消息保留在磁盘上，并在集群内复制以防止数据丢失。kafka构建在zookeeper同步服务之上。它与apache和spark非常好的集成，应用于实时流式数据分析。

kafka的主要应用场景:

1) 指标分析: kafka通常用于操作监控数据, 这设计聚合来自分布式应用程序和统计信息, 以产生操作的数据集中反馈

2) 日志聚合解决方法: kafka可用于跨组织从多个服务器收集日志, 并使他们一标准的合适提供给多个服务器

3) 流式处理: 流式的处理框架(spark, storm , flink) 从主题中读取数据, 对其进行处理, 并将处理后的结果数据写入新的主题, 供用户和应用程序使用, kafka的强耐久性在流处理的上下文中也非常的有用

2.1 kafka架构

3. kafka的基本操作

3.0 启动kafka

cd /export/servers/kafka/bin
#前端启动
./kafka-server-start.sh /export/servers/kafka/config/server.properties

#后台启动:
nohup ./kafka-server-start.sh /export/servers/kafka/config/server.properties 2>&1 &

注意：可以启动一台broker，单机版。也可以同时启动三台broker，组成一个kafka集群版

#kafka停止
./kafka-server-stop.sh

3.1 shell操作

1) 创建topic

创建一个名字为test的主题，有三个分区，有两个副本

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh --create --zookeeper node01:2181 --replication-factor 2 --partitions 3 --topic test

2) 查看主题命令

查看kafka当中存在的主题

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh  --list --zookeeper node01:2181,node02:2181,node03:2181

3) 生产者生产数据

模拟生产者来生产数据

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-console-producer.sh --broker-list node01:9092,node02:9092,node03:9092 --topic test

4) 消费者消费数据

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-console-consumer.sh --from-beginning --topic test  --zookeeper node01:2181,node02:2181,node03:2181
bin/kafka-console-consumer.sh --bootstrap-server Node01:9092 --topic test02

5) 运行describe的命令

运行describe查看topic的相关详细信息
```
cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh --describe --zookeeper node01:2181 --topic test
```
结果说明：

这是输出的解释。第一行给出了所有分区的摘要，每个附加行提供有关一个分区的信息。由于我们只有一个分区用于此主题，因此只有一行。

“leader”是负责给定分区的所有读取和写入的节点。每个节点将成为随机选择的分区部分的领导者。（因为在kafka中如果有多个副本的话，就会存在leader和follower的关系，表示当前这个副本为leader所在的broker是哪一个）

“replicas”是复制此分区日志的节点列表，无论它们是否为领导者，或者即使它们当前处于活动状态。（所有副本列表 0 ，1,2）

“isr”是“同步”复制品的集合。这是副本列表的子集，该列表当前处于活跃状态并且已经被领导者捕获。（可用的列表数）

6) 增加topic分区数

任意kafka服务器执行以下命令可以增加topic分区数

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh --zookeeper zkhost:port --alter --topic topicName --partitions 8

7) 增加配置

动态修改kakfa的配置

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh --zookeeper node01:2181 --alter --topic test --config flush.messages=1

8) 删除配置

动态删除kafka集群配置

cd /export/servers/kafka_2.11-1.0.0
bin/kafka-topics.sh --zookeeper node01:2181 --alter --topic test --delete-config flush.messages

9) 删除topic

目前删除topic在默认情况下知识打上一个删除的标记，在重新启动kafka后才删除。如果需要立即删除，则需要在

server.properties中配置：

delete.topic.enable=true

然后执行以下命令进行删除topic
```
kafka-topics.sh --zookeeper zkhost:port --delete --topic topicName
```

4. kafka的javaAPI的操作

kafka相关依赖

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

</dependencies>

<build>
    <plugins>
        <!-- java编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.2</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

kafka生产者代码

public class OrderProducer {
    public static void main(String[] args) {
        //1.创建kafka的生产者对象
        Properties props = new Properties();
        //kafka集群地址
        props.put("bootstrap.servers", "node01:9092");
        //ack数据校验机制    all   表示数据必须完整传递
        props.put("acks", "all");
        //重试的测试
        props.put("retries", 0);
        //一批数据的大小    16kb
        props.put("batch.size", 16384);
        //发送数据的间隔时间
        props.put("linger.ms", 1);
        //缓存池大小   32M
        props.put("buffer.memory", 33554432);
        //key value使用何种序列化
        props.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer kafkaProducer = new KafkaProducer(props);

        //2.发送数据
        for (int i = 0; i < 10; i++) {
            ProducerRecord producerRecord = new ProducerRecord("test02","你好,我是测试生产者");
            kafkaProducer.send(producerRecord);
        }

        //3.释放资源
        kafkaProducer.close();

    }
}

kafka消费者代码(自动提交偏移量)

public class OrderConsumer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "Node01:9092,Node02:9092,Node03:9092");
        props.setProperty("group.id", "test");//组id
        props.setProperty("enable.auto.commit", "true");//自动提交偏移量数据
        props.setProperty("auto.commit.interval.ms", "1000");//自动提交偏移量的间隔时间
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        //1.创建消费者的核心对象
        KafkaConsumer kafkaConsumer = new KafkaConsumer(props);
        //2.绑定要监听的topic:可以一个可以多个
        kafkaConsumer.subscribe(Arrays.asList("test02"));
        while (true){
            //3.获取数据.一直监听操作,循环获取
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(1000);
            for (ConsumerRecord<String,String> consumerRecord : consumerRecords) {
                String value = consumerRecord.value();
                long offset = consumerRecord.offset();
                System.out.println(value+";数据的偏移量:"+offset);
            }
        }
        //4.释放资源

    }
}

kafka消费者代码(手动提交偏移量)

//手动提交偏移量
public class OrderConsumerTest {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "Node01:9092,Node02:9092,Node03:9092");
        props.setProperty("group.id", "111");//组id
        props.setProperty("enable.auto.commit", "false");//自动提交偏移量数据
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer kafkaConsumer = new KafkaConsumer(props);
        kafkaConsumer.subscribe(Arrays.asList("test02"));

        while(true){
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(1000);
            for (ConsumerRecord<String,String> consumerRecord : consumerRecords) {
                String value = consumerRecord.value();
                System.out.println(value);
                //根据value发送邮件/短信

                //消费完成,异步提交此数据的偏移量
                kafkaConsumer.commitAsync();

                //消费完成,同步提交此数据的偏移量
                kafkaConsumer.commitSync();
            }
        }
    }
}

惨猴

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
kafka入门

大数据实施框架_kafka1. 消息队列消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，有消息系统来确保信息的可靠传递，消息发布者只管把消息发布到MQ中而不管谁来取，消息使用者只管从MQ中取消息而不管谁发布的，这样发布者和使用者都不用知道对方的存在1.1消息队列的应用场景消息队列在实际应用中包括如下四个场景： 1) 应用耦合：...
复制链接

扫一扫