在另一个完成后执行 Volley 请求

Question

我有两个 Volley 请求。第一个请求对用户进行身份验证；第二个从服务器获取数据。

如果我发送 GET 请求但用户未通过身份验证，我想触发第一个请求，对用户进行身份验证，然后在用户身份验证成功后继续执行第二个请求。

Answer 1

因此，解决方案非常简单。 :)

在了解了回调及其工作原理后，我明白了该怎么做。所以，我实现了一个接口，声明了我想调用的方法：

public interface AuthenticationCallback {

    public void onLoginSuccess(String result);

    public void onLoginError(String result);
}

public interface ResponseCallback {

    public void onLoginSuccess(String result);

    public void onAuthorizationError(String result);

}

我的函数：

public void getConversationMessages(final Context context, final String conversationID, final ResponseCallback responseCallback) {

        final String url = GET_CONVERSATION_MESSAGES + conversationID;

        StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        if (responseCallback != null) {
                            responseCallback.onLoginSuccess(response);
                        }
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {    
                if (error.networkResponse != null && error.networkResponse.statusCode == HttpURLConnection.HTTP_UNAUTHORIZED){
                    if (responseCallback != null) {
                        responseCallback.onAuthorizationError(error.getMessage());
                    }
                }
            }
        })
        {
            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap<String, String> headers = new HashMap<String, String>();
                headers.put("Cookie", AppSingleton.getInstance(context).getCookie());
                headers.put("Content-Type", "application/json");
                return headers;
            }
        };

        AppSingleton.getInstance(context).getRequestQueue().add(stringRequest);
    }
}

我的Activity:

ServerConnection.getInstance().getConversationMessages(getApplicationContext(), id, new ResponseCallback() {
            @Override
            public void onLoginSuccess(String result) {

            }

            @Override
            public void onAuthorizationError(String result) {

                ServerConnection.getInstance().loginFunction(getApplicationContext(), userID, new AuthenticationCallback() {
                    @Override
                    public void onLoginSuccess(String result) {
                        ServerConnection.getInstance().getConversationMessages(getApplicationContext(), conID, new ResponseCallback() {
                            @Override
                            public void onLoginSuccess(String result) {

                            }

                            @Override
                            public void onAuthorizationError(String result) {

                            }
                        });
                    }
                    @Override
                    public void onLoginError(String result) {

                    }
                });
            }
        });

基本上，代码会尝试发送 GET 请求。如果用户未通过身份验证，则它将执行 onAuthorizationError() 处的代码，这将对用户进行身份验证。一旦用户成功验证，它将再次发送 GET 请求。

我认为像这样嵌套回调不是一个好的做法，但我稍后会修复它并更新我的答案。

如果有人有更好的实现方式，请post另一个答案！

Answer 2

您可以将一个 volley 方法放在另一个方法中，一旦第一个请求完成，它就会发送另一个 request.By 这样做，数据将被发送到数据库，并且可以再次获取相同的修改数据. 代码如下图

StringRequest stringRequest = new StringRequest(Request.Method.POST, "YOUR_FIRST_URL", new Response.Listener < String > () {
      @Override
      public void onResponse(String response) {

        StringRequest stringRequests = new StringRequest(Request.Method.POST, "YOUR_SECOND_URL", new Response.Listener < String > () {
              @Override
              public void onResponse(String response) {

                try {
                  JSONArray genreArry = new JSONArray(response);


                }
              } catch (JSONException e) {
                e.printStackTrace();
              }

            }
          },
          new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

            }
          }) {
        @Override
        protected Map < String, String > getParams() {
          Map < String, String > params = new HashMap < String, String > ();

          return params;
        }
      };
      int socketTimeouts = 30000;
      RetryPolicy policys = new DefaultRetryPolicy(socketTimeouts, DefaultRetryPolicy.DEFAULT_MAX_RETRIES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
      stringRequests.setRetryPolicy(policys);
      RequestQueue requestQueues = Volley.newRequestQueue(context);
      requestQueues.add(stringRequests);


    }
  },
  new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {

    }
  }) {
  @Override
  protected Map < String, String > getParams() {
    Map < String, String > params = new HashMap < String, String > ();

    return params;
  }
};
int socketTimeout = 30000;
RetryPolicy policy = new DefaultRetryPolicy(socketTimeout, DefaultRetryPolicy.DEFAULT_MAX_RETRIES, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
stringRequest.setRetryPolicy(policy);
RequestQueue requestQueue = Volley.newRequestQueue(context);
requestQueue.add(stringRequest);

在另一个完成后执行 Volley 请求

Execute a Volley request after another one is finished

android

android-volley