从回调返回字符串-Java

有人知道我如何解决以下问题吗。我想从回调返回一个字符串，但由于final，我只得到“final局部变量s无法赋值，因为它是在封闭类型中定义的”

 public String getConstraint(int indexFdg) {
    final String s;
    AsyncCallback<String> callback = new AsyncCallback<String>() {
        public void onFailure(Throwable caught) {
            caught.printStackTrace();
        }

        public void onSuccess(String result) {
            s = result;
        }
    };
    SpeicherService.Util.getInstance().getConstraint(indexFdg, callback);
    return s;
    }

公共字符串getConstraint（int indexFdg）{
最终字符串s；
AsyncCallback callback=新的AsyncCallback（）{
失败时的公共无效（可丢弃）{
已捕获。printStackTrace（）；
}
成功时的公共void（字符串结果）{
s=结果；
}
};
SpeicherService.Util.getInstance（）.getConstraint（indexFdg，回调）；
返回s；
}

异步回调的全部目的是在将来某个时候通知您异步发生的事情。如果要在方法完成运行后设置，则不能从

getConstraint

返回

s

在处理异步回调时，您必须重新考虑程序的流程。回调的结果应该调用将继续使用该值的代码，而不是返回值

作为一个简单（不完整）的示例，您需要更改以下内容：

 String s = getConstraint();
 someGuiLabel.setText(s);

变成这样：

 myCallback = new AsyncCallback<String>() {
     public void onSuccess(String result) {
         someGuiLabel.setText(result);
     }
 }
 fetchConstraintAsynchronously(myCallback);

myCallback=new AsyncCallback（）{
成功时的公共void（字符串结果）{
someGuiLabel.setText（结果）；
}
}
同步获取约束（myCallback）；

编辑 一个流行的选择是未来的概念。未来是一个可以立即返回的对象，但它只在未来的某个时刻具有值。它是一个容器，您只需在请求时等待值

你可以把拥有未来想象成拥有一张在干洗店买衣服的票。你马上拿到票，可以把它放在钱包里，交给朋友。。。但是一旦你需要把它换成真正的西装，你就需要等到西装准备好了

---

Java有这样一个类（），被广泛使用。

另一种解决方法是定义一个新类，称为

SyncResult

public class SyncResult {
    private static final long TIMEOUT = 20000L;
    private String result;

    public String getResult() {
        long startTimeMillis = System.currentTimeMillis();
        while (result == null && System.currentTimeMillis() - startTimeMillis < TIMEOUT) {
            synchronized (this) {
                try {
                    wait(TIMEOUT);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public void setResult(String result) {
        this.result = result;
        synchronized (this) {
            notify();
        }
    }
}

公共类同步结果{
专用静态最终长超时=20000L；
私有字符串结果；
公共字符串getResult（）{
long startTimeMillis=System.currentTimeMillis（）；
while（result==null&&System.currentTimeMillis（）-startTimeMillis

然后将代码更改为

public String getConstraint(int indexFdg) {
    final SyncResult syncResult = new SyncResult();
    AsyncCallback<String> callback = new AsyncCallback<String>() {
        public void onFailure(Throwable caught) {
            caught.printStackTrace();
        }

        public void onSuccess(String result) {
            syncResult.setResult(result);
        }
    };
    SpeicherService.Util.getInstance().getConstraint(indexFdg, callback);
    return syncResult.getResult();
}

公共字符串getConstraint（int indexFdg）{
最终SyncResult SyncResult=新的SyncResult（）；
AsyncCallback callback=新的AsyncCallback（）{
失败时的公共无效（可丢弃）{
已捕获。printStackTrace（）；
}
成功时的公共void（字符串结果）{
syncResult.setResult（结果）；
}
};
SpeicherService.Util.getInstance（）.getConstraint（indexFdg，回调）；
返回syncResult.getResult（）；
}

---

getResult（）

方法将被阻止，直到调用了

setResult（String）

方法或达到了

超时时间。
AsyncCallback
无法返回值。但是
Callable
可以。通常我会做的是将其设置为可调用的，将其传递给executor服务，并使用返回的
Future
获取返回值。我面临类似的问题，从回调的结果中，我必须更新UI。我采用了与您提到的相同的技术，但在我的例子中，问题变成了循环的，就像A->B和B->A一样，其中A是UI类，B是具有回调的类。保持这种状态是一种好的做法，还是你能提出其他的替代方案？Like UI类调用回调函数，回调函数再次调用UI。@AtulKumar:我们可能需要更多的细节来了解这是否是一个问题。如果它引起了一个具体的问题，用一个简单的例子来重复这个问题可能是合适的。如果你问的是关于设计的一般性问题，那么它可能适合你。一般来说，我要说的是，相互依赖本身并不是交易的破坏者，在MVC（视图和控制器相互了解）等模式中很常见。