kafka开发

上篇文章中我们搭建了kafka的服务器,并可以使用Kafka的命令行工具创建topic,发送和接收消息。下面我们来搭建kafka的开发环境。

添加依赖

搭建开发环境需要引入kafka的jar包,一种方式是将Kafka安装包中lib下的jar包加入到项目的classpath中,这种比较简单了。不过我们使用另一种更加流行的方式:使用maven管理jar包依赖。
创建好maven项目后,在pom.xml中添加以下依赖:
               
[html]  view plain copy
  1. <dependency>  
  2.          <groupId> org.apache.kafka</groupId >  
  3.          <artifactId> kafka_2.10</artifactId >  
  4.          <version> 0.8.0</ version>  
  5. </dependency>  

添加依赖后你会发现有两个jar包的依赖找不到。没关系我都帮你想好了,点击 这里下载这两个jar包,解压后你有两种选择,第一种是使用mvn的install命令将jar包安装到本地仓库,另一种是直接将解压后的文件夹拷贝到mvn本地仓库的com文件夹下,比如我的本地仓库是d:\mvn,完成后我的目录结构是这样的:

目录结构

配置程序

首先是一个充当配置文件作用的接口,配置了Kafka的各种连接参数:
[java]  view plain copy
  1. package com.sohu.kafkademon;  
  2.   
  3. public interface KafkaProperties  
  4. {  
  5.     final static String zkConnect = "10.22.10.139:2181";  
  6.     final static String groupId = "group1";  
  7.     final static String topic = "topic1";  
  8.     final static String kafkaServerURL = "10.22.10.139";  
  9.     final static int kafkaServerPort = 9092;  
  10.     final static int kafkaProducerBufferSize = 64 * 1024;  
  11.     final static int connectionTimeOut = 20000;  
  12.     final static int reconnectInterval = 10000;  
  13.     final static String topic2 = "topic2";  
  14.     final static String topic3 = "topic3";  
  15.     final static String clientId = "SimpleConsumerDemoClient";  
  16. }  


producer

[java]  view plain copy
  1. package com.sohu.kafkademon;  
  2.   
  3. import java.util.Properties;  
  4.   
  5. import kafka.producer.KeyedMessage;  
  6. import kafka.producer.ProducerConfig;  
  7.   
  8. /** 
  9.  * @author leicui bourne_cui@163.com 
  10.  */  
  11. public class KafkaProducer extends Thread  
  12. {  
  13.     private final kafka.javaapi.producer.Producer<Integer, String> producer;  
  14.     private final String topic;  
  15.     private final Properties props = new Properties();  
  16.   
  17.     public KafkaProducer(String topic)  
  18.     {  
  19.         props.put("serializer.class""kafka.serializer.StringEncoder");  
  20.         props.put("metadata.broker.list""10.22.10.139:9092");  
  21.         producer = new kafka.javaapi.producer.Producer<Integer, String>(new ProducerConfig(props));  
  22.         this.topic = topic;  
  23.     }  
  24.   
  25.     @Override  
  26.     public void run() {  
  27.         int messageNo = 1;  
  28.         while (true)  
  29.         {  
  30.             String messageStr = new String("Message_" + messageNo);  
  31.             System.out.println("Send:" + messageStr);  
  32.             producer.send(new KeyedMessage<Integer, String>(topic, messageStr));  
  33.             messageNo++;  
  34.             try {  
  35.                 sleep(3000);  
  36.             } catch (InterruptedException e) {  
  37.                 // TODO Auto-generated catch block  
  38.                 e.printStackTrace();  
  39.             }  
  40.         }  
  41.     }  
  42.   
  43. }  



consumer

[java]  view plain copy
  1. package com.sohu.kafkademon;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Properties;  
  7.   
  8. import kafka.consumer.ConsumerConfig;  
  9. import kafka.consumer.ConsumerIterator;  
  10. import kafka.consumer.KafkaStream;  
  11. import kafka.javaapi.consumer.ConsumerConnector;  
  12.   
  13. /** 
  14.  * @author leicui bourne_cui@163.com 
  15.  */  
  16. public class KafkaConsumer extends Thread  
  17. {  
  18.     private final ConsumerConnector consumer;  
  19.     private final String topic;  
  20.   
  21.     public KafkaConsumer(String topic)  
  22.     {  
  23.         consumer = kafka.consumer.Consumer.createJavaConsumerConnector(  
  24.                 createConsumerConfig());  
  25.         this.topic = topic;  
  26.     }  
  27.   
  28.     private static ConsumerConfig createConsumerConfig()  
  29.     {  
  30.         Properties props = new Properties();  
  31.         props.put("zookeeper.connect", KafkaProperties.zkConnect);  
  32.         props.put("group.id", KafkaProperties.groupId);  
  33.         props.put("zookeeper.session.timeout.ms""40000");  
  34.         props.put("zookeeper.sync.time.ms""200");  
  35.         props.put("auto.commit.interval.ms""1000");  
  36.         return new ConsumerConfig(props);  
  37.     }  
  38.   
  39.     @Override  
  40.     public void run() {  
  41.         Map<String, Integer> topicCountMap = new HashMap<String, Integer>();  
  42.         topicCountMap.put(topic, new Integer(1));  
  43.         Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCountMap);  
  44.         KafkaStream<byte[], byte[]> stream = consumerMap.get(topic).get(0);  
  45.         ConsumerIterator<byte[], byte[]> it = stream.iterator();  
  46.         while (it.hasNext()) {  
  47.             System.out.println("receive:" + new String(it.next().message()));  
  48.             try {  
  49.                 sleep(3000);  
  50.             } catch (InterruptedException e) {  
  51.                 e.printStackTrace();  
  52.             }  
  53.         }  
  54.     }  
  55. }  


简单的发送接收

运行下面这个程序,就可以进行简单的发送接收消息了:
[java]  view plain copy
  1. package com.sohu.kafkademon;  
  2.   
  3. /** 
  4.  * @author leicui bourne_cui@163.com 
  5.  */  
  6. public class KafkaConsumerProducerDemo  
  7. {  
  8.     public static void main(String[] args)  
  9.     {  
  10.         KafkaProducer producerThread = new KafkaProducer(KafkaProperties.topic);  
  11.         producerThread.start();  
  12.   
  13.         KafkaConsumer consumerThread = new KafkaConsumer(KafkaProperties.topic);  
  14.         consumerThread.start();  
  15.     }  
  16. }  


高级别的consumer

下面是比较负载的发送接收的程序:
[java]  view plain copy
  1. package com.sohu.kafkademon;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Properties;  
  7.   
  8. import kafka.consumer.ConsumerConfig;  
  9. import kafka.consumer.ConsumerIterator;  
  10. import kafka.consumer.KafkaStream;  
  11. import kafka.javaapi.consumer.ConsumerConnector;  
  12.   
  13. /** 
  14.  * @author leicui bourne_cui@163.com 
  15.  */  
  16. public class KafkaConsumer extends Thread  
  17. {  
  18.     private final ConsumerConnector consumer;  
  19.     private final String topic;  
  20.   
  21.     public KafkaConsumer(String topic)  
  22.     {  
  23.         consumer = kafka.consumer.Consumer.createJavaConsumerConnector(  
  24.                 createConsumerConfig());  
  25.         this.topic = topic;  
  26.     }  
  27.   
  28.     private static ConsumerConfig createConsumerConfig()  
  29.     {  
  30.         Properties props = new Properties();  
  31.         props.put("zookeeper.connect", KafkaProperties.zkConnect);  
  32.         props.put("group.id", KafkaProperties.groupId);  
  33.         props.put("zookeeper.session.timeout.ms""40000");  
  34.         props.put("zookeeper.sync.time.ms""200");  
  35.         props.put("auto.commit.interval.ms""1000");  
  36.         return new ConsumerConfig(props);  
  37.     }  
  38.   
  39.     @Override  
  40.     public void run() {  
  41.         Map<String, Integer> topicCountMap = new HashMap<String, Integer>();  
  42.         topicCountMap.put(topic, new Integer(1));  
  43.         Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCountMap);  
  44.         KafkaStream<byte[], byte[]> stream = consumerMap.get(topic).get(0);  
  45.         ConsumerIterator<byte[], byte[]> it = stream.iterator();  
  46.         while (it.hasNext()) {  
  47.             System.out.println("receive:" + new String(it.next().message()));  
  48.             try {  
  49.                 sleep(3000);  
  50.             } catch (InterruptedException e) {  
  51.                 e.printStackTrace();  
  52.             }  
  53.         }  
  54.     }  
  55. }  
<think>我们正在回答用户关于Kafka开发技术的基本介绍入门指南的问题。根据引用资料,Kafka是由Apache软件基金会开发的开源流处理平台,最初由LinkedIn开发,用于解决高吞吐量实时性场景的问题。它已成为企业级基础设施中处理流式数据的重要工具。 我们将从以下几个方面介绍Kafka: 1. Kafka的基本概念 2. Kafka的核心特性 3. Kafka的架构 4. Kafka的安装与启动 5. Kafka的基本操作 6. 编程语言操作Kafka(如Python) 7. Kafka消息存储机制 8. Kafka的读写流程 下面开始详细说明。</think>### Kafka开发技术介绍与入门指南 --- #### 一、Kafka核心概念 1. **定位与特性** - **分布式流处理平台**:兼具消息队列、流存储实时计算能力[^1][^4]。 - **核心特性**: - **高吞吐**:单集群可达百万级TPS(如LinkedIn单日处理2万亿消息)[^2][^5]。 - **低延迟**:端到端延迟可控制在10ms内[^4]。 - **持久化存储**:消息按顺序持久化到磁盘,支持TB级数据保留[^1][^3]。 2. **核心组件** | 组件 | 作用 | |---------------|---------------------------------------| | **Producer** | 发布消息到指定Topic(支持异步/同步发送) | | **Consumer** | 订阅Topic并消费消息(支持消费者组负载均衡)| | **Broker** | Kafka服务节点,存储消息处理请求 | | **Topic** | 消息的逻辑分类(可分区存储) | | **ZooKeeper** | 管理集群元数据与Broker协调(Kafka 3.0+逐步移除)[^4] | --- #### 二、开发环境搭建 1. **快速启动单节点集群** ```bash # 下载Kafka(以3.6.1为例) wget https://downloads.apache.org/kafka/3.6.1/kafka_2.13-3.6.1.tgz # 启动ZooKeeper(Kafka内置) bin/zookeeper-server-start.sh config/zookeeper.properties # 启动Kafka Broker bin/kafka-server-start.sh config/server.properties ``` 2. **基础操作命令** ```bash # 创建Topic(分区数=3,副本数=1) bin/kafka-topics.sh --create --topic orders --partitions 3 --replication-factor 1 --bootstrap-server localhost:9092 # 生产消息 bin/kafka-console-producer.sh --topic orders --bootstrap-server localhost:9092 # 消费消息(从头开始) bin/kafka-console-consumer.sh --topic orders --from-beginning --bootstrap-server localhost:9092 ``` --- #### 三、开发实战:生产者与消费者 1. **Java生产者示例** ```java Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); Producer<String, String> producer = new KafkaProducer<>(props); producer.send(new ProducerRecord<>("orders", "order-123", "iPhone 15")); // 发送消息 producer.close(); ``` 2. **Python消费者示例** ```python from kafka import KafkaConsumer consumer = KafkaConsumer( 'orders', bootstrap_servers='localhost:9092', auto_offset_reset='earliest' # 从最早消息开始消费 ) for msg in consumer: print(f"Received: {msg.value.decode('utf-8')}") ``` --- #### 四、高级特性与应用 1. **消息存储机制** - **分区存储**:每个Topic划分为多个Partition,分布在不同Broker[^3][^7]。 - **分段日志**:数据按`<topic>-<partition>/000000.log`格式存储,支持快速追加写入[^3][^7]。 - **索引文件**:`.index`文件加速消息定位(偏移量索引 + 时间戳索引)。 2. **读写流程优化** - **写入流程**: ```mermaid graph LR A[Producer] -->|1. 序列化消息| B[Partitioner] B -->|2. 选择Partition| C[Leader Broker] C -->|3. 写入PageCache| D[磁盘异步刷盘] ``` - **读取流程**: - 消费者直接读取PageCache(零拷贝技术)[^1][^4]。 3. **流处理集成** - **Spark Streaming**: ```scala val stream = SparkSession.builder .getOrCreate() .readStream .format("kafka") .option("kafka.bootstrap.servers", "localhost:9092") .option("subscribe", "orders") .load() ``` --- #### 五、生产环境最佳实践 1. **集群部署建议** | 参数 | 推荐值 | 说明 | |---------------------|---------------------|-----------------------| | `num.partitions` | ≥3 | 避免单分区瓶颈 | | `replication.factor`| 3 | 保障数据高可用 | | `min.insync.replicas`| 2 | ISR最小同步副本数[^4] | 2. **监控与运维** - **关键指标**: - 消息堆积量(`kafka-consumer-groups.sh`) - Broker磁盘使用率 - **工具推荐**: - Kafka Manager:集群监控 - Prometheus + Grafana:指标可视化 --- ### 相关问题 1. Kafka的ISR机制如何保障数据一致性? 2. 如何通过Kafka实现Exactly-Once语义? 3. Kafka与Flink集成时如何解决状态管理问题? 4. 如何设计跨数据中心的Kafka集群架构? 5. Kafka的Log Compaction机制如何工作? > 提示:生产环境务必启用**SSL加密****SASL认证**,并使用**多副本机制**(replication.factor≥3)保障高可用[^1][^4]。测试推荐使用`kafka-producer-perf-test.sh`进行压测。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值