在将Spring Cloud Stream与Kafka一起使用时，如何执行优雅的应用程序关闭？

Question

我有一个使用Spring Cloud Stream（v1.3.0）和Kafka（v1.1.6）的Spring boot（v.1.57）应用程序。我希望能够优雅地关闭它，即关闭时，所有流监听器（即用@StreamListener注释）应该：

1. 停止轮询新消息
2. 完成他们的工作
3. 将偏移提交给Kafka

我注意到ContainerProperties（默认设置为10000ms）中有一个名为“Shutdown Timeout”的属性，所以我尝试通过像这样的反射扩展ConvoltKafkaListenerContainerFactoryConfigrer类来将其修改为30000（因为它有一个@先决条件OnMissingBean注释）：

@Slf4j
@Component
public class BehalfConcurrentKafkaListenerContainerFactoryConfigurer extends ConcurrentKafkaListenerContainerFactoryConfigurer {

    @Autowired
    private KafkaProperties kproperties;

    @Override
    public void configure(ConcurrentKafkaListenerContainerFactory<Object, Object> listenerContainerFactory,
                          ConsumerFactory<Object, Object> consumerFactory) {
        PropertyAccessor myAccessor = PropertyAccessorFactory.forDirectFieldAccess(this);
        myAccessor.setPropertyValue("properties", kproperties);

        ContainerProperties containerProperties = listenerContainerFactory
                .getContainerProperties();
        super.configure(listenerContainerFactory, consumerFactory);
        containerProperties.setShutdownTimeout(30000);
    }
}

但这并不成功。还尝试将其（关机超时：30000）放入应用程序。yml在spring cloud stream binder设置下，但同样没有帮助。

有什么方法可以控制关机过程并实现我的目标吗？

Answer 1

编辑

不再需要进行这种反射黑客；只需将ListenerContainerCustomizer添加到应用程序上下文中。请参见此处。

EDIT_END

SpringKafka1.1。不再支持x；您应该将1.3.9与boot 1.5一起使用。x。

当前引导1.5。x版本为1.5.21。

你应该立即升级。

然而，所有这些项目都有更新的版本。

Spring Cloud Stream不使用该工厂或引导属性来创建其容器；它没有公开在容器上配置该属性的机制。

Spring Cloud Stream 2.1添加了ListenerContainerCustomizer，它允许您通过在其上设置任何属性来自定义绑定容器。

我建议您升级到Boot 2.1.6和Spring Cloud Stream Germantown（2.2.0）。

编辑

这是一个有点黑客，但它应该工作，直到你可以升级到一个新的流版本。。。

@SpringBootApplication
@EnableBinding(Sink.class)
public class So56883620Application {

    public static void main(String[] args) {
        SpringApplication.run(So56883620Application.class, args).close();
    }

    private final CountDownLatch latch = new CountDownLatch(1);

    @StreamListener(Sink.INPUT)
    public void listen(String in) throws InterruptedException {
        this.latch.countDown();
        System.out.println(in);
        Thread.sleep(6_000);
        System.out.println("exiting");
    }

    @Bean
    public ApplicationRunner runner(KafkaTemplate<byte[], byte[]> template) {
        return args -> {
            IntStream.range(0,2).forEach(i -> template.send("mytopic", ("foo" + i).getBytes()));
            // wait for listener to start
            this.latch.await(10, TimeUnit.SECONDS);
            System.out.println("Shutting down");
        };
    }

    @Bean
    public SmartLifecycle bindingFixer(BindingService bindingService) {
        return new SmartLifecycle() {

            @Override
            public int getPhase() {
                return Integer.MAX_VALUE;
            }

            @Override
            public void stop() {
                // no op
            }

            @Override
            public void start() {
                @SuppressWarnings("unchecked")
                Map<String, Binding<?>> consumers = (Map<String, Binding<?>>) new DirectFieldAccessor(bindingService)
                        .getPropertyValue("consumerBindings");
                @SuppressWarnings("unchecked")
                Binding<?> inputBinding = ((List<Binding<?>>) consumers.get("input")).get(0);
                ((AbstractMessageListenerContainer<?, ?>) new DirectFieldAccessor(inputBinding)
                        .getPropertyValue("lifecycle.messageListenerContainer"))
                                .getContainerProperties().setShutdownTimeout(30_000L);
            }

            @Override
            public boolean isRunning() {
                return false;
            }

            @Override
            public void stop(Runnable callback) {
                callback.run();
            }

            @Override
            public boolean isAutoStartup() {
                return true;
            }
        };
    }

}