Question

我希望有相同的函数来使用来自不同 RabbitMQ 队列的消息，然后将消息生成到不同的交换器。

我的函数处理消费和生产

@Bean
public Function<String, String> myFunction() {

    return (x) -> {
        System.out.println(x);
        return "hello world " + x;
    };
}

我的 application.yml 看起来像这样：

spring:
  cloud:
    stream:
      function:
        definition: myFunction
      rabbit:
        bindings:
          myFunction-in-0:
            consumer:
              declareExchange: false
              bindQueue: false
              queueNameGroupOnly: true
              bindingRoutingKey: '"myExchange.test.request"'
          myFunction-out-0:
            producer:
              declareExchange: false
              bindQueue: false
              queueNameGroupOnly: true
              routingKeyExpression: '"myExchange.test.result"'
          myFunction-in-1:
            consumer:
              declareExchange: false
              bindQueue: false
              queueNameGroupOnly: true
              bindingRoutingKey: '"myExchange1.test.request"'
          myFunction-out-1:
            producer:
              declareExchange: false
              bindQueue: false
              queueNameGroupOnly: true
              routingKeyExpression: '"myExchange1.test.result"'
      bindings:
        myFunction-in-0:
          content-type: application/json
          group: MY_QUEUE
        myFunction-out-0:
          content-type: application/json
          destination: myExchange
        myFunction-in-1:
          content-type: application/json
          group: MY_QUEUE1
        myFunction-out-1:
          content-type: application/json
          destination: myExchange1

基本上，我想要实现的是拥有一个功能，并且在幕后，我希望 Spring Cloud Stream 为我创建两个消费者和两个生产者，而我根本不必更改功能。

我认为这可以通过将 out 绑定中的绑定分别更改为 0 1 来实现，但它不起作用。 Spring Cloud stream 仅为 in-0 绑定创建一个使用者，而我的 in-1 绑定被忽略。

有什么想法吗？

Answer 1

多输入/输出当前 (3.1.3) 仅支持反应式函数。

<块引用>

重要提示：目前，只有反应式函数 (Function<TupleN<Flux<?>…>, TupleN<Flux<?>…>>) 支持函数元性，这些函数以复杂事件处理为中心，其中对事件汇合的评估和计算通常需要查看事件流而不是单个事件。

然而，即使使用反应式函数，定义也有点不同，索引与函数参数显式耦合。与您的示例相反，不同的绑定对于每个索引可能具有不同的输入/输出类型。因此，函数定义使用来自 Project Reactor 的 TupleN 类型，允许指定每个绑定的类型。

让我们让您的示例发挥作用：

@Bean
public Function<Tuple2<Flux<String>, Flux<String>>, Tuple2<Flux<String>, Flux<String>>> myFunction2() {
    return tuple -> {
        var flux = Flux.merge(tuple.getT1(), tuple.getT2())
                .doOnNext(System.out::println)
                .map(x -> "hello world " + x)
                .publish();
        flux.connect();
        return Tuples.of(flux, flux);
    };
}

如果你真的不能改变函数，你可以创建一个反应式包装函数：

@Bean
public Function<Tuple2<Flux<String>, Flux<String>>, Tuple2<Flux<String>, Flux<String>>> myFunctionWrapper() {
    return tuple -> {
        var flux = Flux.merge(tuple.getT1(), tuple.getT2())
                .map(myFunction())
                .publish();
        flux.connect();
        return Tuples.of(flux, flux);
    };
}

这是docs中的相关部分。

从不同队列消费并生产到不同队列的一种功能

1 个答案: