SpringBoot 2.2.5 整合Kafka，实现消息的发送及消费_springboot向kafka发送信息,消费信息

完整代码地址在结尾！！

第一步，在pom.xml加入依赖，如下

<!-- kafka -->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.3.6.RELEASE</version>
</dependency>
1
2
3
4
5
6

第二步，在application.yml配置文件配置kafka

spring:
  kafka:
    bootstrap-servers: xxx:9092,xxx:9092,xxx:9092
    # 消费监听接口监听的主题不存在时，默认会报错
    listener:
      missing-topics-fatal: false
    producer:
      # 当retris为0时，produce不会重复。retirs重发，此时repli节点完全成为leader节点，不会产生消息丢失。
      retries: 0
      #procedure要求leader在考虑完成请求之前收到的确认数，用于控制发送记录在服务端的持久化，其值可以为如下：
      #acks = 0 如果设置为零，则生产者将不会等待来自服务器的任何确认，该记录将立即添加到套接字缓冲区并视为已发送。在这种情况下，无法保证服务器已收到记录，并且重试配置将不会生效（因为客户端通常不会知道任何故障），为每条记录返回的偏移量始终设置为-1。
      #acks = 1 这意味着leader会将记录写入其本地日志，但无需等待所有副本服务器的完全确认即可做出回应，在这种情况下，如果leader在确认记录后立即失败，但在将数据复制到所有的副本服务器之前，则记录将会丢失。
      #acks = all 这意味着leader将等待完整的同步副本集以确认记录，这保证了只要至少一个同步副本服务器仍然存活，记录就不会丢失，这是最强有力的保证，这相当于acks = -1的设置。
      #可以设置的值为：all, -1, 0, 1
      acks: 1
      # 指定消息key和消息体的编解码方式
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      # 每次批量发送消息的数量,produce积累到一定数据，一次发送
      #batch-size: 16384
      # produce积累数据一次发送，缓存大小达到buffer.memory就发送数据
      #buffer-memory: 33554432
    consumer:
      # 指定默认消费者group id --> 由于在kafka中，同一组中的consumer不会读取到同一个消息，依靠groud.id设置组名
      group-id: testGroup
      # smallest和largest才有效，如果smallest重新0开始读取，如果是largest从logfile的offset读取。一般情况下我们都是设置smallest
      auto-offset-reset: earliest
      # enable.auto.commit:true --> 设置自动提交offset
      enable-auto-commit: true
      #如果'enable.auto.commit'为true，则消费者偏移自动提交给Kafka的频率（以毫秒为单位），默认值为5000。
      auto-commit-interval: 100
      # 指定消息key和消息体的编解码方式
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

第三步，创建简单消息体，Message，简单消息请求实体，如下

Message

import lombok.Data;

import java.io.Serializable;

/**
 * @Description: 消息体
 * @Author: jinhaoxun
 * @Date: 2020/7/10 9:53 上午
 * @Version: 1.0.0
 */
@Data
public class Message<T> implements Serializable {

    private String id;
    private T content;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

第四步，创建消息监听器，KafkaConsumerListener，消费者消费消息使用，只要有消息就会进行消费，可以指定不同的topic，如下

import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: jinhaoxun
 * @Date: 2020/7/10 9:53 上午
 * @Version: 1.0.0
 */
@Slf4j
@Component
public class KafkaConsumerListener {

    @KafkaListener(topics = "test_topic")
    public void onMessage(String message){
        // 消费消息
        // 这里为插入数据库代码
        //insertIntoDb(buffer);
        log.info("接收到消息：" + message);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第五步，编写服务类，KafkaService，KafkaServiceImpl，如下

KafkaService

public interface KafkaService {

    boolean sendMessage(String message);

}
1
2
3
4
5

KafkaServiceImpl

import com.luoyu.kafka.service.KafkaService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Slf4j
@Service
public class KafkaServiceImpl implements KafkaService {

    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    @Override
    public boolean sendMessage(String message) {
        // 发送消息
        kafkaTemplate.send("test_topic", message);
        return true;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

第六步，编写单元测试类，KafkaApplicationTests，并进行测试，只列举了部分方法

import com.luoyu.kafka.entity.Message;
import com.luoyu.kafka.service.KafkaService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
// 获取启动类，加载配置，确定装载 Spring 程序的装载方法，它回去寻找 主配置启动类（被 @SpringBootApplication 注解的）
@SpringBootTest
class KafkaApplicationTests {

    @Autowired
    private KafkaService kafkaService;

    @Test
    void sendMessageTest() throws Exception{
        Message<String> message = new Message();
        message.setId("1");
        message.setContent("test");
        // 发送消息
        kafkaService.sendMessage(message.toString());
        // 让主线程睡眠10秒
        Thread.currentThread().sleep(10000);
    }

    @BeforeEach
    void testBefore(){
        log.info("测试开始!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

    @AfterEach
    void testAfter(){
        log.info("测试结束!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

完整代码地址：https://github.com/Jinhx128/springboot-demo

注：此工程包含多个module，本文所用代码均在kafka-demo模块下