kafka从部署到Java springboot整合

最新推荐文章于 2024-06-02 19:29:15 发布
最新推荐文章于 2024-06-02 19:29:15 发布
阅读量506 收藏 4
点赞数
分类专栏： java springboot kafka 文章标签： java Spring boot kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuxuxu1222/article/details/107207603
版权
java 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
springboot
2 篇文章 0 订阅
订阅专栏
kafka
1 篇文章 0 订阅
订阅专栏
一、部署zookeeper服务（单机）

温馨提示：部署zookeeper前请务必自己搭建并配置好java环境

服务器环境：centos7
zookeeper版本：zookeeper-3.4.6
zookeeper安装包：zookeeper-3.4.6.tar.gz

1、zookeeper下载
cd /home/root
wget https://archive.apache.org/dist/zookeeper/zookeeper-3.4.6/zookeeper-3.4.6.tar.gz
2、解压、配置和启动zookeeper服务
# 解压
cd /home/root
tar -xf zookeeper-3.4.6.tar.gz
mv zookeeper-3.4.6 zookeeper
# 进入conf目录修改zookeeper配置参数
cd /home/root/zookeeper/conf
# 修改zoo_sample.cfg名为zoo.cfg
# 因为zookeeper启动脚本zkServer.sh启动时会执行zkEnv.sh脚本，zkEnv.sh中会去找conf目录下的zoo.cfg文件作为配置文件加载
mv zoo_sample.cfg zoo.cfg
# 修改dataDir值为/home/root/zookeeper/zookeeper/data
# 添加dataLogDir=/home/root/zookeeper/zookeeper/logs
vim zoo.cfg
# 配置zookeeper环境变量
vim /etc/profile
# 添加配置
export ZK_HOME=/home/root/zookeeper/zookeeper
export PATH=.:$ZK_HOME/bin:$PATH
# 环境变量生效
source /etc/profile
# 启动zookeeper服务
zkServer.sh start
# 查看zk状态
zkServer.sh status
3、查看zookeeper服务状态

在这里插入图片描述

二、部署kafka服务（单机）

kafka版本：kafka_2.12-2.3.1
kafka安装包：kafka_2.12-2.3.1.tgz

1、kafka下载
cd /home/root
wget https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/2.3.1/kafka_2.12-2.3.1.tgz
2、解压、配置和启动kafka服务
cd /home/root/kafka/config
# 修改server.properties
# 修改advertised.listeners值为服务器ip,否则java项目启动会报错
log.dirs=/home/root/kafka/logs
advertised.listeners=PLAINTEXT://服务器ip:9092
# 启动kafka后台运行
cd /home/root/kafka
nohup ./bin/kafka-server-start.sh config/server.properties &
3、创建kafka topic

创建topic，为我们下面java项目服务

# 创建一个topic为hello
# replication-factor : 副本数
# partitions : 分区数
# topic ：主题名称
cd /home/root/kafka
./bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic hello

至此，kafka服务部署完成，接下来我们开始在java中使用kafka

三、搭建springboot项目
1、maven依赖导入
<!-- https://mvnrepository.com/artifact/org.springframework.kafka/spring-kafka -->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.5.2.RELEASE</version>
</dependency>
2、配置
server.port=8989
###########【Kafka集群】###########
spring.kafka.bootstrap-servers=192.168.10.8:9092

###########【初始化生产者配置】###########
# 重试次数
spring.kafka.producer.retries=0
# 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
spring.kafka.producer.acks=1
# 批量大小
spring.kafka.producer.batch-size=16384
# 提交延时
spring.kafka.producer.properties.linger.ms=0
# 当生产端积累的消息达到batch-size或接收到消息linger.ms后,生产者就会将消息提交给kafka
# linger.ms为0表示每接收到一条消息就提交给kafka,这时候batch-size其实就没用了

# 生产端缓冲区大小
spring.kafka.producer.buffer-memory=33554432
# Kafka提供的序列化和反序列化类
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
​
###########【初始化消费者配置】###########
# 默认的消费组ID
spring.kafka.consumer.properties.group.id=defaultConsumerGroup
# 是否自动提交offset
spring.kafka.consumer.enable-auto-commit=true
# 提交offset延时(接收到消息后多久提交offset)
spring.kafka.consumer.auto.commit.interval.ms=0
# 当kafka中没有初始offset或offset超出范围时将自动重置offset
# earliest:重置为分区中最小的offset;
# latest:重置为分区中最新的offset(消费分区中新产生的数据);
# none:只要有一个分区不存在已提交的offset,就抛出异常;
spring.kafka.consumer.auto-offset-reset=latest
# 消费会话超时时间(超过这个时间consumer没有发送心跳,就会触发rebalance操作)
spring.kafka.consumer.properties.session.timeout.ms=120000
# 消费请求超时时间
spring.kafka.consumer.properties.request.timeout.ms=180000
# Kafka提供的序列化和反序列化类
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# 消费端监听的topic不存在时，关掉项目启动报错
spring.kafka.listener.missing-topics-fatal=false

准备工作完成。
接下来我们采用Controller模拟传入消息触发kafka生产者生产消息，用@KafkaListener注解开启kafka消费者消费（监听消息）

以下消息输出采用日志打印，请在项目中加入maven依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
3、创建KafkaController模拟消息创建者
package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @Description : 模拟消息进入，创建kafka消息（生产者）
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:39 下午
 */
@Slf4j 
@RestController
public class KafkaController {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

	// 异步发送消息（无回调）
    @PostMapping("/sendMsg")
    public void sendMessage1(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello"; // kafka主题
        kafkaTemplate.send(topic, "你好");
    }
}
4、创建kafkaConsumer监听kafka消息
package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

/**
 * @Description : kafka消费者
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:40 下午
 */
@Slf4j 
@Component
public class KafkaConsumer {

    // 消费监听,topics写入我们创建的topic
    @KafkaListener(topics = {"hello"})
    public void listen1(ConsumerRecord<String,String> record) {
        String msg = record.value();             // 消息内容
        Integer partition = record.partition();  // 分区
        Long timestamp = record.timestamp();     // 时间戳
        Long offset = record.offset();			 // offset（偏移）
        log.info("kafka consumer message:{}; partition:{}; offset:{}; timestamp:{}", msg, partition, offset, timestamp);
    }
}
5、启动项目测试

①、使用curl发起请求：

curl -XPOST http://localhost:8989/sendMsg -d 'msg=你好'

②、使用postman发起请求：
在这里插入图片描述
监听到的结果：

2020-07-08 18:31:42.411  INFO 6085 --- [ntainer#0-0-C-1] com.example.kafkademo.KafkaConsumer      : kafka consumer message:你好; partition:0; offset:385; timestamp:1594204302340
四、kafkaTemplate异步回调

默认情况下 KafkaTemplate 发送消息是采取异步方式，上面演示的也是异步发送消息的一种。
接下来我们演示异步回调发送消息。异步回调的好处：可以在发送消息后得知消息是否发送成功，便于方便根据成功与否及时补偿。

package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @Description : 模拟消息进入，创建kafka消息（生产者）
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:39 下午
 */
@Slf4j 
@RestController
public class KafkaController {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

	// 异步发送消息（回调）
    @PostMapping("/sendMsg2")
    public void sendMessage2(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        kafkaTemplate.send(topic, normalMessage).addCallback(success -> {
            String topicStr = success.getRecordMetadata().topic();
            int partition = success.getRecordMetadata().partition();
            long offset = success.getRecordMetadata().offset();
            log.info("send msg success!; topic = {}, partition = {}, offset = {}", topicStr, partition, offset);
        }, failed -> {
            log.error("send msg failed! errMsg : {}", failed.getMessage());
        });
    }

    /*
    // 异步发送消息（无回调）
    @PostMapping("/sendMsg")
    public void sendMessage1(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello"; // kafka主题
        kafkaTemplate.send(topic, "你好");
    }
    */
}
五、kafkaTemplate同步发消息（无时间限制）

在kafkaTemplate.send()方法之后发送消息之后调用get()方法即同步发送消息。
get 方法返回的即为结果，如果发送失败则抛出异常。

package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @Description : 模拟消息进入，创建kafka消息（生产者）
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:39 下午
 */
@Slf4j 
@RestController
public class KafkaController {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

	// 同步发送消息
    @PostMapping("/sendMsg3")
    public void sendMessage3(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        try {
            SendResult<String, Object> result = kafkaTemplate.send(topic, normalMessage).get();
            String topic1 = result.getRecordMetadata().topic();     // 消息发送到的topic
            int partition = result.getRecordMetadata().partition(); // 消息发送到的分区
            long offset = result.getRecordMetadata().offset();      // 消息在分区内的offset
            log.info("send msg done. topic = {}, partition = {}, offset = {}", topic1, partition, offset);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

	/*
	// 异步发送消息（回调）
    @PostMapping("/sendMsg2")
    public void sendMessage2(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        kafkaTemplate.send(topic, normalMessage).addCallback(success -> {
            String topicStr = success.getRecordMetadata().topic();
            int partition = success.getRecordMetadata().partition();
            long offset = success.getRecordMetadata().offset();
            log.info("send msg success!; topic = {}, partition = {}, offset = {}", topicStr, partition, offset);
        }, failed -> {
            log.error("send msg failed! errMsg : {}", failed.getMessage());
        });
    }
    */

    /*
    // 异步发送消息（无回调）
    @PostMapping("/sendMsg")
    public void sendMessage1(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello"; // kafka主题
        kafkaTemplate.send(topic, "你好");
    }
    */
}
六、kafkaTemplate发送同步消息（时间限制）

调用get()方法的重载方法get(long timeout, TimeUnit unit)进行发送消息时间限制。
需要注意，这里时间限制是对整个结果的耗时（time）限制的：
发送消息 -> 消费者消费完成 -> 返回消费结果。
计时是从生产者产生消息开始计算。
如果设置的timeout小于time，则会捕获到消息发送失败异常，但是消费者依然对该消息进行了消费。可以理解为：生产者不管消费者有没有成功进行消费，只要时间到还没有收到响应，就立即抛出超时异常。

我们设置时间限制（timeout）为1毫秒（故意演示失败效果），get(1, TimeUnit.MILLISECONDS)

package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @Description : 模拟消息进入，创建kafka消息（生产者）
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:39 下午
 */
@Slf4j 
@RestController
public class KafkaController {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;
	
	// 同步发送消息（超时限制设置）
    // 调用get()的重载方法get(long timeout, TimeUnit unit)
    @PostMapping("/sendMsg4")
    public void sendMessage4(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        try {
            SendResult<String, Object> result = kafkaTemplate.send(topic, normalMessage).get(1, TimeUnit.MILLISECONDS);
            String topic1 = result.getRecordMetadata().topic();     // 消息发送到的topic
            int partition = result.getRecordMetadata().partition(); // 消息发送到的分区
            long offset = result.getRecordMetadata().offset();      // 消息在分区内的offset
            log.info("send msg done. topic = {}, partition = {}, offset = {}", topic1, partition, offset);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }

	/*
	// 同步发送消息
    @PostMapping("/sendMsg3")
    public void sendMessage3(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        try {
            SendResult<String, Object> result = kafkaTemplate.send(topic, normalMessage).get();
            String topic1 = result.getRecordMetadata().topic();     // 消息发送到的topic
            int partition = result.getRecordMetadata().partition(); // 消息发送到的分区
            long offset = result.getRecordMetadata().offset();      // 消息在分区内的offset
            log.info("send msg done. topic = {}, partition = {}, offset = {}", topic1, partition, offset);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    */

	/*
	// 异步发送消息（回调）
    @PostMapping("/sendMsg2")
    public void sendMessage2(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        kafkaTemplate.send(topic, normalMessage).addCallback(success -> {
            String topicStr = success.getRecordMetadata().topic();
            int partition = success.getRecordMetadata().partition();
            long offset = success.getRecordMetadata().offset();
            log.info("send msg success!; topic = {}, partition = {}, offset = {}", topicStr, partition, offset);
        }, failed -> {
            log.error("send msg failed! errMsg : {}", failed.getMessage());
        });
    }
    */

    /*
    // 异步发送消息（无回调）
    @PostMapping("/sendMsg")
    public void sendMessage1(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello"; // kafka主题
        kafkaTemplate.send(topic, "你好");
    }
    */

开始测试，发送post请求：

curl -XPOST http://localhost:8989/sendMsg4 -d 'msg=测试同步发送消息的时间限制1ms'

显示结果为:
程序抛出了java.util.concurrent.TimeoutException异常，但是消费者consumer正常消费了消息

java.util.concurrent.TimeoutException
	at java.util.concurrent.FutureTask.get(FutureTask.java:205)
	at org.springframework.util.concurrent.SettableListenableFuture.get(SettableListenableFuture.java:134)
	at com.example.kafkademo.KafkaController.sendMessage4(KafkaController.java:79)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:190)
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:138)
	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:105)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:879)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:793)
	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87)
	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1040)
	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943)
	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006)
	at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:909)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:660)
	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:741)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
	at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
	at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96)
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343)
	at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:373)
	at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65)
	at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:868)
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1590)
	at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
	at java.lang.Thread.run(Thread.java:748)

2020-07-09 11:09:12.963  INFO 8665 --- [ntainer#0-0-C-1] com.example.kafkademo.KafkaConsumer      : kafka consumer message:测试同步发送消息的时间限制1ms; partition:0; offset:387; timestamp:1594264152891
七、开启kafka事务

Kafka和数据库一样可以支持事务，在程序发生异常或者出现特定逻辑的时候可以进行回滚，确保消息监听器不会接收到一些错误的或者不需要的消息。
开启kafka事务有两种方法，一种是在方法上使用@Transactional注解，另一种是使用本地事务kafkaTemplate.executeInTransaction

1、调用executeInTransaction方法开启事务

开启kafka事务需要添加修改配置文件:
1、重试次数的值设置大于0
2、把应答级别设置为all
3、增加kafka事务配置

# 重试次数
spring.kafka.producer.retries=1
# 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
spring.kafka.producer.acks=all
# 开启kafka事务
spring.kafka.producer.transaction-id-prefix=kafka-transacation

编写事务测试Controller

package com.example.kafkademo;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @Description : 模拟消息进入，创建kafka消息（生产者）
 * @Author : xu_teng_chao@163.com
 * @CreateTime : 2020/7/7 12:39 下午
 */
@Slf4j 
@RestController
public class KafkaController {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

	// 事务发送消息
    @PostMapping("/trans")
    public void sendMessageByTrans(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        kafkaTemplate.executeInTransaction(operations -> {
            operations.send(topic, normalMessage);
            throw new RuntimeException("模拟异常");
        });
    }	

	/*
	// 同步发送消息（超时限制设置）
    // 调用get()的重载方法get(long timeout, TimeUnit unit)
    @PostMapping("/sendMsg4")
    public void sendMessage4(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        try {
            SendResult<String, Object> result = kafkaTemplate.send(topic, normalMessage).get(1, TimeUnit.MILLISECONDS);
            String topic1 = result.getRecordMetadata().topic();     // 消息发送到的topic
            int partition = result.getRecordMetadata().partition(); // 消息发送到的分区
            long offset = result.getRecordMetadata().offset();      // 消息在分区内的offset
            log.info("send msg done. topic = {}, partition = {}, offset = {}", topic1, partition, offset);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
    */

	/*
	// 同步发送消息
    @PostMapping("/sendMsg3")
    public void sendMessage3(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        try {
            SendResult<String, Object> result = kafkaTemplate.send(topic, normalMessage).get();
            String topic1 = result.getRecordMetadata().topic();     // 消息发送到的topic
            int partition = result.getRecordMetadata().partition(); // 消息发送到的分区
            long offset = result.getRecordMetadata().offset();      // 消息在分区内的offset
            log.info("send msg done. topic = {}, partition = {}, offset = {}", topic1, partition, offset);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    */

	/*
	// 异步发送消息（回调）
    @PostMapping("/sendMsg2")
    public void sendMessage2(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello";
        kafkaTemplate.send(topic, normalMessage).addCallback(success -> {
            String topicStr = success.getRecordMetadata().topic();
            int partition = success.getRecordMetadata().partition();
            long offset = success.getRecordMetadata().offset();
            log.info("send msg success!; topic = {}, partition = {}, offset = {}", topicStr, partition, offset);
        }, failed -> {
            log.error("send msg failed! errMsg : {}", failed.getMessage());
        });
    }
    */

    /*
    // 异步发送消息（无回调）
    @PostMapping("/sendMsg")
    public void sendMessage1(@RequestParam(value = "msg") String normalMessage) {
        String topic = "hello"; // kafka主题
        kafkaTemplate.send(topic, "你好");
    }
    */

发送请求：

curl -XPOST http://localhost:8989/trans -d 'msg=测试事务'

测试结果为：

2020-07-09 11:56:53.249 ERROR 9149 --- [a-transacation0] o.s.k.support.LoggingProducerListener    : Exception thrown when sending a message with key='null' and payload='测试事务' to topic hello:

org.apache.kafka.common.KafkaException: Failing batch since transaction was aborted
	at org.apache.kafka.clients.producer.internals.Sender.maybeSendAndPollTransactionalRequest(Sender.java:422) [kafka-clients-2.5.0.jar:na]
	at org.apache.kafka.clients.producer.internals.Sender.runOnce(Sender.java:312) [kafka-clients-2.5.0.jar:na]
	at org.apache.kafka.clients.producer.internals.Sender.run(Sender.java:239) [kafka-clients-2.5.0.jar:na]
	at java.lang.Thread.run(Thread.java:748) ~[na:1.8.0_221]

2020-07-09 11:56:53.294 ERROR 9149 --- [nio-8989-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: 模拟异常] with root cause

java.lang.RuntimeException: 模拟异常
	at com.example.kafkademo.KafkaController.lambda$sendMessageByTrans$2(KafkaController.java:101) ~[classes/:na]
	at org.springframework.kafka.core.KafkaTemplate.executeInTransaction(KafkaTemplate.java:463) ~[spring-kafka-2.5.2.RELEASE.jar:2.5.2.RELEASE]
	at com.example.kafkademo.KafkaController.sendMessageByTrans(KafkaController.java:99) ~[classes/:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_221]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_221]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_221]
	at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_221]
	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:190) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:138) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:105) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:879) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:793) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1040) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:909) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:660) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:741) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53) ~[tomcat-embed-websocket-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202) ~[tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:373) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:868) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1590) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [na:1.8.0_221]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_221]
	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) [tomcat-embed-core-9.0.36.jar:9.0.36]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_221]

可以看到已经触发了事务回滚，该消息消费者也没有进行消费。

转战英雄枫
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在java代码中使用kafka(springboot整合kafka)
jerry764的博客
09-06 8403
java代码maven项目实现kafka的连接及生产者、消费者的创建，以及消息的发布和订阅
SpringBoot集成kafka全面实战
热门推荐
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
消息队列Kafka（一）介绍及安装以及基本原理
m0_45101736的博客
09-19 342
！！！
Springboot整合kafka简单使用
最新发布
m0_56353506的博客
06-02 1366
Kafka 是一个开源的分布式流处理平台，最初由 LinkedIn 开发并贡献给 Apache 软件基金会。它设计用于构建高性能、持久性、可伸缩和容错的实时数据管道和流处理应用程序。发布-订阅模型：Kafka 使用发布-订阅模型，其中消息生产者将消息发布到主题（topic），而消息消费者从主题订阅消息。这种模型可以支持多个消费者同时消费消息，并且具有良好的扩展性。主题（Topic）：主题是消息的逻辑分类，相当于一个消息队列。消息被发布到主题，并且消费者从主题订阅消息。分区（Partition）
Springboot 配置使用 Kafka
泡泡的博客
11-01 1万+
不多BB讲原理，只教你怎么用，看了全网没有比我更详细的了，yml 配置，Config 工厂代码配置都有，batch-size、acks、offset、auto-commit、trusted-packages、poll-timeout、linger 应有尽有，批量消费、开启事务、定义批量消费数量、延时发送、失败重试、异常处理你还想要什么As we all know，当今世界最流行的消息中间件有 RabbitMq、RocketMq、Kafka，其中，应用最广泛的是RabbitMq，RocketMq。
SpringBoot——集成Kafka详解
吴声子夜歌的博客
08-21 2万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；若发送消息时未指定 patition，但指定了 key（kafka允许为每条消息设置一个key），则对key值进行hash计算，根据计算结果路由到指定分区，这种情况下可以保证同一个 Key 的所有消息都进入到相同的分区；
springboot集成kafka进行消息发布和订阅jar
05-22
**SpringBoot集成Kafka进行消息发布与订阅** 在现代微服务架构中，消息队列（Message Queue）扮演着至关重要的角色，它能够有效地解耦系统组件，提高系统的响应速度和可扩展性。Apache Kafka作为一款高吞吐量、低...
springboot整合dubbo
11-26
通过Spring Boot的便利性和Dubbo的服务治理能力，我们可以快速地开发、部署和管理服务，提升系统的可扩展性和稳定性。在实际操作中，理解并掌握这两个框架的特性以及整合方法，对于提升开发效率和维护性具有重要意义...
springboot-kafka-simple-demo
04-19
SpringBoot与Kafka整合简单示例 在Java开发领域，SpringBoot因其简化配置和快速启动的优势，已经成为构建微服务的首选框架。而Apache Kafka作为分布式流处理平台，被广泛用于实时数据传输和处理。本示例"springboot...
Java Springboot入门自学笔记
09-08
Java Spring Boot 是一款由 Pivotal Team 创建的框架，它旨在简化Java应用程序的初始搭建以及开发过程。Spring Boot 基于 Spring Framework，但通过预设的默认配置，减少了大量繁琐的配置工作，使得开发者可以更快地...
debj_SpringBoot_ELK+Kafka_resources.zip
06-24
《SpringBoot整合ELK+Kafka的资源集合详解》 在现代微服务架构中，日志管理和实时数据流处理是至关重要的。SpringBoot作为一个轻量级的Java开发框架，广泛应用于构建可快速启动的独立应用。而ELK（Elasticsearch、...
springBoot整合kafka和elasticSearch,实现批量拉取日志以及批量更新到es里
01-15
从Kafka中批量拉去数据，然后批量更新到es里。一次拉取的数量可以设置，现在是10000，轻松运转，更新到es内部也是，目标是百万日志秒处理
SpringBoot整合Kafka
ITBOY_ITBOX博客
10-11 956
使用注解@KafkaListener定义当前方法监听Kafka中指定topic的消息，接收到的消息封装在对象ConsumerRecord中，获取数据从ConsumerRecord对象中获取即可。运行bin目录下的windows目录下的kafka-server-start命令即可启动kafka服务器，默认对外服务端口9092。Kafka提供有一套测试服务器功能的测试程序，运行bin目录下的windows目录下的命令即可使用。：使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息。
SpringBoot项目集成kafka及常规配置
codeLife1993的博客
06-17 1万+
使用 spring-kafka 的api，在springboot项目中集成kafka能力，封装配置。
springboot+kafka详细
baidu_25691461的博客
03-03 4188
集成kafka 1.引入kafka maven依赖 <!-- kafka包 --> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> <!-- fast
本地搭建kafka并用java实现发送消费消息
小趴菜的小蛋泡
09-25 917
调用send发送1-100消息到指定Topic test。需要启动上面的操作 启动kafka 建立主题，启动zk。发送kafka的测试，消费者直接消费。首先下载一个可视化软件。
大数据之Kafka————java来实现kafka相关操作
ycz926940的博客
07-06 4462
生产者多线程是一种常见的技术实践，可以提高消息生产的并发性和吞吐量。通过将消息生产任务分配给多个线程来并行地发送消息，可以有效地利用系统资源，加快消息的发送速度。Java中写在生产者输入内容在kafka中可以让消费者提取。（2）、Producer进行多线程操作。一、在java中配置pom。通过java来实现消费者。(2)、设置多人访问。
spring boot集成kafka开发，接收kafka消息，Java（1）
Zhang Phil
02-24 5206
命令： kafka-topics.bat --list --bootstrap-server 127.0.0.1:9092 Windows环境下，列出主机127.0.0.1上kafka的主题topic。
kafka springboot整合
09-07
Kafka与Spring Boot的整合可以通过引入Spring Kafka的starter来实现。首先，在项目的pom.xml文件中引入如下依赖： ```xml <groupId>org.springframework.kafka <artifactId>spring-kafka ``` 接下来，您需要启动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值