Question

我有一个严重的问题。

我有一家餐馆的小应用程序，用于管理订单的创建，更新等。服务员使用Android平板电脑为客户服务。

问题是，大约一个星期以来，我意识到门票倾向于重复物品。经过研究并深入研究日志，我意识到很多次，当我调用AsyncTask向服务器发送请求时，它不发送一个请求，而是发送了多个请求。因此，如果我四次调用“ addItemToOrder”服务，它将添加四项而不是仅仅一项。

这是我的代码。我称之为“通用GET异步任务”。它具有一个url，可能带有或不带有一些参数，并且它只是创建一个发送到服务器的截击请求。如您所见，它有0次重试，在您问之前，我只是确保不会多次调用该AT：

package es.vdevelop.tpvmobile.asynctask;

import android.content.Context;
import android.os.AsyncTask;
import android.os.Handler;
import android.widget.Toast;

import com.android.volley.DefaultRetryPolicy;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.bugfender.sdk.Bugfender;

import org.json.JSONException;

import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;

import es.vdevelop.tpvmobile.Constants;
import es.vdevelop.tpvmobile.ErrorHelper;
import es.vdevelop.tpvmobile.FunctionsHelper;


abstract class GenericGetAsyncTask extends AsyncTask<Void, Void, Void> {

    private static final String TAG = "DEBUG GenericGetAT";

    Handler h;
    WeakReference<Context> context;

    String auxURL;
    HashMap<String, String> postParams;
    String query;

    GenericGetAsyncTask(WeakReference<Context> context, Handler h) {
        this.auxURL = "";
        this.context = context;
        this.h = h;
        this.postParams = new HashMap<>();
        this.query = "";
    }


    @Override
    protected Void doInBackground(final Void... params) {
        if (!FunctionsHelper.isConnected(context.get())) {
            h.sendEmptyMessage(ErrorHelper.HANDLER_NO_INTERNET_ERROR);
            Bugfender.d(TAG, "No internet connection");
            ErrorHelper.mostrarError(context.get(), ErrorHelper.HANDLER_NO_INTERNET_ERROR, TAG);
            return null;
        }

        String urlParcial = Constants.getUrl(context.get());
        if (urlParcial.equals("")) {
            h.sendEmptyMessage(ErrorHelper.HANDLER_FALTA_URL);
            Bugfender.d(TAG, "Falta url");
            ErrorHelper.mostrarError(context.get(), ErrorHelper.HANDLER_URL_INCORRECTA, TAG);
            return null;
        }


        int metodo;
        String url;
        if (query == null || query.equals("")) {
            url = urlParcial + this.auxURL;
            metodo = Request.Method.POST;
        } else {
            url = urlParcial + this.auxURL + "?" + this.query;
            metodo = Request.Method.GET;
        }
        Bugfender.d(TAG, "url -> " + url);


        final RequestQueue queue = Volley.newRequestQueue(context.get());
        final StringRequest request = new StringRequest(metodo, url, new Response.Listener<String>() {

            @Override
            public void onResponse(String response) {
                try {
                    onResultRetrieved(response);
                } catch (JSONException e) {
                    Bugfender.d(TAG, "Hubo un error de json en onResponse -> " + e.toString());
                    h.sendEmptyMessage(ErrorHelper.HANDLER_RESPUESTA_INCORRECTA);
                    ErrorHelper.mostrarError(context.get(), ErrorHelper.HANDLER_JSON, TAG);
                }
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Bugfender.d(TAG, "Error recibido del servidor -> " + error.toString());
                ErrorHelper.mostrarError(context.get(), ErrorHelper.HANDLER_RESPUESTA_INCORRECTA, TAG);
                Toast.makeText(context.get(), "Error realizando llamada http -> " + error.toString(), Toast.LENGTH_SHORT).show();
                h.sendEmptyMessage(ErrorHelper.HANDLER_ERROR);
            }
        }) {
            @Override
            protected Map<String, String> getParams() {
                return postParams;
            }

            @Override
            public Priority getPriority() {
                return Priority.IMMEDIATE;
            }
        };
        request.setRetryPolicy(new DefaultRetryPolicy(2000, 0, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));

        queue.add(request);
        return null;
    }


    protected abstract void onResultRetrieved(String result) throws JSONException;
}

在那之后，我只需要从通用的AT中继承一些代码就可以进行简单的请求，就像您在此“ UpdateTicketAT”中看到的一样：

package es.vdevelop.tpvmobile.asynctask;

import android.content.Context;
import android.os.Handler;

import com.bugfender.sdk.Bugfender;

import org.json.JSONException;
import org.json.JSONObject;

import java.lang.ref.WeakReference;

import es.vdevelop.tpvmobile.Constants;
import es.vdevelop.tpvmobile.ErrorHelper;
import es.vdevelop.tpvmobile.Functions;


public class UpdateTicketAsyncTask extends GenericGetAsyncTask {

    private static final String TAG = "DEBUG UpdateTicketAT";

    public UpdateTicketAsyncTask(WeakReference<Context> context, Handler h, String json) {
        super(context, h);
        this.auxURL = "actualizar_ticket.php";
        this.postParams.put("ticket", json);
        Bugfender.d(TAG, "Ticket que vamos a enviar -> " + json);
    }


    @Override
    protected void onResultRetrieved(String response) throws JSONException {
        Bugfender.d(TAG, "Respuesta obtenida del servidor -> " + response);
        JSONObject result = new JSONObject(response);
        int codigo = result.getInt("codigo");
        if (codigo == 0) {
            h.sendEmptyMessage(Constants.handlerOk);
            Bugfender.d(TAG, "Ticket actualizado correctamente");
        } else {
            h.sendEmptyMessage(Constants.handlerError);
            ErrorHelper.mostrarError(context.get(), codigo, TAG);
        }
    }
}

我不知道这里发生了什么。难道我做错了什么？

重要的一点是，对服务器的调用可能不是连续进行的。我的意思是，我发出请求，得到响应，也许一两分钟后，再次发出请求！

通过查看服务器日志，我可以意识到这一点。

我不知道这里发生了什么。

无论如何，先谢谢！

Answer 1

我可以看到两种回答您问题的方法：

首先：我不喜欢您的DefaultRetryPolicy行中的“ 0”，请尝试输入以下内容：

jsonObjectRequest.setRetryPolicy（new DefaultRetryPolicy（TIMEOUT_SERVICE， DefaultRetryPolicy.DEFAULT_MAX_RETRIES，DefaultRetryPolicy.DEFAULT_BACKOFF_MULT））;

第一个参数是超时，第二个参数是最大重试次数（是的，我知道，您知道但是要检查是否为1），最后一个参数是DefaultRetryPolicy.DEFAULT_BACKOFF_MULT（我也知道，等等，但是请检查该值为1.0f）或直接输入文字。

jsonObjectRequest.setRetryPolicy（new DefaultRetryPolicy（TIMEOUT_SERVICE， 1，1.0f））;

第二：您只能在超时时间中设置更多时间吗？

希望对您有帮助。

排球执行了太多不受控制的重试

1 个答案: