Azure Spring Boot Function使用Tuple作为输入输出参数时遭遇UnsupportedOperationException异常

我刚遇到过类似的问题，这个错误的核心原因是Spring Cloud Function的适配器会把Tuple类型的返回值误认为是多个输出参数，而不是单个返回对象。虽然错误提示写着“only Tuple-based function are supporting multiple arguments”，但这里的场景是我们把Tuple作为单个返回值使用，适配器却错误地尝试将其解析为多输出，从而抛出异常。

问题根源 #

你的Hello函数定义为Function<Tuple2<String, Integer>, Tuple3<String, Boolean, Integer>>，当Spring Cloud Function处理返回的Tuple3时，它会触发多输出参数的解析逻辑，但当前版本的适配器并不支持将单个Tuple作为返回值——它只允许在函数本身是接收/返回多个独立参数时使用Tuple，而不是把Tuple当作单个输入/输出对象。

解决方案 #

最直接且易维护的解决方法是用自定义的POJO类替代Tuple作为返回类型，这样Spring Cloud Function会明确将其视为单个返回对象，不会触发错误的多输出解析逻辑。

步骤1：创建自定义返回DTO类

package com.att.trace.function.model;

public class HelloResponse {
    private String firstValue;
    private Boolean secondValue;
    private Integer thirdValue;

    // 全参构造函数
    public HelloResponse(String firstValue, Boolean secondValue, Integer thirdValue) {
        this.firstValue = firstValue;
        this.secondValue = secondValue;
        this.thirdValue = thirdValue;
    }

    // 生成getter和setter方法
    public String getFirstValue() { return firstValue; }
    public void setFirstValue(String firstValue) { this.firstValue = firstValue; }
    public Boolean getSecondValue() { return secondValue; }
    public void setSecondValue(Boolean secondValue) { this.secondValue = secondValue; }
    public Integer getThirdValue() { return thirdValue; }
    public void setThirdValue(Integer thirdValue) { this.thirdValue = thirdValue; }
}

步骤2：修改Hello函数类

把函数的返回类型从Tuple3替换为自定义的HelloResponse：

package com.att.trace.function;

import java.util.function.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import com.att.trace.function.model.HelloResponse;
import reactor.util.function.Tuple2;

@Component
public class Hello implements Function<Tuple2<String, Integer>, HelloResponse>{
    private static Logger log = LoggerFactory.getLogger(Hello.class);

    @Override
    public HelloResponse apply(Tuple2<String, Integer> input) {
        System.out.println("input.getT1()=" + input.getT1());
        System.out.println("input.getT2()=" + input.getT2());
        // 用自定义DTO封装返回值
        return new HelloResponse("one", false, 1);
    }
}

步骤3：修改HelloHandler类的泛型

更新FunctionInvoker的泛型参数，将输出类型改为自定义的HelloResponse：

package com.att.trace.function;

import java.util.Optional;
import com.att.trace.function.model.HelloResponse;
import com.att.trace.function.model.User;
import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import org.springframework.cloud.function.adapter.azure.FunctionInvoker;
import reactor.util.function.Tuple2;
import reactor.util.function.Tuples;

public class HelloHandler extends FunctionInvoker<Tuple2<String, Integer>, HelloResponse> {
    @FunctionName("hello")
    public HttpResponseMessage execute(@HttpTrigger(name = "request", methods = { HttpMethod.GET, HttpMethod.POST }, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<User>> request, ExecutionContext context) {
        User user = request.getBody().filter((u -> u.getName() != null))
                .orElseGet(() -> new User(request.getQueryParameters().getOrDefault("name", "world")));
        context.getLogger().info("Greeting user name: " + user.getName());
        Tuple2<String, Integer> base = Tuples.of("one", 1);
        HelloResponse push_to = handleRequest(base, context);
        System.out.println("push_to=" + push_to.getFirstValue() + ", " + push_to.getSecondValue() + ", " + push_to.getThirdValue());
        return request.createResponseBuilder(HttpStatus.OK).body("ok")
                .header("Content-Type", "application/json").build();
    }
}

可选替代方案（如需保留Tuple） #

如果你确实需要继续使用Tuple作为返回值，可以将其包装在Mono中，让适配器将其视为单个异步返回值：

// 修改Hello函数的返回类型
@Component
public class Hello implements Function<Tuple2<String, Integer>, Mono<Tuple3<String, Boolean, Integer>>> {
    @Override
    public Mono<Tuple3<String, Boolean, Integer>> apply(Tuple2<String, Integer> input) {
        return Mono.just(Tuples.of("one", false, 1));
    }
}

// 同步修改HelloHandler的泛型
public class HelloHandler extends FunctionInvoker<Tuple2<String, Integer>, Mono<Tuple3<String, Boolean, Integer>>> {
    // ... 其余逻辑调整为异步处理返回值
}

不过这种方式会增加异步处理的复杂度，不如自定义DTO直观。

内容的提问来源于stack exchange，提问作者Tarun Aghara