C++转Java：带错误码与多参数函数的通用返回方案咨询

现有一个C++项目，包含至少100个如下模式的相似函数，需要转换为Java代码，但遇到了适配问题：

int evaluateFunc(const para1 /*input only*/, para2 &/* input&output*/, para3 & /*output only */ ...)
{
   int result = OK;
   ...
   // For Input parameter, we defined as const. e.g. para1
   // For Input/Output parameter, we pass either by reference or pointer, as it may get updated during data processing.  e.g. para2 
   // For output only parameter, which will be modified inside function. e.g. para3
   ...
   return result;
}

这类函数的核心特点：

1. 输入输出或仅输出参数会被函数修改，后续供其他函数处理，因此C++中使用引用或指针传递；
2. 返回整数类型的结果码表示执行状态，0代表成功，其他50+种值为错误码，外部会根据结果码做错误处理。

Java中不支持传引用或指针，所有值按副本传递，且函数只能返回一个值。如果为每个函数创建对应类来同时返回错误码和数据，最坏情况需要创建100个类，成本过高。请问是否存在Java函数返回结果的通用解决方案？

方案1：泛型结果类封装 #

创建一个通用的泛型结果类，统一承载错误码和输出数据。对于多输出参数的场景，先将多个输出数据封装成DTO类，再放入泛型结果中，避免为每个函数单独创建结果类。

示例代码：

// 通用结果类，所有函数复用
public class Result<T> {
    private int code; // 0为成功，其他为错误码
    private T data; // 可存储单个值或多输出DTO

    public Result(int code, T data) {
        this.code = code;
        this.data = data;
    }

    public int getCode() { return code; }
    public T getData() { return data; }
}

// 多输出参数的DTO示例（对应原C++的para2、para3）
public class EvaluateOutput {
    private ParaType2 para2; // 原输入输出参数
    private ParaType3 para3; // 原仅输出参数

    public void setPara2(ParaType2 para2) { this.para2 = para2; }
    public ParaType2 getPara2() { return para2; }
    public void setPara3(ParaType3 para3) { this.para3 = para3; }
    public ParaType3 getPara3() { return para3; }
}

// 转换后的Java函数
public Result<EvaluateOutput> evaluateFunc(ParaType1 para1, ParaType2 para2) {
    int code = 0;
    EvaluateOutput output = new EvaluateOutput();
    output.setPara2(para2);

    try {
        // 业务逻辑处理，生成并设置输出参数
        ParaType3 para3 = processData(para1, para2);
        output.setPara3(para3);
    } catch (DataException e) {
        code = 101; // 对应错误码
    }

    return new Result<>(code, output);
}

方案2：利用Holder类模拟输出参数 #

Java中对象传递的是引用副本，因此可以用通用Holder类承载仅输出参数，输入输出参数直接传递对象并修改其内部属性，函数返回错误码，完全贴合原C++的参数模式。

示例代码：

// 通用Holder类，所有仅输出参数复用
public class Holder<T> {
    private T value;

    public void setValue(T value) { this.value = value; }
    public T getValue() { return value; }
}

// 转换后的Java函数
public int evaluateFunc(ParaType1 para1, ParaType2 para2, Holder<ParaType3> para3Holder) {
    int code = 0;
    try {
        // 修改输入输出参数的内部属性（对象引用副本不影响属性修改）
        para2.updateField(processInput(para1));
        // 生成仅输出参数并设置到Holder中
        ParaType3 para3 = generateOutput(para1, para2);
        para3Holder.setValue(para3);
    } catch (ProcessException e) {
        code = 202; // 对应错误码
    }
    return code;
}

// 调用示例
ParaType1 para1 = new ParaType1();
ParaType2 para2 = new ParaType2();
Holder<ParaType3> para3Holder = new Holder<>();
int resultCode = evaluateFunc(para1, para2, para3Holder);
if (resultCode == 0) {
    ParaType3 para3 = para3Holder.getValue();
    // 后续处理逻辑
}

方案3：异常映射错误码 #

如果错误码对应可预见的业务异常，可将每种错误码映射为自定义异常，函数正常执行时返回输出数据，出错时抛出对应异常，外部通过捕获异常处理错误逻辑，符合Java的异常处理习惯。

示例代码：

// 自定义业务异常基类
public class BusinessException extends RuntimeException {
    private int errorCode;

    public BusinessException(int errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() { return errorCode; }
}

// 对应某错误码的具体异常
public class DataProcessException extends BusinessException {
    public DataProcessException() {
        super(101, "数据处理失败");
    }
}

// 转换后的Java函数
public EvaluateOutput evaluateFunc(ParaType1 para1, ParaType2 para2) {
    EvaluateOutput output = new EvaluateOutput();
    output.setPara2(para2);
    try {
        ParaType3 para3 = processData(para1, para2);
        output.setPara3(para3);
    } catch (IOException e) {
        throw new DataProcessException();
    }
    return output;
}

// 调用示例
try {
    EvaluateOutput output = evaluateFunc(para1, para2);
    // 成功处理逻辑
} catch (BusinessException e) {
    int errorCode = e.getErrorCode();
    // 根据错误码处理异常
}

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