Question

如果你看下面是我在我的应用程序中进行RPC调用时有效负载进入服务器

7|0|14|http://domain.com/ager-online/tracklay/|7FCCBC6F7B44BB2BEB84AAB8B47DB2E4|com.d.g4.consumer.w.client.rpcservice.ConsumerService|placeService|java.util.List|java.util.ArrayList/4159755760|co.g.consumer.wager.client.model.ConsumernseType/2494043886|java.lang.Double/858496421|java.lang.Integer/3438268394|2|1|WIN|java.lang.Long/4227064769|java.util.Date/3385151746|1|2|3|4|1|5|6|1|7|8|2|8|2|9|1|10|11|11|12|13|Co3|14|**Uzc1OKs**|9|309158|-5|

我知道它被序列化并将数据发送到服务器。我想知道的是中间的钥匙。比如 Uzc1OKs 我在请求中标记了它们。

它们究竟是什么？

有什么想法吗？

Answer 1

您是否尝试过这种开源工具？ https://code.google.com/p/gwt-payload-deserializer/

这是有效载荷元素说明： https://code.google.com/p/gwt-payload-deserializer/wiki/GwtPayloadDefinition

Answer 2

您可以在客户端上以下列方式使用GWT RPC：

创建服务

private void refreshWatchList() {
    final double MAX_PRICE = 100.0; // $100.00
    final double MAX_PRICE_CHANGE = 0.02; // +/- 2%

    StockPrice[] prices = new StockPrice[stocks.size()];
    for (int i = 0; i < stocks.size(); i++) {
      double price = Random.nextDouble() * MAX_PRICE;
      double change = price * MAX_PRICE_CHANGE
          * (Random.nextDouble() * 2.0 - 1.0);

      prices[i] = new StockPrice(stocks.get(i), price, change);
    }

    updateTable(prices);
  }

定义服务

@RemoteServiceRelativePath("stockPrices")
public interface StockPriceService extends RemoteService {

      StockPrice[] getPrices(String[] symbols);
}

实施服务

public class StockPriceServiceImpl extends RemoteServiceServlet implements StockPriceService {

    public StockPrice[] getPrices(String[] symbols) {
        // TODO Auto-generated method stub
        return null;
    }
}

从客户端调用服务并进行远程过程调用：

private ArrayList<String> stocks = new ArrayList<String>();
private StockPriceServiceAsync stockPriceSvc = GWT.create(StockPriceService.class);

private void refreshWatchList() {
    // Initialize the service proxy.
    if (stockPriceSvc == null) {
      stockPriceSvc = GWT.create(StockPriceService.class);
    }

     // Set up the callback object.
    AsyncCallback<StockPrice[]> callback = new AsyncCallback<StockPrice[]>() {
      public void onFailure(Throwable caught) {
        // TODO: Do something with errors.
      }

      public void onSuccess(StockPrice[] result) {
        updateTable(result);
      }
    };

     // Make the call to the stock price service.
    stockPriceSvc.getPrices(stocks.toArray(new String[0]), callback);
}

这基本上就是RPC的功能。

你的

中间的
键

可能是序列化对象的结果。如果你不喜欢，你也可以使用GWT RequestBuilder。

RequestBuilder requestBuilder = new RequestBuilder(requestMethod, url); 
requestBuilder.setHeader("Content-Type", "application/json");
requestBuilder.setRequestData(bodyString);
requestBuilder.setCallback(new RequestCallback() {

      @Override
      public void onResponseReceived(Request request, Response response) {
        callback.onResponse(response.getStatusCode(), response.getText());
      }

      @Override
      public void onError(Request request, Throwable exception) {
        callback.onError(new Exception(exception));
      }
    });

    try {
      requestBuilder.send();
    }
    catch(RequestException ex) {
      callback.onError(ex);
    }

使用RequestBuilder时，您可以更好地控制格式和传输内容。

GWT请求有效负载理解

2 个答案: