Kafka消费消息时遇到的问题

问题

现在有这样一个场景，当Kafka接收到某条消息之后，会解析这条信息，并补充其他信息，然后将其存入到MySQL中。问，在接收到消息并存入到MySQL的过程中出现以下问题该如何解决：

• 第一，如果出现异常，该如何保证这条消息被重新发回到队列中；
• 第二，当代码本身异常，这条消息始终消息不成功，一直在Kafka中循环发送和消息，此时该如何处理？
• 第三，这些消费不成功的消息，该如何进行追踪，以便可以进行手动补偿；
• 第四，如何保证这一条消息不会被重复消息；
• 第五，某一时间内，消息太多，积压在Kafka中，请从减少发送方和增加消费方这两种角度，给出解决方案。

以下面这段代码为例进行说明：

 public void consumerMsg(boolean partitionStatus, Integer partitionNum) {
        //创建消费者
        ConcurrentMessageListenerContainer<String, String> container = partitionStatus ?
                kafkaListenerContainerFactory.createContainer(new TopicPartitionOffset("topic", partitionNum)) :
                kafkaListenerContainerFactory.createContainer("topic");
        //监听器开启手动提交
        container.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);

        //批量消费处理逻辑
        container.setupMessageListener((BatchAcknowledgingConsumerAwareMessageListener<String, String>) (records,
                                                                                                         acknowledgment,
                                                                                                         consumer) -> {
            // 处理批量消息的消费逻辑
            //构建数据集
            Map<String, List<LinkedHashMap<String, Object>>> datas = new HashMap<>();

            //开启消费 进行数据落盘
            for (ConsumerRecord<String, String> record : records) {
                //原始日志
                String rawLog = record.value();
                if (StringUtils.isBlank(rawLog)) {
                    log.warn("kafka process warn get log is null");
                    //如果为空 则结束
                    continue;
                }
                try {
                    //根据基础配置信息序列化所有参数
                    generatorInsertData(datas, rawLog);
                } catch (Exception e) {
                    log.error("kafka process fail 构建入表数据失败", e);
                }
            }
            //构建insertSql入表
            for (String key : datas.keySet()) {
                //获取表对应的类型
                try {
                    //执行插入
                    insertDataToMySQL(datas);
                } catch (Exception e) {
                    log.error("kafka process fail", e);
                }
            }
            // 手动提交消费位移
            assert acknowledgment != null;
            acknowledgment.acknowledge();
        });
        container.start();
    }

    private void generatorInsertData(Map<String, List<LinkedHashMap<String, Object>>> datas, String rawLog) {
        // 根据rawLog填充datas
    }

    private void insertDataToMySQL(Map<String, List<LinkedHashMap<String, Object>>> datas) {
        // 将datas插入到MySQL
    }

解决

在处理Kafka消息并将其存储到MySQL的过程中，确保系统的健壮性和数据的一致性是非常重要的。以下是针对您提出的几个问题的详细解决方案，以及如何从减少发送方和增加消费方的角度解决消息积压问题。

一、处理异常情况

1. 如果出现异常，如何保证这条消息被重新发回到队列中？

在Kafka消费者中，您可以通过不确认消息的位移来实现这一点。只要在处理消息时发生异常，就不调用acknowledge()方法，这样Kafka会将消息重新放回队列中。

代码实现：

container.setupMessageListener((BatchAcknowledgingConsumerAwareMessageListener<String, String>) (records, acknowledgment, consumer) -> {
    Map<String, List<LinkedHashMap<String, Object>>> datas = new HashMap<>();
    boolean hasError = false; // 标识是否出现异常

    for (ConsumerRecord<String, String> record : records) {
        String rawLog = record.value();
        if (StringUtils.isBlank(rawLog)) {
            log.warn("kafka process warn get log is null");
            continue; // 空消息跳过
        }
        try {
            generatorInsertData(datas, rawLog);
        } catch (Exception e) {
            log.error("kafka process fail 构建入表数据失败", e);
            hasError = true; // 设置有错误
        }
    }

    for (String key : datas.keySet()) {
        try {
            insertDataToMySQL(datas);
        } catch (Exception e) {
            log.error("kafka process fail", e);
            hasError = true; // 设置有错误
        }
    }

    // 如果有错误，抛出异常，确保消息不会被确认
    if (hasError) {
        throw new RuntimeException("处理消息时发生错误"); // 可以自定义异常
    } else {
        acknowledgment.acknowledge(); // 确认消费
    }
});

2. 当代码本身异常，消息始终不成功，如何处理？

为了避免消息在Kafka中循环发送，可以设置最大重试次数，并在达到最大重试次数后将消息发送到死信队列（DLQ）。

• 设置最大重试次数：可以通过Kafka的配置来实现。
• 使用死信队列：将处理失败的消息发送到一个专门的主题，用于后续的人工处理或重试。

示例：

if (hasError) {
    // 发送到死信队列
    kafkaTemplate.send("dead-letter-topic", record.key(), record.value());
    throw new RuntimeException("处理消息时发生错误，已发送到死信队列");
}

3. 如何追踪消费不成功的消息以便手动补偿？

• 日志记录：在处理失败时，记录详细的日志，包括消息内容、错误信息等，以便后续审查。
• 外部存储：将失败的消息记录到数据库或其他存储中，方便后续手动补偿。

示例：

if (hasError) {
    // 记录失败消息到数据库
    logFailedMessage(rawLog, e.getMessage());
}

4. 如何保证这一条消息不会被重复处理？

• 幂等性设计：确保数据插入操作是幂等的，即对于同一条消息，执行多次的结果是一样的。
• 唯一性约束：在数据库表中对关键字段（如消息ID）添加唯一约束，这样在插入时如果遇到重复的消息，数据库会拒绝插入。

示例：

private void insertDataToMySQL(Map<String, List<LinkedHashMap<String, Object>>> datas) {
    for (String table : datas.keySet()) {
        List<LinkedHashMap<String, Object>> records = datas.get(table);
        for (LinkedHashMap<String, Object> record : records) {
            try {
                if (!existsInDatabase(record.get("uniqueId"))) { // 检查唯一性
                    // 执行插入操作
                }
            } catch (Exception e) {
                log.error("插入数据失败", e);
                throw e; // 抛出异常，触发重试机制
            }
        }
    }
}

private boolean existsInDatabase(Object uniqueId) {
    // 查询数据库，检查记录是否存在
    // ...
    return false; // 示例返回值
}

二、处理消息积压

1. 从减少发送方的角度

• 限流（Rate Limiting）：在生产者端实现限流机制，限制每秒发送的消息数量。

  示例代码（使用Guava的RateLimiter）：

  RateLimiter rateLimiter = RateLimiter.create(100); // 每秒最多发送 100 条消息
  
  public void sendMessage(String message) {
      rateLimiter.acquire(); // 获取令牌，若无令牌则阻塞
      kafkaTemplate.send("topic", message);
  }
  

• 批量发送：将多条消息合并为一条消息进行发送，减少发送次数。

  配置示例：

  batch.size=16384 # 批量大小
  linger.ms=5 # 等待时间
  

• 消息压缩：使用 Kafka 的消息压缩功能（如 GZIP、Snappy、LZ4），减少网络带宽和存储空间的使用。

  配置示例：

  compression.type=gzip # 设置压缩类型
  

• 动态调整发送策略：根据当前 Kafka 的负载情况动态调整发送策略，例如在高负载时降低发送速率。

2. 从增加消费方的角度

• 增加消费者实例：通过增加消费者实例来提高并发消费能力。Kafka 的分区数决定了可以并行消费的消费者数量。

• 增加分区数：增加主题的分区数，以便可以有更多的消费者并行消费消息。

  命令示例：

  kafka-topics.sh --alter --topic your_topic --partitions 10 --bootstrap-server localhost:9092
  

• 优化消费者逻辑：确保消费者的处理逻辑尽可能高效，减少处理时间。可以考虑使用异步处理或多线程来提高消费速度。

  示例：

  ExecutorService executorService = Executors.newFixedThreadPool(10);
  
  container.setupMessageListener((BatchAcknowledgingConsumerAwareMessageListener<String, String>) (records, acknowledgment, consumer) -> {
      for (ConsumerRecord<String, String> record : records) {
          executorService.submit(() -> processMessage(record));
      }
      acknowledgment.acknowledge(); // 确认消费
  });
  

• 使用流处理框架：使用 Kafka Streams 或 Apache Flink 等流处理框架，利用其高效的流处理能力来处理消息。

• 调整消费者配置：调整消费者的配置参数以提高消费效率，例如增加 max.poll.records 和 fetch.min.bytes。

  配置示例：

  max.poll.records=500 # 每次最多拉取 500 条消息
  fetch.min.bytes=1024 # 最小拉取字节数
  

总结

通过上述措施，您可以有效地处理Kafka消息到MySQL的过程中可能出现的异常情况，并确保系统的健壮性和数据的一致性。同时，通过减少发送方的消息量和增加消费方的处理能力，可以有效缓解Kafka中的消息积压问题。具体措施包括限流、批量发送、增加消费者实例、优化消费者逻辑等。结合这些策略，可以提升系统的整体性能和稳定性，确保消息能够及时被处理。

延伸问题

上面使用到的uniqueId可以使用哪些方法生成？

在系统中生成唯一标识符（unique ID）是确保数据一致性和防止重复处理的关键。以下是一些常用的方法来生成 uniqueId：

1. UUID（通用唯一标识符）

描述：UUID是一种标准的唯一标识符，通常以32个十六进制数字表示，分为五个部分，格式为 8-4-4-4-12。

生成方法：

• 在 Java 中，可以使用 java.util.UUID 类生成 UUID。

import java.util.UUID;

String uniqueId = UUID.randomUUID().toString();

优点：

• 几乎可以保证全局唯一性。
• 不需要中心化的生成服务。

缺点：

• UUID的长度较长（36 个字符），在某些情况下可能会影响性能。

2. 数据库自增主键

描述：使用数据库的自增主键作为唯一标识符。

生成方法：

• 在 MySQL 中，可以定义一个自增字段作为主键。

CREATE TABLE example (
    id INT AUTO_INCREMENT PRIMARY KEY,
    ...
);

优点：

• 简单易用，且在数据库中保证唯一性。

缺点：

• 需要依赖数据库，可能会成为性能瓶颈。
• 在分布式系统中，可能会导致id冲突。

3. 雪花算法（Snowflake）

描述：Twitter开源的雪花算法生成的ID是一个 64 位的整数，通常由时间戳、机器ID和序列号组合而成。

生成方法：

• 可以使用现成的库，例如 snowflake 或自己实现。

public class SnowflakeIdGenerator {
    private final long workerId;
    private final long datacenterId;
    private long sequence = 0L;
    private final long epoch = 1288834974657L; // 自定义起始时间
    private final long workerIdBits = 5L; // 机器 ID 位数
    private final long datacenterIdBits = 5L; // 数据中心 ID 位数
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits); // 机器 ID最大值
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 数据中心 ID最大值
    private final long sequenceBits = 12L; // 序列号位数
    private final long workerIdShift = sequenceBits; // 机器 ID偏移量
    private final long datacenterIdShift = sequenceBits + workerIdBits; // 数据中心 ID偏移量
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; // 时间戳偏移量

    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("worker Id can't be greater than " + maxWorkerId + " or less than 0");
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException("datacenter Id can't be greater than " + maxDatacenterId + " or less than 0");
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        // 生成 ID 的逻辑
        // ...
        return id;
    }
}

优点：

• 生成的id有序，适合用于数据库索引。
• 具有高并发性，适合分布式系统。

缺点：

• 需要维护机器id和数据中心id。

4. 时间戳 + 随机数

描述：使用当前时间戳加上随机数生成唯一标识符。

生成方法：

• 可以将当前时间戳与随机数结合。

import java.util.Random;

public String generateUniqueId() {
    long timestamp = System.currentTimeMillis();
    int randomNum = new Random().nextInt(10000); // 生成 0-9999 的随机数
    return timestamp + "-" + randomNum; // 例如：1633024800000-1234
}

优点：

• 简单易用。

缺点：

• 在高并发情况下可能会产生重复id。

5. Hashing 方法

描述：使用某种哈希算法（如SHA-256）对特定数据（如用户id、时间戳等）进行哈希，生成唯一标识符。

生成方法：

import java.security.MessageDigest;

public String generateHashId(String input) throws Exception {
    MessageDigest md = MessageDigest.getInstance("SHA-256");
    byte[] hash = md.digest(input.getBytes());
    StringBuilder hexString = new StringBuilder();
    for (byte b : hash) {
        String hex = Integer.toHexString(0xff & b);
        if (hex.length() == 1) hexString.append('0');
        hexString.append(hex);
    }
    return hexString.toString();
}

优点：

• 可以生成固定长度的id。

缺点：

• 需要确保输入数据的唯一性，以避免哈希冲突。

6. 自定义 ID 生成器

描述：根据业务需求自定义id生成器，可以结合多种方法。

生成方法：

• 结合时间戳、机器 ID、随机数等生成唯一 ID。

public String customUniqueId() {
    long timestamp = System.currentTimeMillis();
    String machineId = "01"; // 假设机器 ID
    String randomPart = UUID.randomUUID().toString().replace("-", "").substring(0, 8); // 8 位随机数
    return timestamp + "-" + machineId + "-" + randomPart;
}

总结

选择合适的 uniqueId 生成方法取决于您的具体需求，包括性能、唯一性、可读性和系统架构等因素。对于大多数应用，UUID和雪花算法是比较常用的选择，而数据库自增主键则适合简单的单机应用。

uniqueId生成时，如果两条消息的内容完成一样，则此时生成的uniqueId应该是一样，该如何实现

如果您希望根据消息内容生成的 uniqueId 在内容完全相同的情况下也能保持一致，您可以使用哈希函数来实现这一目标。哈希函数的特性是相同的输入总会产生相同的输出，因此可以确保对于相同的消息内容，生成的 uniqueId 是一致的。

以下是实现这一目标的几种方法：

1. 使用哈希函数

使用哈希函数（如SHA-256或MD5）对消息内容进行哈希处理。无论消息内容的长度如何，哈希函数都会生成固定长度的输出。

示例代码（使用SHA-256）：

import java.security.MessageDigest;

public class UniqueIdGenerator {

    public String generateUniqueIdFromMessage(String message) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(message.getBytes());
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

2. 组合特定字段并哈希

如果消息是一个结构化对象（如JSON），可以选择其中一些字段进行组合，然后对组合后的字符串进行哈希处理。这种方法确保了即使消息的其他部分不同，只要关键字段相同，生成的 uniqueId 也会相同。

示例代码：

import java.security.MessageDigest;
import java.util.Map;

public class UniqueIdGenerator {

    public String generateUniqueIdFromStructuredMessage(Map<String, Object> message) throws Exception {
        StringBuilder uniqueIdBuilder = new StringBuilder();
        uniqueIdBuilder.append(message.get("userId")); // 假设消息中有 userId 字段
        uniqueIdBuilder.append(message.get("timestamp")); // 假设消息中有 timestamp 字段
        uniqueIdBuilder.append(message.get("eventType")); // 假设消息中有 eventType 字段

        return generateUniqueIdFromMessage(uniqueIdBuilder.toString());
    }

    private String generateUniqueIdFromMessage(String message) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(message.getBytes());
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

3. JSON 字符串化与哈希

如果消息是JSON格式，可以将其字符串化后进行哈希处理。确保在字符串化时保持字段的顺序一致，以避免因字段顺序不同而导致的哈希值不同。

示例代码（使用Jackson库）：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.security.MessageDigest;

public class UniqueIdGenerator {

    private final ObjectMapper objectMapper = new ObjectMapper();

    public String generateUniqueIdFromJsonMessage(Object messageObject) throws Exception {
        String jsonString = objectMapper.writeValueAsString(messageObject);
        return generateUniqueIdFromMessage(jsonString);
    }

    private String generateUniqueIdFromMessage(String message) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(message.getBytes());
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

4. 确保输入一致性

无论您选择哪种方法，都需要确保输入到哈希函数的数据是一致的。这意味着：

• 对于结构化数据，确保字段的顺序和格式一致。
• 对于字符串，确保使用相同的编码（如UTF-8）。
• 对于 JSON，使用标准化的方式进行字符串化，避免因空格、换行等导致的差异。

总结

通过使用哈希函数（如SHA-256或MD5），您可以确保对于相同的消息内容生成相同的 uniqueId。选择合适的字段进行组合或直接对整个消息进行哈希处理，确保输入的一致性是关键。这样，无论消息的内容如何变化，只要内容相同，生成的 uniqueId 就会保持一致。