SpringBoot整合Kafka消息队列，实现消费和生产

1. 情景：项目中需要用到kafka消息队列获取消息和返回消息，然后SpringBoot使用整合一下kafka，在此记录一下配置和使用过程。

框架版本：SpringBoot2.0

上一下Kafka流程图：

 

 1、在pom.xml引用kafka包

        <!-- kafka -->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>   
        </dependency>

2、在 application.xml中配置kafka相关参数

  kafka:
    #bootstrap-servers: 你的ip:9092  #此处必须与server.properties的ip一致
    bootstrap-servers: xxxx:9092  #此处必须与server.properties的ip一致

    #生产者配置
    producer:
      #指定消息key和消息体的编解码方式 UTF-8
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      #kafka加密配置
      properties:
        sasl.mechanism: PLAIN
        security.protocol: SASL_PLAINTEXT
        sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username='root' password=xxxx';
    #消费者配置
    consumer:
      group-id: seeker-test
      enable-auto-commit: true
      auto-commit-interval: 1000
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      auto-offset-reset: earliest
      max-poll-records: 100
      #kafka加密配置
      properties:
        sasl.mechanism: PLAIN
        security.protocol: SASL_PLAINTEXT
        sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username='root' password='xxxx';

3、创建生产者实体类：KafkaProducer 

package com.seeker.kafka;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

/**
 *生产者
 * @author seeker
 * 
 */
@Component
@Slf4j
public class KafkaProducer {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    //自定义topic
    public static final String TOPIC_TEST = "iot-call-warn";

    public void send(Object obj) {
        String obj2String = JSONObject.toJSONString(obj);
        log.info("准备发送消息为：{}", obj2String);

        //发送消息
        ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(TOPIC_TEST, obj2String);
        future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                //发送失败的处理
                log.info(TOPIC_TEST + " - 生产者 发送消息失败：" + throwable.getMessage());
            }

            @Override
            public void onSuccess(SendResult<String, String> stringObjectSendResult) {
                //成功的处理
                log.info(TOPIC_TEST + " - 生产者 发送消息成功：" + stringObjectSendResult.toString());
            }
        });
    }
}

 4、创建消费者实体类：KafkaConsumer 

package com.seeker.kafka;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zhuoyue.elmt.UserFilterUtils;
import jodd.util.StringUtil;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.mp.api.WxMpInMemoryConfigStorage;
import me.chanjar.weixin.mp.api.WxMpService;
import me.chanjar.weixin.mp.api.impl.WxMpServiceImpl;
import me.chanjar.weixin.mp.bean.template.WxMpTemplateData;
import me.chanjar.weixin.mp.bean.template.WxMpTemplateMessage;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.text.MessageFormat;
import java.util.*;

/**
 * 消费者
 * @author seeker
 *  2021-07-27
 */
@Component
@Slf4j
public class KafkaConsumer {

    @Autowired
    private KafkaProducer kafkaProducer;

    @KafkaListener(topics = "iot-msg-warn")
    public void topic_test(String data) {
        try {

            log.warn(data);
            //处理接收的数据
            String param = data.replace("[", "").replace("]", "");
            log.warn("param=" + param);
    
            List<Warnmsg> list = JSON.parseArray(data, Warnmsg.class);
            for (Warnmsg warnmsg : list) {
              
                        //推回消息给Kafka
                        warnmsg.setPhoneNum("185***24");//设置回推人联系电话
                        //调用生产者 困人返回电话号码
                        kafkaProducer.send(warnmsg);
                    }
                }
            }
        } catch (Throwable e) {
            log.error("", e);
        }
    }
}

5、接收参数实体：

package com.seeker.kafka;

import lombok.Data;

@Data
public class Warnmsg {

    private String deviceId;

    private Long deviceTime;

    private Long eventType;

    private String phoneNum;

}

总结：SpringBoot整合kafka还是比较简单的，只需导入kafka包，配置好kafka生产者和消费者参数，然后写好接收kafka消息的消费者实体类、发送kafka消息的生产者实体类、接收和发送参数实体，就可以实现系统接收和发送kafka消息。

注意：配置文件中的消费者group-id要起一个唯一性的防止出现重复的，重复了会导致消费会被随机消费，一方被消费，另一方就消费不到消息啦了。

OK 就到这里了！