kafka收发消息demo

最新推荐文章于 2024-09-15 10:22:12 发布
最新推荐文章于 2024-09-15 10:22:12 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： kafka</div>
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsdtq123/article/details/78263217
版权
使用原生态方式发送、接受消息

pom.xml 
<dependency>
		<groupId>org.apache.kafka</groupId>
		<artifactId>kafka-clients</artifactId>
		<version>0.10.1.1</version>
	</dependency>


发消息 
@Test
	public void TestProducer(){
		Properties props = new Properties();
		props.put("bootstrap.servers", "192.168.1.245:9393,192.168.1.246:9393");
        //“所有”设置将导致记录的完整提交阻塞，最慢的，但最持久的设置。
        props.put("acks", "all");
        //如果请求失败，生产者也会自动重试，即使设置成０ the producer can automatically retry.
        props.put("retries", 0);
        //The producer maintains buffers of unsent records for each partition. 
        props.put("batch.size", 16384);
        //默认立即发送，这里这是延时毫秒数
        props.put("linger.ms", 1);
        //生产者缓冲大小，当缓冲区耗尽后，额外的发送调用将被阻塞。时间超过max.block.ms将抛出TimeoutException
        props.put("buffer.memory", 33554432);
        //The key.serializer and value.serializer instruct how to turn the key and value objects the user provides with their ProducerRecord into bytes.
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        
        //创建kafka的生产者类
        // close();//Close this producer.
        // close(long timeout, TimeUnit timeUnit); //This method waits up to timeout for the producer to complete the sending of all incomplete requests.
        // flush() ;所有缓存记录被立刻发送
        Producer<String, String> producer = new KafkaProducer<String, String>(props);
        for(int i = 0; i < 10; i++){
        	
        	producer.send(new ProducerRecord<String, String>("d-topic", Integer.toString(i), Integer.toString(i)));
        }
        producer.flush();
        producer.close();
	}


收消息 
@Test
	public void TestConsumer() throws InterruptedException{
		Properties props = new Properties();
		props.put("bootstrap.servers", "192.168.1.245:9393,192.168.1.246:9393");
		props.put("group.id", "GroupA");
		props.put("enable.auto.commit", "true");
		props.put("auto.commit.interval.ms", "1000");
		//从poll(拉)的回话处理时长
        props.put("session.timeout.ms", "30000");
        //poll的数量限制
        //props.put("max.poll.records", "100");
        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<String, String>(props);
        //订阅主题列表topic
        //consumer.subscribe(Arrays.asList("d-topic", "bar"));
        consumer.subscribe(Arrays.asList("d-topic"));
        while (true) {
        	ConsumerRecords<String, String> records = consumer.poll(100);
        	for (ConsumerRecord<String, String> record : records){
        		System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        	}
        	Thread.sleep(1000);
        }
	}


与spring集成
pom.xml 
<dependency>
	    <groupId>org.springframework.integration</groupId>
	    <artifactId>spring-integration-kafka</artifactId>
	    <version>2.1.0.RELEASE</version>
	</dependency>


producer.xml 
<?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:int="http://www.springframework.org/schema/integration"  
       xmlns:int-kafka="http://www.springframework.org/schema/integration/kafka"  
       xsi:schemaLocation="http://www.springframework.org/schema/integration/kafka  
        http://www.springframework.org/schema/integration/kafka/spring-integration-kafka.xsd  
        http://www.springframework.org/schema/integration  
        http://www.springframework.org/schema/integration/spring-integration.xsd  
        http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  
    <!-- 生产者配置 -->  
    <bean id="template" class="org.springframework.kafka.core.KafkaTemplate">  
        <constructor-arg index="0">  
            <bean class="org.springframework.kafka.core.DefaultKafkaProducerFactory">  
                <constructor-arg>  
                    <map>  
                        <entry key="bootstrap.servers" value="192.168.1.245:9393,192.168.1.246:9393"/>  
                        <entry key="acks" value="all"/>  
                        <entry key="retries" value="3"/>  
                        <entry key="batch.size" value="16384"/>  
                        <entry key="linger.ms" value="1"/>  
                        <entry key="buffer.memory" value="33554432"/>
                        <entry key="key.serializer" value="org.apache.kafka.common.serialization.StringSerializer"></entry>  
                        <entry key="value.serializer" value="org.apache.kafka.common.serialization.StringSerializer"></entry>  
                    </map>  
                </constructor-arg>  
            </bean>  
        </constructor-arg>  
    </bean>  
  
    <!-- 生产1号 -->  
    <int:channel id="inputToKafka">
        <int:queue/>  
    </int:channel>  
    <int-kafka:outbound-channel-adapter id="kafkaOutboundChannelAdapter"  
                                        kafka-template="template"  
                                        auto-startup="true"  
                                        channel="inputToKafka"  
                                        topic="d-topic">  
        <int:poller fixed-delay="1000" time-unit="MILLISECONDS"/>  
    </int-kafka:outbound-channel-adapter>
  
</beans>


cunsumer.xml 
<?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:int="http://www.springframework.org/schema/integration"  
       xmlns:int-kafka="http://www.springframework.org/schema/integration/kafka"  
       xsi:schemaLocation="http://www.springframework.org/schema/integration/kafka  
        http://www.springframework.org/schema/integration/kafka/spring-integration-kafka.xsd  
        http://www.springframework.org/schema/integration  
        http://www.springframework.org/schema/integration/spring-integration.xsd  
        http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
    <!-- 消费配置 -->  
    <bean id="consumerProperties" class="java.util.HashMap">  
        <constructor-arg>  
            <map>  
                <entry key="bootstrap.servers" value="192.168.1.245:9393,192.168.1.246:9393"/>  
                <entry key="group.id" value="GroupA"/>  
                <entry key="enable.auto.commit" value="true"/>  
                <entry key="auto.commit.interval.ms" value="1000"/>  
                <entry key="session.timeout.ms" value="15000"/>  
                <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>
    
    <!-- 创建consumerFactory bean -->  
    <bean id="consumerFactory" class="org.springframework.kafka.core.DefaultKafkaConsumerFactory">  
        <constructor-arg>  
            <ref bean="consumerProperties"/>  
        </constructor-arg>  
    </bean>
    
    <!-- 消费1号 -->  
    <int:channel id="inputFromKafka">  
        <int:queue/>  
    </int:channel>
    
    <int-kafka:message-driven-channel-adapter auto-startup="true" channel="inputFromKafka" listener-container="container1" />  
  
    <bean id="container1" class="org.springframework.kafka.listener.KafkaMessageListenerContainer">  
        <constructor-arg index="0" ref="consumerFactory"/>  
        <constructor-arg index="1" ref="containerProperties"/>  
    </bean>  
  
    <bean id="containerProperties" class="org.springframework.kafka.listener.config.ContainerProperties">  
        <constructor-arg value="d-topic"/>  
    </bean>
   
</beans>


发送、接口消息代码 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class TestKafka {
	
	@Autowired  
    @Qualifier("inputToKafka")  
    MessageChannel messageChannel;
	
	@Autowired  
    @Qualifier("inputFromKafka")  
    PollableChannel pollableChannel;
	
		@Test
	public void TestSpringProducer(){
		for (int i = 0; i < 15; i++) {
			Message<String> message = new GenericMessage<String>("test_" + i);
			boolean flag = messageChannel.send(message);
			System.out.println(flag + "_" + i);
		}
	}
	
	@Test
	public void TestSpringConsumer(){
		Message<?> received = pollableChannel.receive(1000);  
        while (received != null) {
            System.out.println("message########" + received);  
            received = pollableChannel.receive(1000);  
        }
	}
}
daidaoqr
关注
专栏目录
kafka的搭建与收发消息
06-09 630
kafka是中间件类产品，消息队列 https://blog.csdn.net/wobuaizhi/article/details/80950337
Kafka参数配置原理及demo整理
qq_45505510的博客
01-06 1703
kafka案例及参数原理详解 消息回调确认等
kafka 发送和接收消息
03-01
消息中间件kafka 进行消息的分发和接收示例 应用中包含分通道发送和多线程接收
中间件知识点-消息中间件（Kafka）二
最新发布
willard_z的博客
09-15 2548
消息中间件知识点
kafka 收发消息
lanse_huanxiang的专栏
03-11 527
kafka
Kafka发送消息与接收消息简单demo
清茶的博客
09-11 9925
一、先上pom依赖 <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>0.10.2.0&lt...
Kafka：springboot集成kafka收发消息
A20001230T的博客
08-09 1530
4、component中实现接收类HelloListener。思路：在传递消息时，将对象转为json字符串，在接收时再解析。1、springboot中引入kafka依赖。3、controller实现消息发送接口。2、配置application.yml。1、controller实现发送。2、component实现接收类。浏览器访问该接口并查看控制台。kafka环境搭建参考。
main方法编写kafka收发消息
04-01
public class KafkaDemo { public static void main(String[] args) throws Exception { String topicName = "my-topic"; String groupName = "my-group"; String message = "Hello, Kafka!"; int partition =...
Kafka之初识Kafka
d303577562的博客
08-12 396
1.简介 Kafka起初是由LinkedIn公司采用Scala语言开发的一个多分区、多副本且基于ZooKeeper协调的分布式消息系统，现已被捐献给Apache基金会。目前Kafka已经定位为一个分布式流式处理平台，它以高吞吐、可持久化、可水平扩展、支持流数据处理等多种特性而被广泛使用。目前越来越多的开源分布式处理系统如Cloudera、Storm、Spark、Flink等都支持与Kafka集成。 Kafka之所以受到越来越多的青睐，与它“扮演”的三大角色是分不开的。 消息系统：Kafka和传统的消息系统
kafka学习笔记三：负载均衡
为了忘却的纪念
11-08 9444
Kafka具有消费分组的概念，一个Topic的一个partition只能由一个Consumer group中的一个Consmer消费，概念似乎很容易理解，那么我们来做个测试看 1、创建一个Topic 使用一个已经创建好的Topic， [root@node1 bin]# ./kafka-topics.sh --describe --zookeeper localhost:2181 --to
17、Kafka ------ SpringBoot 整合 Kafka 发送 和 接收消息（使用 KafkaTemplate 发送消息 和 使用 @KafkaListener 修饰监听器来接收消息）
Java 领域技术分享
01-29 4145
SpringBoot 整合 Kafka 发送 和 接收消息（使用 KafkaTemplate 发送消息 和 使用 @KafkaListener 修饰监听器来接收消息）
kafka java 实现消息队列demo
热门推荐
云守护的专栏
12-30 1万+
kafka是吞吐量巨大的一个消息系统，它是用scala写的，和普通的消息的生产消费还有所不同，写了个demo程序供大家参考。kafka的安装请参考官方文档。 首先我们需要新建一个maven项目，然后在pom中引用kafka jar包，引用依赖如下： org.apache.kafka kafka_2.10 0.8.0
kafka 往cdh 6的kafka写数据成功
weixin_34198881的博客
02-11 599
2019独角兽企业重金招聘Python工程师标准>>> ...
Java操作Kafka收发消息demo
学无止境
11-09 2787
通过Java程序来进行Kafka收发消息的演示 Kafka自身提供的Java客户端来演示消息的收发，与Kafka的Java客户端相关的Maven依赖如下： <properties> <scala.version>2.11</scala.version> <slf4j.version>1.7.21</slf4j.version> <kafka.version>2.0.0</kafka.
Kafka-Java一：Spring实现kafka消息的简单发送_kafka发送对象消息(1)
2401_84689803的博客
05-12 404
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
Kafka 生产者：发送消息代码解析（五）
AcWare 学习笔记
11-16 512
代码使用的是 0.10.1.0 版本的 Kafka examples Producer 代码 代码在源码包的 kafka.examples.Producer 中 Kafka Producer 代码 public class Producer extends Thread { // 发送的数据是 K V 结构，对应上类型 private final KafkaProducer<Integer, String> producer; private final String
Kafka简单测试demo
人是有思想的芦苇
09-30 3015
对搭建好的kafka集群【kafka_2.10-0.8.2.1】做简单的demo测试
kafka 简易发送/接收框架 之1
guishuanglin的专栏
09-18 370
此框架代码为单线程收发, 适用于用kafka转送消息的业务, 如果要发送大量数据, 并且发送端有大量并发请求, 应当修改发送代码. 代码可以免费应用于商业代码, 但请保留创作者信息. 本框架包含如下内容: 下面就把各类完整代码发上来 AbstractConfig类: package org.test; import java.util.ArrayList; import...
kafka 异步消息 demo
05-31
以下是使用Java编写Kafka异步消息的示例代码，供您参考： ```java import org.apache.kafka.clients.producer.Callback; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值