Kafka与Spring的集成

最新推荐文章于 2024-07-13 00:30:00 发布
最新推荐文章于 2024-07-13 00:30:00 发布
阅读量282 收藏
点赞数
分类专栏： java编程 文章标签： spring kafka protobuf mq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_12335/article/details/82646407
版权
[b]producer[/b] 

public class KafkaServiceImpl implements KafkaService {

	private Producer<byte[], byte[]> inner;

	private Properties properties;


	public void setInner(Producer<byte[], byte[]> inner) {
		this.inner = inner;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	public void init() throws IOException {
		ProducerConfig config = new ProducerConfig(properties);
		inner = new Producer<byte[], byte[]>(config);
	}
	@Override
	public void sendMessage(String topicName, byte[] message) {
		if (topicName == null || message == null) {
			return;
		}
		KeyedMessage<byte[], byte[]> km = new KeyedMessage<byte[], byte[]>(topicName, "".getBytes(), message);
		inner.send(km);
	}
}


配置文件 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:util="http://www.springframework.org/schema/util" 
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/util
		http://www.springframework.org/schema/util/spring-util-4.0.xsd
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/task
		http://www.springframework.org/schema/task/spring-task-4.0.xsd">


	<bean id="producerConfig" class="org.springframework.beans.factory.config.PropertiesFactoryBean">  
        <property name="locations">  
            <list>  
                <value>config/properties/producer.properties</value>  
            </list>  
        </property>  
    </bean>
	<bean id="kafkaService" class="com.aiyou.gamecloud.kafka.KafkaServiceImpl" init-method="init"> 
		<property name="properties" ref="producerConfig"/>
	</bean>
</beans>


property 

metadata.broker.list=192.168.113.181:9092
producer.type=async  
compression.codec=0  
#serializer.class=kafka.serializer.StringEncoder 
#key.serializer.class=kafka.serializer.StringEncoder

编解码部分如果使用字符串需要设置，默认是字节数组
使用异（async）通信时，消息队列默认发送时间间隔由queue.buffering.max.ms决定（kafka.producer.async.AsyncProducerConfig中），默认时间间隔为5000ms，也就是说异步方式默认每5s发送一次消息

[b]Customer[/b] 


import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.messaging.Message;

import com.google.protobuf.InvalidProtocolBufferException;

import kafka.consumer.Consumer;

/**
 * @project: gate
 * @Title: KafkaCustomerService.java
 * @author: chenpeng
 * @email: 46731706@qq.com
 * @date: 2016年1月14日下午1:40:47
 * @description:
 * @version:
 */
public class KafkaCustomerService {
	private static final Logger logger = LoggerFactory.getLogger(KafkaCustomerService.class);
	private static final String CONFIG = "kafka-customer-config.xml";
	private static Random rand = new Random();

	public static void main(String[] args) {

		final ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(CONFIG, Consumer.class);
		ctx.start();

		final QueueChannel channel = ctx.getBean("inputFromKafka", QueueChannel.class);
		Message msg;
		while ((msg = channel.receive()) != null) {
			HashMap map = (HashMap) msg.getPayload();

			System.out.println("Here in  disb ================" + map.size());
			Set<Map.Entry> set = map.entrySet();

			for (Map.Entry entry : set) {
				String topic = (String) entry.getKey();
				System.out.println("Topic:" + topic);
				ConcurrentHashMap<Integer, List<byte[]>> messages = (ConcurrentHashMap<Integer, List<byte[]>>) entry
						.getValue();
				Collection<List<byte[]>> values = messages.values();

				for (Iterator<List<byte[]>> iterator = values.iterator(); iterator.hasNext();) {
					List<byte[]> list = iterator.next();
					System.out.println("================" + list.size());
					for (byte[] bytes : list) {
						try {
							BroadcastMessage message = BroadcastMessage.parseFrom(bytes);
							logger.debug(message.getGameId());
						} catch (InvalidProtocolBufferException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}

					}

				}

			}

		}

		try {
			Thread.sleep(100000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		ctx.close();
	}
}



配置文件 

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:int-kafka="http://www.springframework.org/schema/integration/kafka"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:int-stream="http://www.springframework.org/schema/integration/stream"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/integration
  http://www.springframework.org/schema/integration/spring-integration-4.1.xsd
  http://www.springframework.org/schema/integration/kafka
  http://www.springframework.org/schema/integration/kafka/spring-integration-kafka.xsd
  http://www.springframework.org/schema/integration/stream
  http://www.springframework.org/schema/integration/stream/spring-integration-stream.xsd">

	<int:channel id="inputFromKafka" ><int:queue/></int:channel>

	<int-kafka:inbound-channel-adapter
		id="kafkaInboundChannelAdapter" kafka-consumer-context-ref="consumerContext"
		auto-startup="false" channel="inputFromKafka">
		<int:poller fixed-delay="10" time-unit="MILLISECONDS"
			max-messages-per-poll="50" />
	</int-kafka:inbound-channel-adapter>


	<int-kafka:consumer-context id="consumerContext"
		consumer-timeout="10" zookeeper-connect="zookeeperConnect" >
		<int-kafka:consumer-configurations>
			<int-kafka:consumer-configuration
				group-id="default" max-messages="5000">
				<int-kafka:topic id="websocket_01" streams="1" />
			</int-kafka:consumer-configuration>
		</int-kafka:consumer-configurations>
	</int-kafka:consumer-context>
	<int-kafka:zookeeper-connect id="zookeeperConnect"
		zk-connect="192.168.113.181:2121" zk-connection-timeout="6000"
		zk-session-timeout="6000" zk-sync-time="200" />

</beans:beans>


这里需要注意两个参数：
fixed-delay：即从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。即每次sleep的时间间隔。
fixed-rate： 即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。即每次获取消息的时间间隔。
consumer-timeout：如果在指定的时间间隔后，没有发现可用的消息可消费，则抛出一个timeout异常，我的理解是处理完一个消息后等待fixed-delay+consumer-timeout时间间隔，如果还没消息就重连（不知道理解的对不对，不过实验证明将consumer-timeout值修改后会影响接收消息的频率）

结合spring，还可以使用Spring Integration方式进行配置 


<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:int-kafka="http://www.springframework.org/schema/integration/kafka"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:int-stream="http://www.springframework.org/schema/integration/stream"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/integration
  http://www.springframework.org/schema/integration/spring-integration-4.1.xsd
  http://www.springframework.org/schema/integration/kafka
  http://www.springframework.org/schema/integration/kafka/spring-integration-kafka.xsd
  http://www.springframework.org/schema/integration/stream
  http://www.springframework.org/schema/integration/stream/spring-integration-stream.xsd">

	<int:channel id="inputFromKafka"></int:channel>

	<int:service-activator auto-startup="true"
		input-channel="inputFromKafka" ref="disbService" method="distribute">
	</int:service-activator>


	<int:poller default="true" id="default" fixed-rate="5"
		time-unit="MILLISECONDS">
	</int:poller>

	<int-kafka:inbound-channel-adapter
		kafka-consumer-context-ref="consumerContext" channel="inputFromKafka">
	</int-kafka:inbound-channel-adapter>

	<int-kafka:consumer-context id="consumerContext"
		consumer-timeout="5" zookeeper-connect="zookeeperConnect">
		<int-kafka:consumer-configurations>
			<int-kafka:consumer-configuration
				group-id="default" max-messages="5000">
				<int-kafka:topic id="${gateId}" streams="1" />
			</int-kafka:consumer-configuration>
		</int-kafka:consumer-configurations>
	</int-kafka:consumer-context>
	<int-kafka:zookeeper-connect id="zookeeperConnect"
		zk-connect="192.168.113.181:2121" zk-connection-timeout="6000"
		zk-session-timeout="6000" zk-sync-time="2000" />

</beans:beans>


service实现 


import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.google.protobuf.InvalidProtocolBufferException;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;


@Service("disbService")
public class DisbService {
	private static final Logger logger = LoggerFactory.getLogger(DisbService.class);

	@Value("#{configProperties['server.requestType']}")
	private String requestType = ERequestType.SOCKET.getValue();
	@Autowired
	private CacheService cacheService;

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void distribute(HashMap map) {
		System.out.println("Here in  disb ================" + map.size());
		Set<Map.Entry> set = map.entrySet();

		for (Map.Entry entry : set) {
			String topic = (String) entry.getKey();
			logger.debug("Topic:" + topic);
			ConcurrentHashMap<Integer, List<byte[]>> messages = (ConcurrentHashMap<Integer, List<byte[]>>) entry
					.getValue();
			Collection<List<byte[]>> values = messages.values();

			for (Iterator<List<byte[]>> iterator = values.iterator(); iterator.hasNext();) {
				List<byte[]> list = iterator.next();
				System.out.println("================" + list.size());
				for (byte[] bytes : list) {
					// 这里获取到的是广播的信息
					try {
						if (ERequestType.HTTP.getValue().equals(requestType)) {
							// 缓存起来！！！
						} else {
							Message.BroadcastMessage message = Message.BroadcastMessage.parseFrom(bytes);
							if (message.getUserIdsList().isEmpty()) {
								List<ChannelCache> channelList = cacheService.getGameChannelList(topic,
										message.getGameId(), message.getServerId());
								for (ChannelCache channelCache : channelList) {
									sendMessage(channelCache, message);
								}
							}

							for (String userId : message.getUserIdsList()) {
								ChannelCache channelCache = cacheService.getCachedChannel(message.getGameId(),
										message.getServerId(), userId);
								sendMessage(channelCache, message);
							}
						}

					} catch (InvalidProtocolBufferException e) {
						e.printStackTrace();
					}

				}

			}

		}
	}

	private void sendMessage(ChannelCache channelCache, Message.BroadcastMessage message) {
		if (channelCache != null) {
			switch (ERequestType.parse(requestType)) {
			case HTTP:
				break;
			case SOCKET:
				try {
					if (channelCache.getChannel().isActive()) {
						ByteBuf messageData = Unpooled.buffer();
						messageData.writeInt(message.getMessage().toByteArray().length);
						messageData.writeBytes(message.getMessage().toByteArray());
						channelCache.getChannel().writeAndFlush(messageData).sync();
					} else {
						cacheService.userLogout(channelCache.getChannel().hashCode());
					}

				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				break;

			case WEBSOCKET:
				try {
					if (channelCache.getChannel().isActive()) {
						ByteBuf messageData = Unpooled.buffer();
						messageData.writeInt(message.getMessage().toByteArray().length);
						messageData.writeBytes(message.getMessage().toByteArray());
						channelCache.getChannel().writeAndFlush(new BinaryWebSocketFrame(messageData)).sync();
					} else {
						cacheService.userLogout(channelCache.getChannel().hashCode());
					}

				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			default:
				break;

			}
		}
	}

}

iteye_12335
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kafka与spring集成
LS的博客
09-01 149
Spring与kafka集成 注意: 首先启动zookeeper 然后启动kafka 本文档是以主题 test1为前提demo，需要先创建主题 bin/kafka-topics.sh --create --zookeeper 192.168.124.200:2181 --replication-factor 1 --partitions 1 --topic test1 一、maven(pom.xml引jar) <dependency>...
Kafka和Spring集成实践
Hijacker的专栏
07-26 1万+
目录 安装Zookeeper 安装Kafka 创建一个Spring项目 使用Producer API发送消息到Kafka 使用Kafka High Level API接收消息 使用spring-integration-kafka发送消息 使用spring-integration-kafka接收消息本文以单机的环境演示如何将Kafka和Spring集成。
Spring集成Kafka
ALiangXLogic的博客
06-12 4941
Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者在网站中的所有动作流数据。
Spring集成Apache Kafka教程
neweastsun的专栏
09-23 2394
前面介绍了发送、接收字符串消息，我们可以发送接收自定义java对象。这选哟配置相应序列化和反序列类。}@Bean// ...}@Bean}@Bean// ...props,}@Bean}}为了反序列化接收的消息，需要给消费者提供自定义MessageConverter.在后台，MessageConverter依赖于Jackson2JavaTypeMapper。我们还需要提供反向映射信息。
springboot 集成kafka 详细教程，看这一篇就够了
qq_41041630的博客
07-13 1529
springboot ,kafka
spring整合kafka
weixin_66381464的博客
11-14 1675
kafka是一个分布式的基于发布订阅模式的消息队列。
Spring整合Kafka
weixin_45809829的博客
05-29 2776
Spring整合Kafka 采用Kafaka技术进行系统消息的发送，提高系统的性能 1、阻塞队列的使用 Kafaka也好还是其他的消息中间件也好都是框架，如果不使用这些框架使用BlockingQueue也可以解决消息系统的开发 理解阻塞队列对理解Kafaka很有帮助 BlockingQueue 解决线程通信的问题 阻塞的方法有put、take 生产的数据放在队列当中，当队列满的时候生产者线程就被阻塞住(什么都不做，不会消耗资源)，等待消费者线程进行消费 消费线程从队列当中拿数据进
spring-kafka整合
qq_34810124的博客
10-19 1万+
springboot-kafka
Kafka与spring集成
12-10
Kafka与Spring集成指南 Kafka分布式消息系统是一种高吞吐量、可扩展、基于发布订阅模式的消息系统，广泛应用于大数据处理、实时数据处理和日志处理等领域。Spring Framework是一种流行的Java应用程序框架，提供了一...
SpringCloud与Kafka消息中间件集成教程
最新发布
07-13
### SpringCloud与Kafka消息中间件集成教程 #### 一、SpringCloud概述 Spring Cloud 是一个基于Spring Boot的框架，旨在提供一系列开箱即用的工具和服务，帮助开发者轻松构建和部署微服务架构的应用程序。它集合了...
spring boot与kafka集成的简单实例
08-29
Spring Boot 与 Kafka 集成的简单实例 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序，而 Kafka 是一个分布式流媒体平台，用于高吞吐量、可扩展的数据处理。今天，我们将介绍如何使用 ...
spring boot集成kafka
08-26
在这个项目中，Spring Boot通过其内置的自动配置能力与Kafka进行集成。以下是一些关键点： 1. **依赖管理**：在`pom.xml`中，我们需要添加Spring Boot对Kafka的依赖。这通常包括`spring-boot-starter-data-jpa`和`...
Spring 集成 Kafka的配置文件及代码讲解
04-12
在本文中，我们将深入探讨如何将Spring框架与Apache Kafka集成，以便实现...压缩包中的"Kafka与spring集成的代码"文件应该包含了这些示例的完整实现，供你参考和学习。记得根据实际的Kafka集群配置和业务需求调整代码。
SpringBoot——集成Kafka详解
热门推荐
吴声子夜歌的博客
08-21 2万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；若发送消息时未指定 patition，但指定了 key（kafka允许为每条消息设置一个key），则对key值进行hash计算，根据计算结果路由到指定分区，这种情况下可以保证同一个 Key 的所有消息都进入到相同的分区；
Spring整合kafka
程序三两行
04-17 1917
ssm项目使用kafka 只用spring-kafka依赖就行注入KafkaTemplate模板消息发送监听消息消费测试发送。
SpringBoot项目集成kafka及常规配置
codeLife1993的博客
06-17 1万+
使用 spring-kafka 的api，在springboot项目中集成kafka能力，封装配置。
Apache Kafka Spring 集成
u013433591的博客
01-02 716
Apache Kafka Spring 集成、@KafkaListener 消息监听、消息过滤
从零开始搭建Kafka+SpringBoot分布式消息系统
Java架构师联盟
12-03 1039
前言 由于kafka强依赖于zookeeper，所以需先搭建好zookeeper集群。由于zookeeper是由java编写的，需运行在jvm上，所以首先应具备java环境。 （ps：默认您的centos系统可联网，本教程就不教配置ip什么的了） （ps2：没有wget的先装一下：yum install wget） （ps3：人啊，就是要条理。东边放一点，西边放一点，过段时间就不知道自己装在哪里了。本教程所有下载均放在/usr/local目录下） （ps4：kafka可能有内置zookeeper，感觉可以越
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值