如何使用AsyncTask

Question

异步任务问题

我已经学习了一些教程，但我仍然不清楚。这是我目前拥有的代码，代码下面有一些问题。MainActivity调用SomeClassWithHTTPNeeds，然后调用JSONParser（异步任务

主要活动：

String station = SomeClassWithHTTPNeeds.getInstance().getStation(123);

一些具有HTTP需求的类：

getStation {

JSONParser = new JSONParser();
JSONObject station = parser.getJSONFromUrl("https://api....");
return JSONObject.getString("station");
}

JSONParser（异步任务

protected String doInBackground(); ==> Seperate thread
protected void onPostExecute(); ==> On GUI thread

我在想：---把HTTPRequest放在doInBackground（）中；

问题是我不知道如何：让JSONParser将JSONObject返回给getStation方法？

我需要知道的

=

=

=

非常感谢！

Answer 1

我认为您可以在异步任务的后台执行您的HTTPRequest。和JSONParser在onPostExecute处。

Answer 2

package com.example.jsontest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONObject;
import android.util.Log;

public class HttpClient {
    private static final String TAG = "HttpClient";

    public static JSONObject SendHttpPost(String URL, JSONObject jsonObjSend) {

        try {
            DefaultHttpClient httpclient = new DefaultHttpClient();
            HttpPost httpPostRequest = new HttpPost(URL);

            StringEntity se;
            se = new StringEntity(jsonObjSend.toString());

            httpPostRequest.setEntity(se);
            httpPostRequest.setHeader("Accept", "application/json");
            httpPostRequest.setHeader("Content-type", "application/json");
            httpPostRequest.setHeader("Accept-Encoding", "gzip"); 

            long t = System.currentTimeMillis();
            HttpResponse response = (HttpResponse) httpclient.execute(httpPostRequest);
            Log.i(TAG, "HTTPResponse received in [" + (System.currentTimeMillis()-t) + "ms]");

            HttpEntity entity = response.getEntity();

            if (entity != null) {
                InputStream instream = entity.getContent();
                Header contentEncoding = response.getFirstHeader("Content-Encoding");
                if (contentEncoding != null && contentEncoding.getValue().equalsIgnoreCase("gzip")) {
                    instream = new GZIPInputStream(instream);
                }

                String resultString= convertStreamToString(instream);
                instream.close();
                resultString = resultString.substring(0,resultString.length()-1); 

                JSONObject jsonObjRecv = new JSONObject(resultString);
                Log.i(TAG,"<JSONObject>\n"+jsonObjRecv.toString()+"\n</JSONObject>");

                return jsonObjRecv;
            } 

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }


    private static String convertStreamToString(InputStream is) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
                Log.e("JSON", ""+line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }

}

异步任务：

公共类callCarWeb扩展了AsyncTask{

    @Override
    protected void onPreExecute() {
        mDialog = new ProgressDialog(MainActivity.this);
        mDialog.setMessage("Please wait...");
        mDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        mDialog.setIndeterminate(true);
        mDialog.setCancelable(false);
        mDialog.show();

    }

    @Override
    protected Void doInBackground(Void... params) {

        try {
            JSONObject jsonObjSend = new JSONObject();
            jsonObjSend.put("username", username);
            jsonObjSend.put("password", passwd);
            Log.e("SEND", jsonObjSend.toString());
            JSONObject json = HttpClient.SendHttpPost("http://10.0.2.2/json/login.php", jsonObjSend);
            String status = json.getString("status");
            if(status.equalsIgnoreCase("pass")){
                String id = json.getString("user_id");
                Log.e("id", id);
                String name = json.getString("name");
                Log.e("name", name);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }



        return null;

}

    @Override
    protected void onPostExecute(Void result) {
        mDialog.cancel();
    }

}##标题##

Answer 3

=

通常，您应该在单独的线程中执行网络操作-

=

通常，AsyncTask类看起来是这样的，它只不过是一个具有3种不同泛型类型的泛型类：

AsyncTask<Params, Progress, Result>

您可以指定AsyncTask采用的参数类型、进度指示器的类型和结果的类型（doInBackGround（）的返回类型）。

下面是一个异步任务的示例，如下所示：

AsyncTask<String, Integer, Long>

参数的类型为String，进度的类型为Integer，结果的类型为Long（返回类型为doInBackground（））。您可以为参数、进度和结果使用任何类型。

private class DownloadFilesTask extends AsyncTask<String, Integer, Long> {

 // these Strings / or String are / is the parameters of the task, that can be handed over via the excecute(params) method of AsyncTask
 protected Long doInBackground(String... params) {

    String param1 = params[0];
    String param2 = params[1];
    // and so on...
    // do something with the parameters...
    // be careful, this can easily result in a ArrayIndexOutOfBounds exception
    // if you try to access more parameters than you handed over

    long someLong;
    int someInt;

    // do something here with params
    // the params could for example contain an url and you could download stuff using this url here

    // the Integer variable is used for progress
    publishProgress(someInt);

    // once the data is downloaded (for example JSON data)
    // parse the data and return it to the onPostExecute() method
    // in this example the return data is simply a long value
    // this could also be a list of your custom-objects, ...
    return someLong;
 }

 // this is called whenever you call puhlishProgress(Integer), for example when updating a progressbar when downloading stuff
 protected void onProgressUpdate(Integer... progress) {
     setProgressPercent(progress[0]);
 }

 // the onPostexecute method receives the return type of doInBackGround()
 protected void onPostExecute(Long result) {
     // do something with the result, for example display the received Data in a ListView
     // in this case, "result" would contain the "someLong" variable returned by doInBackground();
 }
}

=

在这种情况下，AsyncTask将String或String Array作为Parameter，一旦调用AsyncTask，它将如下所示：（指定的参数用于AsyncTask的执行（参数）方法）。

new DownloadFilesTask().execute("Somestring"); // some String as param

请注意，此调用没有返回值，您应该使用的唯一返回值是从doInBackground（）返回的返回值。使用onPostExecute（）方法确实可以使用返回的值。

还要小心这行代码：（此执行实际上会有一个返回值）

long myLong = new DownloadFilesTask().execute("somestring").get();

. get（）调用会导致UI线程在AsyncTask执行时被阻塞（因此如果操作花费的时间超过几毫秒，则UI会冻结），因为执行不会在单独的线程中进行。如果您删除对. get（）的调用，它将异步执行。

=

这是一个带有所谓的“varargs”（可变参数）参数的方法。为了简单起见，我只想说这意味着您可以通过此参数传递给方法的实际值数没有指定，您传递给方法的任何值量都将被视为方法内部的数组。因此，例如，此调用可能如下所示：

execute("param1");

但也可能是这样：

execute("param1", "param2");

或者更多参数。假设我们仍然在讨论异步任务，那么可以通过doInBackground（String…params）方法以这种方式访问参数：

 protected Long doInBackground(String... params) {

     String str1 = params[0];
     String str2 = params[1]; // be careful here, you can easily get an ArrayOutOfBoundsException

     // do other stuff
 }

您可以在此处阅读有关AsyncTask的更多信息：http://developer.android.com/reference/android/os/AsyncTask.html

还要看一下这个AsyncTask示例：https://stackoverflow.com/a/9671602/1590502