多个 GWT-RPC 调用的最佳实践

Question

我必须进行几次 GWT-RPC 调用。 我想像这样异步启动它们。

service.s1(param1, callback1);
service.s2(param2, callback2);
service.s3(param3, callback3);

我不确定如何“同步”这三个回调。 下一个动作，例如调用方法 nextMethod();应在三个回调完成后完成。 是否有“最佳实践”如何做到这一点？

我想建立一个像这样的小服务类

public class ServiceSync
{ private boolean[] callReady;

  public ServiceSync(int n)
  { callReady = new boolean[n];
    for(int i=0; i<n;i++)
    {  callReady[i]=false;
    }
  }

  public boolean setReady(int i)
  { callReady[i]=true;
    for(boolean b : callReady)
    { if (!b) return false;    
    }
    return true;
  }
}

在回调中我会说

if (serviceSync.setReady(myId))
{ nextMethod();}

但我不确定这是不是个好主意。 特别是我不确定是否会出现问题，如果 2 个回调“同时”调用此服务类

Answer 1

看来这是典型案例，Promises可以解决。

遵循 DRY 的原则，我不会自己编写代码，而是使用为 gwt 编写的gwtquery Promises 解决方案，基于流行的 jQuery Deferred 实现。

在您的情况下，您的代码可能如下所示：

    // Create 3 promises to be used in RPC
    PromiseRPC<String> promise1 = new PromiseRPC<String>();
    PromiseRPC<String> promise2 = new PromiseRPC<String>();
    PromiseRPC<String> promise3 = new PromiseRPC<String>();

    // Fire the asynchronous requests
    greetingService.greetServer(textToServer1, promise1);
    greetingService.greetServer(textToServer2, promise2);
    greetingService.greetServer(textToServer3, promise3);

    GQuery
          // 'when' returns a new promise which monitors all of its subordinates
          .when(promise1, promise2, promise3)
          // 'done' will be executed only in the case all promises succeed
          .done(new Function() {
            public void f() {
              // each promise store its result in a fixed position of the argument list
              String textFromServer1 = arguments(0, 0);
              String textFromServer2 = arguments(1, 0);
              String textFromServer3 = arguments(2, 0);
            }
          });

    // If you want you could fire requests here instead than above

Answer 2

为您的回调声明一个带有状态的接收器，例如：

public class CallResultReceiver {

   boolean call1Done, call2Done, call3Done;

   public void onCall1Success() { 
      call1Done = true;
      if (call1Done && call2Done && call3Done) { doGreatThings(); }
   }

   public void onCall2Success() { 
      call2Done = true;
      if (call1Done && call2Done && call3Done) { doGreatThings(); }
   }

   public void onCall3Success() { 
      call3Done = true;
      if (call1Done && call2Done && call3Done) { doGreatThings(); }
   }
}

Answer 3

他是Parallel asynchronous calls in GWT上最好的文章

通过编写一个简单的 ParentCallBack，您可以让您的事情变得简单高效。

public void someGwtClientSideMethod() {   
  SomeServiceAsync someService = GWT.create(SomeService.class);  
  ParallelCallback fooCallback = new ParallelCallback();  
  ParallelCallback barCallback = new ParallelCallback();  
  ParentCallback parent = new ParentCallback(fooCallback, barCallback) {   
    public void handleSuccess() {  
      doSomething(getCallbackData(0), getCallbackData(1));  
    }  
  };  
  someService.foo(fooCallback);  
  someService.bar(barCallback);  
} 

这里是Code for Parent Callback。

Answer 4

这是我提出问题的方法：

首先，我们需要在并行异步问题中使用某种 SynchronizedCounter：

public class SynchronizedCounter {

    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

下一步是调用 RPC 方法，例如：

private void fetchData() {
    getFirst();
    getSecond();
    getThird();
    getFourth();
}

每个 RPC 方法都必须在请求之前增加我们的计数器，并在调用成功后立即减少它。每个 RPC 方法都会在 RPC 调用之后调用 final 方法，该方法会检查请求的计数，例如：

private void dataFetched() {
    if (counter.value() <= 0)
        // proceed
}

IMO 非常清晰和优雅的方法。希望对您有所帮助。