（十五）处理有异常消息_got error produce response with

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

在封装创建request的时候会调用handleProduceResponse（），这个里面会调用

private void completeBatch(RecordBatch batch, Errors error, long baseOffset, long timestamp, long correlationId, long now) {
       //如果响应里面带有异常 并且 这个请求是可以重试的
        if (error != Errors.NONE && canRetry(batch, error)) {
            // retry
            log.warn("Got error produce response with correlation id {} on topic-partition {}, retrying ({} attempts left). Error: {}",
                     correlationId,
                     batch.topicPartition,
                     this.retries - batch.attempts - 1,
                     error);
            //重新把发送失败等着批次 加入到队列里面。
            this.accumulator.reenqueue(batch, now);
            this.sensors.recordRetries(batch.topicPartition.topic(), batch.recordCount);
        } else {
            //这儿过来的数据：带有异常，但是不可以重试（1：压根就不让重试2：重试次数超了）

            //其余的都走这个分支。
            RuntimeException exception;
            //如果响应里面带有 没有权限的异常
            if (error == Errors.TOPIC_AUTHORIZATION_FAILED)
                //自己封装一个异常信息（自定义了异常）
                exception = new TopicAuthorizationException(batch.topicPartition.topic());
            else
                //
                exception = error.exception();
            // tell the user the result of their request
            //TODO 核心代码 把异常的信息也给带过去了
            //我们刚刚看的就是这儿的代码
            //里面调用了用户传进来的回调函数
            //回调函数调用了以后
            //说明我们的一个完整的消息的发送流程就结束了。
            batch.done(baseOffset, timestamp, exception);
            //看起来这个代码就是要回收资源的。
            this.accumulator.deallocate(batch);
            if (error != Errors.NONE)
                this.sensors.recordErrors(batch.topicPartition.topic(), batch.recordCount);
        }
        if (error.exception() instanceof InvalidMetadataException) {
            if (error.exception() instanceof UnknownTopicOrPartitionException)
                log.warn("Received unknown topic or partition error in produce request on partition {}. The " +
                        "topic/partition may not exist or the user may not have Describe access to it", batch.topicPartition);
            metadata.requestUpdate();
        }

        // Unmute the completed partition.
        if (guaranteeMessageOrder)
            this.accumulator.unmutePartition(batch.topicPartition);
    }

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
40
41
42
43
44
45
46
47
48

有异常并且可以重试，执行第一个分支，会调用

  public void reenqueue(RecordBatch batch, long now) {
        //重试次数 累加
        batch.attempts++;
        //上一次重试的时间
        batch.lastAttemptMs = now;
        batch.lastAppendTime = now;
        batch.setRetry();
        Deque<RecordBatch> deque = getOrCreateDeque(batch.topicPartition);
        synchronized (deque) {
            //重新放入到队列里面
            //放入到队头
            deque.addFirst(batch);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

有异常但是不可以重试，执行第二个分支，会调用

 //这儿过来的数据：带有异常，但是不可以重试（1：压根就不让重试2：重试次数超了）

            //其余的都走这个分支。
            RuntimeException exception;
            //如果响应里面带有 没有权限的异常
            if (error == Errors.TOPIC_AUTHORIZATION_FAILED)
                //自己封装一个异常信息（自定义了异常）
                exception = new TopicAuthorizationException(batch.topicPartition.topic());
            else
                //
                exception = error.exception();
            // tell the user the result of their request
            //TODO 核心代码 把异常的信息也给带过去了
            //我们刚刚看的就是这儿的代码
            //里面调用了用户传进来的回调函数
            //回调函数调用了以后
            //说明我们的一个完整的消息的发送流程就结束了。
            batch.done(baseOffset, timestamp, exception);
            //看起来这个代码就是要回收资源的。
            this.accumulator.deallocate(batch);
            if (error != Errors.NONE)
                this.sensors.recordErrors(batch.topicPartition.topic(), batch.recordCount);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22