kafka批量拉一部分数据，消费过程中抛错，剩下数据丢失咋解决

[sinat_27054329]

现在项目中kafka环境测试结果如下：

比如一次拉500条数据下来处理，
当处理第100条时由于数据问题导致程序报错了，那么101-500这些数据就没被消费了
下一批数据就会从501-1000

以前看到过这种情况，如果一批数据处理中有任何报错，下次消费从报错这批数据的第一个offset继续消费，这样保证每批数据至少不漏消费
请问实现这种场景怎么配置的，现在用kafka+springboot测试不是这种效果

最后，还有什么更好的方法，解决这种漏消费问题么，尽量保证不丢，适当重复也可以

[sinat_27054329]

有没有大佬解答下

[weixin_41138110]

zookeeper里面保存了消费组的offset，修改它就可以

[sinat_27054329]

引用 2 楼 weixin_41138110 的回复:

zookeeper里面保存了消费组的offset，修改它就可以

手动修改？代码咋操作或者咋配置呢，可以详细点么

[sinat_27054329]

有没有大佬知道

[戎码一生灬]

引用 9 楼 sinat_27054329 的回复:

[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题

[sinat_27054329]

引用 10 楼 James灬Gosling 的回复:

[quote=引用 9 楼 sinat_27054329 的回复:] [quote=引用 8 楼 James灬Gosling 的回复:] 配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了； 但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote] 不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote] 之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完； 但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理； 所以好奇这是怎么实现的

[sinat_27054329]

有没有大佬解惑下

[戎码一生灬]

你别自动提交啊，代码改为手动提交offset啊

[sinat_27054329]

引用 6 楼 James灬Gosling 的回复:

你别自动提交啊，代码改为手动提交offset啊

是可以手动提交实现 但是kafka可以实现拉一批数据，这批中有抛错，那下一批还是会从有错误的这批第一个offset开始消费，虽然可能重但不漏，想知道这个怎么配置或者实现的，而且这种方式是自动提交offset

[戎码一生灬]

配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

[sinat_27054329]

引用 8 楼 James灬Gosling 的回复:

配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了； 但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的

[sinat_27054329]

引用 12 楼 James灬Gosling 的回复:

[quote=引用 11 楼 sinat_27054329 的回复:] [quote=引用 10 楼 James灬Gosling 的回复:] [quote=引用 9 楼 sinat_27054329 的回复:] [quote=引用 8 楼 James灬Gosling 的回复:] 配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了； 但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote] 不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote] 之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完； 但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理； 所以好奇这是怎么实现的 [/quote] @StreamListener才是批量的吧[/quote] @KafkaListener可以配成批量并发

[戎码一生灬]

引用 13 楼 sinat_27054329 的回复:

[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过

[戎码一生灬]

引用 11 楼 sinat_27054329 的回复:

[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧

[sinat_27054329]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:] [quote=引用 12 楼 James灬Gosling 的回复:] [quote=引用 11 楼 sinat_27054329 的回复:] [quote=引用 10 楼 James灬Gosling 的回复:] [quote=引用 9 楼 sinat_27054329 的回复:] [quote=引用 8 楼 James灬Gosling 的回复:] 配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了； 但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote] 不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote] 之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完； 但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理； 所以好奇这是怎么实现的 [/quote] @StreamListener才是批量的吧[/quote] @KafkaListener可以配成批量并发 [/quote] 没配过[/quote]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:] [quote=引用 12 楼 James灬Gosling 的回复:] [quote=引用 11 楼 sinat_27054329 的回复:] [quote=引用 10 楼 James灬Gosling 的回复:] [quote=引用 9 楼 sinat_27054329 的回复:] [quote=引用 8 楼 James灬Gosling 的回复:] 配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了； 但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote] 不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote] 之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完； 但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理； 所以好奇这是怎么实现的 [/quote] @StreamListener才是批量的吧[/quote] @KafkaListener可以配成批量并发 [/quote] 没配过[/quote] 大佬，比如现在topic的数量是可配的，所以要监听可变的topic，名称是有规律的，所以想到用模糊匹配去做@KafkaListener(topicPattern = "test.*") 可以匹配多个topic， 但如果想匹配上几个topic就要起几个线程处理相应topic的消息怎么实现？比如第一个线程消费第一个topic，第二个线程处理第二个topic内容这样，topic是有规律的，test_1, test_2等等，配的几就几 这咋实现比较好

[戎码一生灬]

引用 15 楼 sinat_27054329 的回复:

[quote=引用 14 楼 James灬Gosling 的回复:]
[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]


大佬，比如现在topic的数量是可配的，所以要监听可变的topic，名称是有规律的，所以想到用模糊匹配去做@KafkaListener(topicPattern = "test.*") 可以匹配多个topic，
但如果想匹配上几个topic就要起几个线程处理相应topic的消息怎么实现？比如第一个线程消费第一个topic，第二个线程处理第二个topic内容这样，topic是有规律的，test_1, test_2等等，配的几就几
这咋实现比较好[/quote]




https://www.cnblogs.com/gaoyawei/p/7723974.html
希望对你有用，参考下

[sinat_27054329]

引用 16 楼 James灬Gosling 的回复:

[quote=引用 15 楼 sinat_27054329 的回复:]
[quote=引用 14 楼 James灬Gosling 的回复:]
[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]


大佬，比如现在topic的数量是可配的，所以要监听可变的topic，名称是有规律的，所以想到用模糊匹配去做@KafkaListener(topicPattern = "test.*") 可以匹配多个topic，
但如果想匹配上几个topic就要起几个线程处理相应topic的消息怎么实现？比如第一个线程消费第一个topic，第二个线程处理第二个topic内容这样，topic是有规律的，test_1, test_2等等，配的几就几
这咋实现比较好[/quote]




https://www.cnblogs.com/gaoyawei/p/7723974.html
希望对你有用，参考下[/quote]

这是用原生api的方式，然后创建线程，
但现在的逻辑都是注解实现监听@KafkaListener，
想根据配置的topic数量，比如配了10，那么就创建10个带@KafkaListener的方法，因为一个带@KafkaListener的方法就是单独一个线程处理的，但是@KafkaListener又不能用在方法内部所以大佬知不知道这咋实现

[戎码一生灬]

引用 17 楼 sinat_27054329 的回复:

[quote=引用 16 楼 James灬Gosling 的回复:]
[quote=引用 15 楼 sinat_27054329 的回复:]
[quote=引用 14 楼 James灬Gosling 的回复:]
[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]


大佬，比如现在topic的数量是可配的，所以要监听可变的topic，名称是有规律的，所以想到用模糊匹配去做@KafkaListener(topicPattern = "test.*") 可以匹配多个topic，
但如果想匹配上几个topic就要起几个线程处理相应topic的消息怎么实现？比如第一个线程消费第一个topic，第二个线程处理第二个topic内容这样，topic是有规律的，test_1, test_2等等，配的几就几
这咋实现比较好[/quote]




https://www.cnblogs.com/gaoyawei/p/7723974.html
希望对你有用，参考下[/quote]

这是用原生api的方式，然后创建线程，
但现在的逻辑都是注解实现监听@KafkaListener，
想根据配置的topic数量，比如配了10，那么就创建10个带@KafkaListener的方法，因为一个带@KafkaListener的方法就是单独一个线程处理的，但是@KafkaListener又不能用在方法内部所以大佬知不知道这咋实现[/quote]

引用 17 楼 sinat_27054329 的回复:

[quote=引用 16 楼 James灬Gosling 的回复:]
[quote=引用 15 楼 sinat_27054329 的回复:]
[quote=引用 14 楼 James灬Gosling 的回复:]
[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]

引用 14 楼 James灬Gosling 的回复:

[quote=引用 13 楼 sinat_27054329 的回复:]
[quote=引用 12 楼 James灬Gosling 的回复:]
[quote=引用 11 楼 sinat_27054329 的回复:]
[quote=引用 10 楼 James灬Gosling 的回复:]
[quote=引用 9 楼 sinat_27054329 的回复:]
[quote=引用 8 楼 James灬Gosling 的回复:]
配置文件里面有个autoCommitOffset设置为false就不会自动提交了，如果你批量消费kafka的数据，当你监听到一批数据以后，建议批量处理这批数据，而不是单个单个处理，原则就是：批量监听，批量处理（例如存数据库），如果你批量监听一批数据，然后单个处理，是会存在你说的可能重但不漏的问题

是的，拉一批数据，然后一条条遍历处理(比如判断字段格式是否正确，是否是想要的数据等等)，但是处理中只要抛错就剩下的就不处理了；
但是看到过别人在一批中有抛错然后下一批还会拉取这批有错的，直到这批没有错误就不再拉取，offset也是自动提交，疑惑通过kafka自身是怎么实现的[/quote]


不管你设置的是自动提交还是手动提交，你监听kafka的那个方法，也就是有@StreamListener这个注解或者@KafkaListener注解的方法，当这个方法里面没有发生错误，顺利执行完，你的offset才会自动提交，如果有任意一个错误，也就是这个方法没有执行完，异常终止了，那并不会提交offset，除非你在里面做了try catch机制，自己吞了异常，才会导致这批数据抛错了，但是下次拉取会跳过这批数据的问题[/quote]

之前测过别人代码，好像直接while循环一直poll，每次拉一批，比如这批中抛异常了，没有catch，重启下，这批数据还是会在，又从这批第一个消息消费，只要某批数据抛异常下次一定会有拉下来，除非这批数据没有错误全部处理完；

但是用springboot写了个测试，用@KafkaListener监听，就是出现不了这种情形，只要一批数据中抛错不catach，下次重启这批数据就没有了，不会像上面那样只有有异常的那批数据还会被拉下来处理；

所以好奇这是怎么实现的
[/quote]


@StreamListener才是批量的吧[/quote]
@KafkaListener可以配成批量并发
[/quote]

没配过[/quote]


大佬，比如现在topic的数量是可配的，所以要监听可变的topic，名称是有规律的，所以想到用模糊匹配去做@KafkaListener(topicPattern = "test.*") 可以匹配多个topic，
但如果想匹配上几个topic就要起几个线程处理相应topic的消息怎么实现？比如第一个线程消费第一个topic，第二个线程处理第二个topic内容这样，topic是有规律的，test_1, test_2等等，配的几就几
这咋实现比较好[/quote]




https://www.cnblogs.com/gaoyawei/p/7723974.html
希望对你有用，参考下[/quote]

这是用原生api的方式，然后创建线程，
但现在的逻辑都是注解实现监听@KafkaListener，
想根据配置的topic数量，比如配了10，那么就创建10个带@KafkaListener的方法，因为一个带@KafkaListener的方法就是单独一个线程处理的，但是@KafkaListener又不能用在方法内部所以大佬知不知道这咋实现[/quote]

没这么玩过，所以我也没经验