kafka本地环境测试

一、安装zooeleeper

 

下载安装包:http://zookeeper.apache.org/releases.html#download

 

下载后解压到一个目录:

 

1.进入Zookeeper设置目录,我的D:\java\Tool\zookeeper-3.4.13\conf

2. 将“zoo_sample.cfg”重命名为“zoo.cfg”

3. 在任意文本编辑器(如notepad)中打开zoo.cfg

4. 找到并编辑dataDir=D:\\java\\Tool\\zookeeper-3.4.13\\tmp

5. 与Java中的做法类似,我们在系统环境变量中添加:

  a. 在系统变量中添加ZOOKEEPER_HOME = D:\java\Tool\zookeeper-3.4.13

  b. 编辑path系统变量,添加为路径%ZOOKEEPER_HOME%\bin;

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

修改zkServer.cmd   set JAVA=D:\JDK1.8\bin\java  自己的jdk路径

 

打开新的cmd,输入zkServer,运行Zookeeper。

8. 命令行提示如下:说明本地Zookeeper启动成功

 

 

 

二、安装与运行Kafka

下载http://kafka.apache.org/downloads.html。注意要下载二进制版本的

 

 

下载后解压到任意一个目录,我的的是D:\Java\Tool\kafka_2.11-0.10.0.1

 

1. 进入Kafka配置目录,D:\java\Tool\kafka_2.11-0.10.0.1

2. 编辑文件“server.properties”

3. 找到并编辑log.dirs=D:\java\Tool\kafka_2.11-0.10.0.1\kafka-log,这里的目录自己修改成自己喜欢的

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

5. Kafka会按照默认,在9092端口上运行,并连接zookeeper的默认端口:2181。

6.修改kafka-run-class.bat

 

找到 set JAVA的地方 改成set JAVA=D:\JDK1.8/bin/java 自己的jdk路径

在kafka安装目录中找到bin\windows目录中的kafka-run-class.bat为%CLASSPATH%加上双引号

#修改前

set COMMAND=%JAVA%%KAFKA_HEAP_OPTS% %KAFKA_JVM_PERFORMANCE_OPTS% %KAFKA_JMX_OPTS%%KAFKA_LOG4J_OPTS% -cp%CLASSPATH% %KAFKA_OPTS% %*   

 

#修改后

set COMMAND=%JAVA%%KAFKA_HEAP_OPTS% %KAFKA_JVM_PERFORMANCE_OPTS% %KAFKA_JMX_OPTS%%KAFKA_LOG4J_OPTS% -cp"%CLASSPATH%"%KAFKA_OPTS% %*

 

运行:

重要:请确保在启动Kafka服务器前,Zookeeper实例已经准备好并开始运行。

1.进入Kafka安装目录D:\java\Tool\kafka_2.11-0.10.0.1

2.按下Shift+右键,选择“打开命令窗口”选项,打开命令行。

3.现在输入

.\bin\windows\kafka-server-start.bat .\config\server.properties

 

 

 

 

三、测试

上面的Zookeeper和kafka一直打开

(1)、创建主题

1.进入Kafka安装目录D:\Java\Tool\kafka_2.11-0.10.0.1

2.按下Shift+右键,选择“打开命令窗口”选项,打开命令行。

3.现在输入

.\bin\windows\kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic zhengneng

 

 

 

创建生产者

进入Kafka安装目录D:\Java\Tool\kafka_2.11-0.10.0.1

2.按下Shift+右键,选择“打开命令窗口”选项,打开命令行。

3.现在输入D:\java\Tool\kafka_2.11-0.10.0.1>.\bin\windows\kafka-console-producer.bat --broker-list localhost:9092 --topic zhangneng

 

创建消费者

进入Kafka安装目录D:\Java\Tool\kafka_2.11-0.10.0.1

2.按下Shift+右键,选择“打开命令窗口”选项,打开命令行。

3.现在输入D:\java\Tool\kafka_2.11-0.10.0.1>.\bin\windows\kafka-console-consumer.bat --zookeeper localhost:2181 --topic zhangneng

 

然后在生产者控制台输入信息  消费者控制台就会打印出信息

 

结合我们的项目 jdk版本使用1.8

 

pom.xml

<dependency>

   <groupId>org.apache.kafka</groupId>

   <artifactId>kafka-clients</artifactId>

   <version>2.1.1</version>

</dependency>

<dependency>

   <groupId>org.apache.kafka</groupId>

   <artifactId>kafka_2.12</artifactId>

   <version>2.1.1</version>

</dependency>

<dependency>

   <groupId>org.springframework.kafka</groupId>

   <artifactId>spring-kafka</artifactId>

   <version>1.1.1.RELEASE</version>

</dependency>

 

worker.properties

################# kafka producer ##################

kafka.producer.bootstrap.servers=localhost:9092

kafka.producer.acks = all

#发送失败重试次数

kafka.producer.retries = 3

kafka.producer.linger.ms = 10

# 33554432 即32MB的批处理缓冲区

kafka.producer.buffer.memory = 40960

#批处理条数:当多个记录被发送到同一个分区时,生产者会尝试将记录合并到更少的请求中。这有助于客户端和服务器的性能

kafka.producer.batch.size = 4096

kafka.producer.defaultTopic = test

 

################# kafka consumer ################## ,

kafka.consumer.bootstrap.servers = localhost:9092

# 如果为true,消费者的偏移量将在后台定期提交

kafka.consumer.enable.auto.commit = true

#如何设置为自动提交(enable.auto.commit=true),这里设置自动提交周期

kafka.consumer.auto.commit.interval.ms=1000

#order-beta 消费者群组ID,发布-订阅模式,即如果一个生产者,多个消费者都要消费,那么需要定义自己的群组,同一群组内的消费者只有一个能消费到消息

kafka.consumer.group.id = order-beta

#在使用Kafka的组管理时,用于检测消费者故障的超时

kafka.consumer.session.timeout.ms = 30000

 

创建 生产者 kafka-producer.xml

<!--基本配置 -->

<bean id="producerProperties" class="java.util.HashMap">

   <constructor-arg>

      <map>

         <!-- kafka服务地址,可能是集群-->

         <entry key="bootstrap.servers" value="${kafka.producer.bootstrap.servers}" />

         <!-- 有可能导致broker接收到重复的消息,默认值为3-->

         <entry key="retries" value="${kafka.producer.retries}" />

         <!-- 每次批量发送消息的数量-->

         <entry key="batch.size" value="${kafka.producer.batch.size}" />

         <!-- 默认0ms,在异步IO线程被触发后(任何一个topic,partition满都可以触发)-->

         <entry key="linger.ms" value="${kafka.producer.linger.ms}" />

         <!--producer可以用来缓存数据的内存大小。如果数据产生速度大于向broker发送的速度,producer会阻塞或者抛出异常 -->

         <entry key="buffer.memory" value="${kafka.producer.buffer.memory}" />

         <!-- producer需要server接收到数据之后发出的确认接收的信号,此项配置就是指procuder需要多少个这样的确认信号-->

         <entry key="acks" value="${kafka.producer.acks}" />

         <entry key="key.serializer" value="org.apache.kafka.common.serialization.StringSerializer" />

         <entry key="value.serializer" value="org.apache.kafka.common.serialization.StringSerializer" />

      </map>

   </constructor-arg>

</bean>

 

<!-- 创建kafkatemplate需要使用的producerfactory bean -->

<bean id="producerFactory"

     class="org.springframework.kafka.core.DefaultKafkaProducerFactory">

   <constructor-arg>

      <ref bean="producerProperties" />

   </constructor-arg>

</bean>

 

<!-- 创建kafkatemplate bean,使用的时候,只需要注入这个bean,即可使用template的send消息方法 -->

<bean id="KafkaTemplate" class="org.springframework.kafka.core.KafkaTemplate">

   <constructor-arg ref="producerFactory" />

   <!--设置对应topic-->

   <property name="defaultTopic" value="${kafka.producer.defaultTopic}" />

</bean>

 

创建 消费者 kafka-consumer.xml

<!--基本配置 -->

<bean id="consumerProperties" class="java.util.HashMap">

   <constructor-arg>

      <map>

         <!--Kafka服务地址 -->

         <entry key="bootstrap.servers" value="${kafka.consumer.bootstrap.servers}" />

         <!--Consumer的组ID,相同goup.id的consumer属于同一个组。 -->

         <entry key="group.id" value="${kafka.consumer.group.id}" />

         <!--如果此值设置为true,consumer会周期性的把当前消费的offset值保存到zookeeper。当consumer失败重启之后将会使用此值作为新开始消费的值。 -->

         <entry key="enable.auto.commit" value="${kafka.consumer.enable.auto.commit}" />

         <!--网络请求的socket超时时间。实际超时时间由max.fetch.wait + socket.timeout.ms 确定 -->

         <entry key="session.timeout.ms" value="${kafka.consumer.session.timeout.ms}" />

         <entry key="key.deserializer"

               value="org.apache.kafka.common.serialization.StringDeserializer" />

         <entry key="value.deserializer"

               value="org.apache.kafka.common.serialization.StringDeserializer" />

      </map>

   </constructor-arg>

</bean>

 

<!-- 实际执行消息消费的类 -->

<bean id="messageListernerConsumerService" class="com.qianxiang.v1.common.kafka.KafkaConsumerListener" />

 

<!-- 创建consumerFactory bean -->

<bean id="consumerFactory" class="org.springframework.kafka.core.DefaultKafkaConsumerFactory">

   <constructor-arg>

      <ref bean="consumerProperties"/>

   </constructor-arg>

</bean>

 

<!-- 消费者容器配置信息 -->

<bean id="containerProperties" class="org.springframework.kafka.listener.config.ContainerProperties">

   <constructor-arg value="test"/>

   <property name="messageListener" ref="messageListernerConsumerService"/>

</bean>

 

<!-- 创建messageListenerContainer bean,使用的时候,只需要注入这个bean -->

<bean id="messageListenerContainer" class="org.springframework.kafka.listener.KafkaMessageListenerContainer"init-method="doStart">

    <constructor-arg ref="consumerFactory"/>

       <constructor-arg ref="containerProperties"/>

</bean>

 

 

spring-context.xml 增加配置

<import resource="kafka-producer.xml"></import>

<import resource="kafka-consumer.xml"></import>

 

 

 

public void onMessage(ConsumerRecord<Integer, String> consumerRecord) {

 

    Object o = consumerRecord.value();

    System.out.println(String.valueOf(o));

}

 

 

 

测试方法

 

@Resource

private KafkaTemplate<Integer, String> kafkaTemplate;

 

 

 

 

@UnSession

@RequestMapping(value = "/lcmain")

public void getlcbidmain() throws Exception {

   kafkaTemplate.setProducerListener(producerListener);

   System.out.println(kafkaTemplate.getDefaultTopic());

   kafkaTemplate.sendDefault("testvalue");

}

 

 

 

 

kafkaTemplate 

Ctrl+鼠标左键进入KafkaTemplate的源代码中查看一下,可以看到有关发送的接口如下。

 

topic:这里填写的是Topic的名字

partition:这里填写的是分区的id,其实也是就第几个分区,id从0开始。表示指定发送到该分区中

timestamp:时间戳,一般默认当前时间戳

key:消息的键

data:消息的数据

ProducerRecord:消息对应的封装类,包含上述字段

Message<?>:Spring自带的Message封装类,包含消息及消息头

 

1、根据业务需要,发送数据消息到Kafka可能需要在业务逻辑处理完成之后,特别是在对外服务的接口中,为保证接口不超时,发送消息到Kafka,把消息丢到线程池中,而不要使用Kafka提供的send方法直接方法,否则出现异常,对系统本身 以及对 接口响应时间 都有影响,在线程池中,实现send功能,并且要捕获异常。

 

2、订阅Kafka消息的Consumer代码,也要捕获异常,防止因为其它的异常,导致系统业务不能正常使用

 

3、无论是请求外部系统的接口,还是提供给外部系统的接口,都要捕获异常,不要因为外部系统接口的问题,导致自身系统业务逻辑出错

 

 

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页