Kafka消费者Consume常用参数

下面先来个消费者Demo:

import java.util.Arrays;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import com.alibaba.fastjson.JSONObject;

public class ConsumerDemo {
    private static ExecutorService threadPool =
            Executors.newFixedThreadPool(20);

    public static void main(String[] args) throws Exception {
        KafkaConsumer<String, String> consumer = createConsumer();
        consumer.subscribe(Arrays.asList("order-topic"));
        try {
            while (true) {
                ConsumerRecords<String, String> records =
                        consumer.poll(Integer.MAX_VALUE);
                for (ConsumerRecord<String, String> record : records) {
                    JSONObject order = JSONObject.parseObject(record.value());
                    threadPool.submit(new CreditManageTask(order));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            consumer.close();
        }
    }

    private static KafkaConsumer<String, String> createConsumer() {
        Properties props = new Properties();
        props.put("bootstrap.servers",
                "hadoop03:9092,hadoop04:9092,hadoop05:9092");
        props.put("group.id", "test-group");
        props.put("key.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("heartbeat.interval.ms", 1000); // 这个尽量时间可以短一点
        props.put("session.timeout.ms", 10 * 1000); // 如果说kafka broker在10秒内感知不到一个consumer心跳
        props.put("max.poll.interval.ms", 30 * 1000); // 如果30秒才去执行下一次poll
// 就会认为那个consumer挂了，此时会触发rebalance
// 如果说某个consumer挂了，kafka broker感知到了，会触发一个rebalance的操作，就是分配他的分区
// 给其他的cosumer来消费，其他的consumer如果要感知到rebalance重新分配分区，就需要通过心跳来感知
// 心跳的间隔一般不要太长，1000，500
        props.put("fetch.max.bytes", 10485760);
        props.put("max.poll.records", 500); // 如果说你的消费的吞吐量特别大，此时可以适当提高一些
        props.put("connection.max.idle.ms", -1); // 不要去回收那个socket连接
// 开启自动提交，他只会每隔一段时间去提交一次offset
// 如果你每次要重启一下consumer的话，他一定会把一些数据重新消费一遍
        props.put("enable.auto.commit", "true");
// 每次自动提交offset的一个时间间隔
        props.put("auto.commit.ineterval.ms", "1000");
// 每次重启都是从最早的offset开始读取，不是接着上一次
        props.put("auto.offset.reset", "earliest");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,
                String>(props);
        return consumer;
    }

    s
    tatic

    class CreditManageTask implements Runnable {
        private JSONObject order;

        public CreditManageTask(JSONObject order) {
            this.order = order;
        }

        @
                Override
        public void run() {
            System.out.println("对订单进行积分的维护......" +
                    order.toJSONString());
// 就可以做一系列的数据库的增删改查的事务操作
        }
    }
}

• 【heartbeat.interval.ms】

consumer心跳时间，必须得保持心跳才能知道consumer是否故障了，然后如果故障之后，就会通过心跳下发rebalance的指令给其他的consumer通知他们进行rebalance的操作

• 【session.timeout.ms】

kafka多长时间感知不到一个consumer就认为他故障了，默认是10秒

• 【max.poll.interval.ms】

如果在两次poll操作之间，超过了这个时间，那么就会认为这个consume处理能力太弱了，会被踢出消费组，分区分配给别人去消费，一遍来说结合你自己的业务处理的性能来设置就可以了

• 【fetch.max.bytes】

获取一条消息最大的字节数，一般建议设置大一些

• 【max.poll.records】

一次poll返回消息的最大条数，默认是500条

• 【connection.max.idle.ms】

consumer跟broker的socket连接如果空闲超过了一定的时间，此时就会自动回收连接，但是下次消费就要重新建立socket连接，这个建议设置为-1，不要去回收

• 【auto.offset.reset】
  •  earliest

当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
topica -> partition0:1000
partitino1:2000

•         latest

当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从当前位置开始消费

•         none

topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
注：我们生产里面一般设置的是latest

• 【enable.auto.commit】

这个就是开启自动提交唯一

• 【auto.commit.ineterval.ms】

这个指的是多久条件一次偏移量