Java 使用AsyncTask创建回调函数

我创建了一个AsyncTask类来处理服务器的发送和接收。我试图做的是在收到数据时触发一个事件或回调，这样我就可以使用所说的数据来操作UI

异步任务类：

public class DataCollectClass extends AsyncTask<Object, Void, JSONObject> {
    private JSONObject collected;

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    //@Override -Commented out because it doesn't like the override
    protected void onPostExecute() {
        try {
            Log.d("Net", this.collected.getString("message"));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected JSONObject doInBackground(Object... params) {
        OkHttpClient client = new OkHttpClient();

        // Get Parameters //
        String requestURI = (String) params[0];
        RequestBody formParameters = (RequestBody) params[1];
        Request request = new Request.Builder().url(requestURI).post(formParameters).build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                // DO something on FAIL
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String jsonResponse = response.body().string();
                Log.d("Net", jsonResponse);
                try {
                    DataCollectClass.this.collected = new JSONObject(jsonResponse);
                    Log.d("Net", DataCollectClass.this.collected.getString("message"));
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        });

        return collected;
    }
}

我已经看遍了所有地方，但似乎找不到关于如何（以及在哪里）添加回调的明确答案。回调代码本身最好与

DataCollectClass

一起使用，这样所有相关代码都可以在同一个地方重用

有没有一种方法可以创建程序可以侦听的自定义事件触发（类似于Javascript库）

我一直在为这件事发脾气

更新：

由于AsyncTask是冗余的，我已将其删除并重新编写了代码（以防其他人有相同的问题）：

公共类DataCollectClass{ 收集私有JSONObject

    public interface OnDataCollectedCallback {
        void onDataCollected(JSONObject data);
    }

    private OnDataCollectedCallback mCallback;

    public DataCollectClass(OnDataCollectedCallback callback, String requestURI, RequestBody formParameters){
        mCallback = callback;
        this.collect(requestURI, formParameters);
    }

    public JSONObject collect(String requestURI, RequestBody formParameters) {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder().url(requestURI).post(formParameters).build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                //TODO Add what happens when shit fucks up...
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String jsonResponse = response.body().string();
                Log.d("Net", jsonResponse);
                try {
                    DataCollectClass.this.collected = new JSONObject(jsonResponse);

                    if(mCallback != null)
                        mCallback.onDataCollected(DataCollectClass.this.collected);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        });
        return collected;
    }
}

从活动中调用：

new DataCollectClass(new DataCollectClass.OnDataCollectedCallback() {
    @Override
    public void onDataCollected(JSONObject data) {
        if(data != null) {
            try {
                // Do Something //
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }
}, requestURI, formVars);

一切都很好！

---

谢谢！

如果您想利用回调处理异步任务，您可以通过以下方式处理它

执行类似操作（修改代码以添加以下内容）

然而，值得注意的是，

大多数网络库，包括OkHttp，都在内部处理后台线程，并包含回调以用于请求。

这还实现了一个自定义接口，因此其他人可以看到您如何将其用于任何异步任务。

有一个，因此您不需要异步任务，但作为一个学习练习，您可以将回调定义为类似这样的参数

new DataCollectClass(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                // DO something on FAIL
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                JSONObject collected = null;
                String jsonResponse = response.body().string();
                Log.d("Callback - Net", jsonResponse);
                try {
                    collected = new JSONObject(jsonResponse);
                    Log.d("Callback - Net", collected.getString("message"));
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }).execute(requestURI, formVars);

异步任务

public class DataCollectClass extends AsyncTask<Object, Void, Call> {
    private Callback mCallback;
    private OkHttpClient client;

    public DataCollectClass(Callback callback) {
        this.mCallback = callback;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        this.client = new OkHttpClient();
    }

    @Override 
    protected void onPostExecute(Call response) {
        if (response != null && this.mCallback != null) {
            response.enqueue(this.mCallback);
        }
    }

    @Override
    protected Call doInBackground(Object... params) {

        // Get Parameters //
        String requestURI = (String) params[0];
        RequestBody formParameters = (RequestBody) params[1];
        Request request = new Request.Builder().url(requestURI).post(formParameters).build();

        return client.newCall(request); // returns to onPostExecute
    }
}

公共类DataCollectClass扩展异步任务{
专用回调mCallback；
私人Okhttp客户端；
公共DataCollectClass（回调）{
this.mCallback=回调；
}
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
this.client=new-OkHttpClient（）；
}
@凌驾
受保护的void onPostExecute（调用响应）{
if（response！=null&&this.mCallback！=null）{
response.enqueue（this.mCallback）；
}
}
@凌驾
受保护的调用doInBackground（对象…参数）{
//获取参数//
String requestURI=（字符串）参数[0]；
RequestBody formParameters=（RequestBody）参数[1]；
Request-Request=newrequest.Builder（）.url（requestURI.post（formParameters.build（））；
return client.newCall（request）；//返回onPostExecute
}
}

使用asynctask调用Web服务是一种老式方法。您可以使用截击或改装。 但您可以使用此过程调用Webservice。以下是步骤：

创建一个接口并在活动/片段中实现它

public interface IAsynchronousTask {
        public void showProgressBar();
        public void hideProgressBar();
        public Object doInBackground();
        public void processDataAfterDownload(Object data);
 }

创建类

DownloadableAsyncTask

。该类是：

import android.os.AsyncTask;
import android.util.Log;

public class DownloadableAsyncTask extends AsyncTask<Void, Void, Object> {

    IAsynchronousTask asynchronousTask;

    public DownloadableAsyncTask(IAsynchronousTask activity) {
        this.asynchronousTask = activity;
    }

    @Override
    protected void onPreExecute() {
        if (asynchronousTask != null)
            asynchronousTask.showProgressBar();
    }

    @Override
    protected Object doInBackground(Void... params) {
        try {
            if (asynchronousTask != null) {
                return asynchronousTask.doInBackground();
            }
        } catch (Exception ex) {
            Log.d("BSS", ex.getMessage()==null?"":ex.getMessage());
        }
        return null;
    }

    @Override
    protected void onPostExecute(Object result) {
        if (asynchronousTask != null) {
            asynchronousTask.hideProgressBar();
            asynchronousTask.processDataAfterDownload(result);
        }
    }

}

---

现在只需调用

loadInformation（）

方法，就可以在

processDataAfterDownload（）上得到响应

如果您使用的是OkHttp，则不需要AsyncTask。如果您想删除AsyncTask，则Volley或Reform更适合处理JSON数据。请再次检查。

DataCollectClass。此.collected

无法在活动内部工作。@cricket\u 007我刚刚复制了他的代码，今天很懒：p我将修复它谢谢你，我也是：）总的来说，我认为如果AsyncTask的需求与Okhttp冲突，你不必将AsyncTask与改装Call.enqueue（）一起使用方法默认情况下它在后台线程上运行。@Mike应该b

OnDataCollectedCallback

而不是

OnDataCollectedListener

，这是一个打字错误，已被修复。感谢此答案更适合于此特定问题；它显示了如何正确使用提供的回调。

public class DataCollectClass extends AsyncTask<Object, Void, Call> {
    private Callback mCallback;
    private OkHttpClient client;

    public DataCollectClass(Callback callback) {
        this.mCallback = callback;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        this.client = new OkHttpClient();
    }

    @Override 
    protected void onPostExecute(Call response) {
        if (response != null && this.mCallback != null) {
            response.enqueue(this.mCallback);
        }
    }

    @Override
    protected Call doInBackground(Object... params) {

        // Get Parameters //
        String requestURI = (String) params[0];
        RequestBody formParameters = (RequestBody) params[1];
        Request request = new Request.Builder().url(requestURI).post(formParameters).build();

        return client.newCall(request); // returns to onPostExecute
    }
}

public interface IAsynchronousTask {
        public void showProgressBar();
        public void hideProgressBar();
        public Object doInBackground();
        public void processDataAfterDownload(Object data);
 }

import android.os.AsyncTask;
import android.util.Log;

public class DownloadableAsyncTask extends AsyncTask<Void, Void, Object> {

    IAsynchronousTask asynchronousTask;

    public DownloadableAsyncTask(IAsynchronousTask activity) {
        this.asynchronousTask = activity;
    }

    @Override
    protected void onPreExecute() {
        if (asynchronousTask != null)
            asynchronousTask.showProgressBar();
    }

    @Override
    protected Object doInBackground(Void... params) {
        try {
            if (asynchronousTask != null) {
                return asynchronousTask.doInBackground();
            }
        } catch (Exception ex) {
            Log.d("BSS", ex.getMessage()==null?"":ex.getMessage());
        }
        return null;
    }

    @Override
    protected void onPostExecute(Object result) {
        if (asynchronousTask != null) {
            asynchronousTask.hideProgressBar();
            asynchronousTask.processDataAfterDownload(result);
        }
    }

}

DownloadableAsyncTask downloadAsyncTask;
ProgressDialog dialog;
    private void loadInformation() {
            if (downloadAsyncTask != null)
                downloadAsyncTask.cancel(true);
            downloadAsyncTask = new DownloadableAsyncTask(this);
            downloadAsyncTask.execute();

        }

        @Override
        public void showProgressBar() {
            dialog = new ProgressDialog(this, ProgressDialog.THEME_HOLO_LIGHT);
            dialog.setMessage(" Plaese wait...");
            dialog.setCancelable(false);
            dialog.show();

        }

        @Override
        public void hideProgressBar() {
            dialog.dismiss();

        }

        @Override
        public Object doInBackground() {
            // Call your Web service and return value

        }

        @Override
        public void processDataAfterDownload(Object data) {
            if (data != null) {
                // data is here
            }else{
                //"Internal Server Error!!!"
            }

        }