Kafka与springmvc整合-yellowcong

版权声明：本文为博主yellowcong原创文章，未经博主允许不得转载。 https://blog.csdn.net/yelllowcong/article/details/88660582

Springmvc和kafka得整合，相对于springboot复杂了一下，需要手动得注册监听器，实现对kafka消息得监听，需要手动注入KafkaTemplate 得配置，然后调用。

添加依赖

<!-- 添加kafka得客户端 -->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>1.0.1</version>
</dependency>

<!-- 添加spring-kafka -->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>1.1.1.RELEASE</version>
</dependency>

1. 生产者

1.1 kafka配置

配置生产者

# kafka配置
kafka.bootstrap-servers=192.168.10.100:9092,192.168.10.101:9092,192.168.10.102:9092,192.168.10.103:9092,192.168.10.104:9092
#topic配置
kafka.topic.name=ba_jump_api

#尝试次数
kafka.producer.retries=1
#批次大小
kafka.producer.batch-size=16384
#内存大小
kafka.producer.buffer-memory=33554432

# 指定消息key和消息体的编解码方式
kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

1.2 xml配置

	<bean id="kafkaServer"
		class="com.yellowcong.service.KafkaServer">
		<property name="kafkaTemplate" ref="kafkaTemplate" ></property>
		<property name="topic" value="${kafka.topic.name}"></property>
	</bean>
	
	<!--基本配置 -->
	<bean id="producerProperties" class="java.util.HashMap">
	    <constructor-arg>
	        <map>
	            <!-- kafka服务地址，可能是集群-->
	            <entry key="bootstrap.servers" value="${kafka.bootstrap-servers}" />
	            <!-- 有可能导致broker接收到重复的消息,默认值为3-->
	            <entry key="retries" value="10" />
	            <!-- 每次批量发送消息的数量-->
	            <entry key="batch.size" value="33554432" />
	            <!-- 默认0ms，在异步IO线程被触发后（任何一个topic，partition满都可以触发）-->
	            <entry key="linger.ms" value="1" />
	            <!--producer可以用来缓存数据的内存大小。如果数据产生速度大于向broker发送的速度，producer会阻塞或者抛出异常 -->
	            <entry key="buffer.memory" value="33554432 " />
	            <!-- producer需要server接收到数据之后发出的确认接收的信号，此项配置就是指procuder需要多少个这样的确认信号-->
	            <entry key="acks" value="all" />
	            <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.topic.name}" />
	</bean>

1.2 创建kafkaserver

通过这个类进行发送消息

package com.yellowcong.service;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

import com.yellowcong.common.AppLog;

/**
 * 代码创建: yellowcong <br/>
 * 创建日期: 2019年3月18日 <br/>
 * 功能描述: 
 */
@Service
public class KafkaServer {
	
	KafkaTemplate<String,String> kafkaTemplate;
	
	private String topic;
	
	public void setTopic(String topic) {
		this.topic = topic;
	}

	public void setKafkaTemplate(KafkaTemplate kafkaTemplate) {
		this.kafkaTemplate = kafkaTemplate;
	}


	/**
	 * 代码创建: yellowcong <br/>
	 * 创建日期: 2019年3月18日 <br/>
	 * 功能描述: 异步发送日志到kafka中
	 */
	public void sendLogAsyn(final String log) {
		try {
			//走我们设定的默认的topic
			kafkaTemplate.send(topic,log);
		} catch (Exception e) {
			e.printStackTrace();
			AppLog.kafka.error(e.getMessage());
		}
	}
	
	
	/**
	 * 代码创建: yellowcong <br/>
	 * 创建日期: 2019年3月18日 <br/>
	 * 功能描述: 同步发送日志到kafka中
	 */
	public void sendLogSync(final String log ) {
		try {
			kafkaTemplate.send(null,log).get();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
}

2. 消费者

2.1 kafka配置

# kafka配置
kafka.bootstrap-servers=192.168.10.100:9092,192.168.10.101:9092,192.168.10.102:9092,192.168.10.103:9092,192.168.10.104:9092

#格式
kafka.consumer.group-id=consumer-ba-jump-2
#自动提交
kafka.consumer.enable-auto-commit=true

#kafka超时时间
kafka.consumer.session.timeout=20000
#topic得名称
kafka.topic.name=ba_jump_api
#消费线程数
kafka.consumer.concurrency=10
#消费方式，当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费 
kafka.auto.offset.reset=earliest 

2.2 xml配置

 <bean id="consumerProperties" class="java.util.HashMap">
	    <constructor-arg>
	        <map>
	            <!--Kafka服务地址 -->
	            <entry key="bootstrap.servers" value="${kafka.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} " />
	            <entry key="auto.offset.reset" value="${kafka.auto.offset.reset}" />
	            <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 -->
    <bean id="kafkaConsumerListener" class="com.yellowcong.sys.listener.KafkaConsumerListener" />
  
    <!-- 创建consumerFactory bean -->
	<bean id="consumerFactory" class="org.springframework.kafka.core.DefaultKafkaConsumerFactory">
	    <constructor-arg>
	        <ref bean="consumerProperties"/>
	    </constructor-arg>
	</bean>

	<!-- 设定topic信息 -->
	<bean id="containerProperties" class="org.springframework.kafka.listener.config.ContainerProperties">
	    <constructor-arg value="${kafka.topic.name}"/>
	    <property name="messageListener" ref="kafkaConsumerListener"/>
	</bean>

	<bean id="messageListenerContainer" class="org.springframework.kafka.listener.KafkaMessageListenerContainer" init-method="doStart">
	    <constructor-arg ref="consumerFactory"/>
	    <constructor-arg ref="containerProperties"/>
	</bean>

2.3 KafkaConsumerListener

创建一个kafka得消费者，需要实现MessageListener得接口，然后复写里面得onMessage 实现消息得监听处理

package com.yellowcong.sys.listener;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.listener.MessageListener;

import com.yellowcong.jump.service.PvuvService;

/**
 * 代码创建: yellowcong <br/>
 * 创建日期: 2019年3月19日 <br/>
 * 功能描述: 
 */
public class KafkaConsumerListener implements MessageListener<String, String> {

	@Autowired
	PvuvService logService;
	
	@Override
	public void onMessage(ConsumerRecord<String, String> data) {
		
		//监听messge的处理
//		logService.countPvUv(data.value());
		System.out.println("获取到数据:\t"+data.value());
	}
}

参考文章

https://blog.csdn.net/wu18296184782/article/details/80164190