kafka

最新推荐文章于 2024-06-22 06:00:00 发布

qq_41770939

最新推荐文章于 2024-06-22 06:00:00 发布

阅读量148

点赞数

分类专栏：大数据

本文链接：https://blog.csdn.net/qq_41770939/article/details/100694092

版权

大数据专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、介绍

二、kafka环境搭建（win）

三、测试Demo

以下内容只是简单介绍和入门的Demo，如果有比较想深入理解kafka的同学可以看官网；像英语水平和我差不多的同学可以看这里

一、介绍

Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。对于像Hadoop一样的日志数据和离线分析系统，但又要求实时处理的限制，这是一个可行的解决方案。Kafka的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。

——百度百科

以下内容摘抄自官网（https://kafka.apache.org/intro）的介绍：

Apache Kafka® is a distributed streaming platform. What exactly does that mean?

A streaming platform has three key capabilities:

Publish and subscribe to streams of records, similar to a message queue or enterprise messaging system.
Store streams of records in a fault-tolerant durable way.
Process streams of records as they occur.

Kafka is generally used for two broad classes of applications:

Building real-time streaming data pipelines that reliably get data between systems or applications
Building real-time streaming applications that transform or react to the streams of data

To understand how Kafka does these things, let's dive in and explore Kafka's capabilities from the bottom up.

First a few concepts:

Kafka is run as a cluster on one or more servers that can span multiple datacenters.
The Kafka cluster stores streams of records in categories called topics.
Each record consists of a key, a value, and a timestamp.

Kafka has four core APIs:

The Producer API allows an application to publish a stream of records to one or more Kafka topics.
The Consumer API allows an application to subscribe to one or more topics and process the stream of records produced to them.
The Streams API allows an application to act as a stream processor, consuming an input stream from one or more topics and producing an output stream to one or more output topics, effectively transforming the input streams to output streams.
The Connector API allows building and running reusable producers or consumers that connect Kafka topics to existing applications or data systems. For example, a connector to a relational database might capture every change to a table.

二、kafka环境搭建（win）

内容摘抄自：https://www.cnblogs.com/zhangkaimin/p/10947553.html

1) 安装包：Java SE Development Kit 9.0.1

下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.html

2) 配置环境：（与之前版本设置有差异）

3) 打开Dos界面，运行java：

4) 运行javac：

5) 配置完成。

Zookeeper：

1) 建议下载稳定版。

下载地址：http://mirrors.hust.edu.cn/apache/zookeeper/

2) 下载后解压到一个目录：eg: D:\Java\Tool\zookeeper-3.4.10

3) 在zookeeper-3.4.10目录下，新建文件夹，并命名(eg: data).(路径为：D:\Java\Tool\zookeeper-3.4.10\conf\data)

4) 进入Zookeeper设置目录，eg: D:\Java\Tool\zookeeper-3.4.10\conf

复制“zoo_sample.cfg”副本à并将副本重命名为“zoo.cfg”

在任意文本编辑器（eg：记事本）中打开zoo.cfg

找到并编辑dataDir=D:\Java\Tool\zookeeper-3.4.10\data

5) 添加系统环境变量：

在系统变量中添加ZOOKEEPER_HOME = D:\Java\Tool\zookeeper-3.4.10

编辑path系统变量，添加为路径%ZOOKEEPER_HOME%\bin

6) 在zoo.cfg文件中修改默认的Zookeeper端口（默认端口2181）

7) Dos下运行：zkserver

8) 搭建成功。

Kafka：

1) 安装包：kafka_2.12-1.0.0.tgz

下载地址：http://kafka.apache.org/downloads.html

推荐版本：kafka_2.12-1.0.0.tgz

2) 下载后解压缩。eg: D:\Tools\kafka_2.11-1.0.0\

3) 建立一个空文件夹 logs. eg: D:\Tools\kafka_2.11-1.0.0\logs

4) 进入config目录，编辑 server.properties文件(eg: 用“写字板”打开)。

找到并编辑log.dirs= D:\Tools\kafka_2.11-1.0.0\logs

找到并编辑zookeeper.connect=localhost:2181。表示本地运行。

(Kafka会按照默认，在9092端口上运行，并连接zookeeper的默认端口：2181)

运行：请确保在启动Kafka服务器前，Zookeeper实例已经准备好并开始运行。（就是开着Zookeeper窗口不要关）

1) 在 D:\WorkSoftware\kafka_2.11-1.0.0下，按住shift+鼠标右键。

选择“在此处打开Powershell窗口（S）”（如果没有此选项，在此处打开命令窗口）。

2) 运行：.\bin\windows\kafka-server-start.bat .\config\server.properties

3) 可能会报错：“找不到或无法加载主类 Files\java\jdk-9.0.1\lib;C:\Program”

4) 解决（3）的办法：

在kafka安装目录中找到bin\windows目录中的kafka-run-class.bat为%CLASSPATH%加上双引号(可用Matlab打开，并进行搜索)

修改前：setCOMMAND=%JAVA%%KAFKA_HEAP_OPTS% %KAFKA_JVM_PERFORMANCE_OPTS% %KAFKA_JMX_OPTS%%KAFKA_LOG4J_OPTS% -cp%CLASSPATH% %KAFKA_OPTS% %*

修改后：SetCOMMAND=%JAVA%%KAFKA_HEAP_OPTS% %KAFKA_JVM_PERFORMANCE_OPTS% %KAFKA_JMX_OPTS%%KAFKA_LOG4J_OPTS% -cp"%CLASSPATH%"%KAFKA_OPTS% %*

5) 再次运行：.\bin\windows\kafka-server-start.bat.\config\server.properties

6) 搭建成功。

三、测试

以下内容摘抄自（https://blog.csdn.net/qq_38417913/article/details/82108486）

1.pom引入jar包

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka_2.12</artifactId>
    <version>1.1.1</version>
</dependency>

2.创建生产者

public class KProducer {

   public static void main(String[] args) throws InterruptedException {
      Properties props = new Properties();
      //kafka服务器地址
      props.put("bootstrap.servers", "localhost:9092");
      //ack是判断请求是否为完整的条件（即判断是否成功发送）。all将会阻塞消息，这种设置性能最低，但是最可靠。
      props.put("acks", "1");
      //retries,如果请求失败，生产者会自动重试，我们指定是0次，如果启用重试，则会有重复消息的可能性。
      props.put("retries", 0);
      //producer缓存每个分区未发送消息，缓存的大小是通过batch.size()配置设定的。值较大的话将会产生更大的批。并需要更多的内存(因为每个“活跃”的分区都有一个缓冲区)
      props.put("batch.size", 16384);
      //默认缓冲区可立即发送，即便缓冲区空间没有满；但是，如果你想减少请求的数量，可以设置linger.ms大于0.这将指示生产者发送请求之前等待一段时间
      //希望更多的消息补填到未满的批中。这类似于tcp的算法，例如上面的代码段，可能100条消息在一个请求发送，因为我们设置了linger时间为1ms，然后，如果我们
      //没有填满缓冲区，这个设置将增加1ms的延迟请求以等待更多的消息。需要注意的是，在高负载下，相近的时间一般也会组成批，即使是linger.ms=0。
      //不处于高负载的情况下，如果设置比0大，以少量的延迟代价换取更少的，更有效的请求。
      props.put("linger.ms", 1);
      //buffer.memory控制生产者可用的缓存总量，如果消息发送速度比其传输到服务器的快，将会耗尽这个缓存空间。当缓存空间耗尽，其他发送调用将被阻塞，阻塞时间的阈值
      //通过max.block.ms设定，之后他将抛出一个TimeoutExecption。
      props.put("buffer.memory", 33554432);
      //key.serializer和value.serializer示例：将用户提供的key和value对象ProducerRecord转换成字节，你可以使用附带的ByteArraySerizlizaer或StringSerializer处理简单的byte和String类型.
      props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
      props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
      //设置kafka的分区数量
      props.put("kafka.partitions", 12);

      Producer<String, String> producer = new KafkaProducer<>(props);
      for (int i = 0; i < 50; i++) {
         System.out.println("key-->key" + i + "  value-->vvv" + i);
         producer.send(new ProducerRecord<String, String>("my-topic", "key" + i, "vvv" + i));
         Thread.sleep(1000);
      }

      producer.close();
   }
}

3.创建消费者

public class KConsumer {

   public KafkaConsumer<String, String> getConsmer() {
      Properties props = new Properties();
      //设置kafka服务器
//    props.put("bootstrap.servers", "192.168.4.40:9092");
      props.put("bootstrap.servers", "localhost:9092");
      //消费者群组ID，发布-订阅模式，即如果一个生产者，多个消费者都要消费，那么需要定义自己的群组，同一个群组内的消费者只有一个能消费到消息
      props.put("group.id", "test");
      //true，消费者的偏移量将在后台定期提交；false关闭自动提交位移，在消息被完整处理之后再手动提交位移
      props.put("enable.auto.commit", "true");
      //如何设置为自动提交（enable.auto.commit=true）,这里设置自动提交周期
      props.put("auto.commit.interval.ms", "1000");
      //session.timeout.ms:在使用kafka的组管理时，用于检测消费者故障的超时
      props.put("session.timeout.ms", "30000");
      //key.serializer和value.serializer示例：将用户提供的key和value对象ProducerRecord转换成字节，你可以使用附带的ByteArraySerizlizaer或StringSerializer处理简单的byte和String类型.
      props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
      props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
      KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
      return consumer;
   }


   public static void main(String[] args) {

        // 用法一
        ConsumerProperties consumerProperties = new ConsumerProperties("my-topic");
        consumerProperties.setServers("localhost:9092");
        TopicConsumer.receive(consumerProperties,(k) -> {
            System.out.println(k);
        });
        
/*      // 用法二 
      KConsumer kconsumer = new KConsumer();
      KafkaConsumer<String, String> consumer = kconsumer.getConsmer();
*/

      // 指定消费者消费的topic  多个topic用,分隔
   /* consumer.subscribe(Arrays.asList("my-topic"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records)
                System.out.println("offset =  " + record.offset() + ", key = " + record.key() + ", value = " + record.value());
        }*/


   /*     // 取出所有(包括历史)topic 以及 topic 对应的分区信息
        Map<String, List<PartitionInfo>> topics = consumer.listTopics();
        topics.keySet().forEach(k -> {
            System.out.println("topic : "+k+" "+topics.get(k));
        });*/


//    consumer.close();

   }
 }

                 {\__/}                                          {\__/}
                 ( ·-·)                                          (·-· )
                 / >------------------------------------------------< \
                          |      ☆                            |
                          |         ☆                         |
                          |  ★                                |
                          |         ☆                         |
                          |      ☆                            |
                          |                                   |
                          -------------------------------------

qq_41770939

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
kafka

目录一、介绍二、kafka环境搭建（win）三、测试Demo 以下内容只是简单介绍和入门的Demo，如果有比较想深入理解kafka的同学可以看官网；像英语水平和我差不多的同学可以看这里一、介绍Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。...
复制链接

扫一扫