kafka-springboot 简单应用

pom

<!--springboot中的kafka依赖-->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>2.5.0</version>
</dependency>

yml

#============== kafka ===================
kafka:
  #kafka配置
  bootstrap-servers: 127.0.0.1:9092 #集群配置多个，中间，隔开
  producer:
    # 连接的broker地址，如有多个用逗号隔开
    bootstrap-servers: 127.0.0.1:9092
    # key序列化类，可以自定义序列化（broker端接受的消息必须以字节数组的形式）
    key-serializer: org.apache.kafka.common.serialization.StringSerializer
    # value序列化类，可以自定义序列化
    value-serializer: org.apache.kafka.common.serialization.StringSerializer
    # 重试次数（提高可靠性，会影响同步性能，需要等待上一条消息发送完成后才发送下一条）
    retries: 0
  consumer:
    # 连接的broker地址，如有多个用逗号隔开
    bootstrap-servers: 127.0.0.1:9092
    # key反序列化类
    key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    # value反序列化类
    value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    properties:
      max.poll.interval.ms: 86400000
    auto-offset-reset: latest

KafkaUtils.java

@Slf4j
@Component
public class KafkaUtils {

    private static final String MESSAGE_START = "kafka sendMessage start";

    @Autowired
    private KafkaTemplate kafkaTemplate;

    /**
     * 异步发送消息并处理回调
     * @param topic
     * @param data
     */
    public void sendCallMessage(String topic, String data) {
        log.info(MESSAGE_START);
        ListenableFuture<SendResult<Integer, String>> future = kafkaTemplate.send(topic, data);
        future.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
            @Override
            public void onFailure(Throwable ex) {
                log.error("kafka sendMessage error, ex = {}, topic = {}, data = {}", ex, topic, data);
            }

            @Override
            public void onSuccess(SendResult<Integer, String> result) {
                log.info("kafka sendMessage success topic = {}, data = {}",topic, data);
            }
        });
        log.info("kafka sendMessage end");
    }

    /**
     * 异步发送，不抛异常则发送成功
     * @param topic
     * @param data
     */
    public void sendMessage(String topic, String data) {
        log.info(MESSAGE_START);
        try{
            kafkaTemplate.send(topic, data);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        log.info("kafka sendMessage end");
    }

    /**
     * 同步发送消息,如果成功返回recordMetadata，否则抛出异常
     * @param topic
     * @param data
     */
    public void sendDefaultMessage(String topic, String data) {
        log.info(MESSAGE_START);
        try {
            RecordMetadata recordMetadata = (RecordMetadata) kafkaTemplate.send(topic, data).get();
            log.info("kafka sendMessage success topic = {}, data = {}",recordMetadata.topic(), data);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        log.info("kafka sendMessage end");
    }
}

JsonUtils

@Slf4j
public class JsonUtils {

    private static ObjectMapper mapper = new ObjectMapper();

    static {
        // 对于空的对象转json的时候不抛出错误
        mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 允许属性名称没有引号
        mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        // 允许单引号
        mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        // 设置输入时忽略在json字符串中存在但在java对象实际没有的属性
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 设置输出时包含属性的风格
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }


    /**
     * 序列化，将对象转化为json字符串
     *
     * @param data
     * @return
     */
    public static String toJsonString(Object data) {
        if (data == null) {
            return null;
        }

        String json = null;
        try {
            json = mapper.writeValueAsString(data);
        } catch (JsonProcessingException e) {
            log.error("[{}] toJsonString error：{{}}", data.getClass().getSimpleName(), e);
        }
        return json;
    }


    /**
     * 反序列化，将json字符串转化为对象
     *
     * @param json
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T parse(@NonNull String json, Class<T> clazz) {
        T t = null;
        try {
            t = mapper.readValue(json, clazz);
        } catch (Exception e) {
            log.error(" parse json [{}] to class [{}] error：{{}}", json, clazz.getSimpleName(), e);
        }
        return t;
    }

}

 

发消息

kafkaUtils.sendMessage("sendOrderMessage", JsonUtils.toJsonString(orderInfo));

接收

@Component
@Slf4j
public class testConsumer {

    @KafkaListener(id = "id", topics = "topicaaaaaaa")
    public void listenxxxapp(String message){
        Vo  param = JsonUtils.parse(message , Vo.class);
       
    }

}