Java 从AsyncTask类返回数据

如何从异步任务中获取数据？我的MainActivity正在调用触发AsyncTask的DataCall.getJSON函数，但我不确定如何将数据返回到原始活动

调用DataCall的MainActivity，该调用应返回字符串并将其保存在

状态\u data

String state_data =  DataCall.getJSON(spinnerURL,spinnerContentType); 

DataCall:

public class DataCall extends Activity {
    private static final String TAG = "MyApp";


    private class DownloadWebPageTask extends AsyncTask<String, Void, String> {


        protected String doInBackground(String... urls) {
            String response = "";
            for (String url : urls) {
                DefaultHttpClient client = new DefaultHttpClient();
                HttpGet httpGet = new HttpGet(url);
                try {
                    HttpResponse execute = client.execute(httpGet);
                    InputStream content = execute.getEntity().getContent();

                    BufferedReader buffer = new BufferedReader(
                            new InputStreamReader(content));
                    String s = "";
                    while ((s = buffer.readLine()) != null) {
                        response += s;
                    }

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


        protected void onPostExecute(String result) {
            //THIS IS WHERE I NEED TO RETURN MY DATA TO THE MAIN ACTIVITY. (I am guessing)
        }

        }

    public void getJSON(String myUrlString, String contentType) {
        DownloadWebPageTask task = new DownloadWebPageTask();
        task.execute(new String[] { "http://www.mywebsite.com/" + myUrlString });

    }

}

公共类数据调用扩展活动{
私有静态最终字符串TAG=“MyApp”；
私有类下载WebPagetTask扩展异步任务{
受保护的字符串doInBackground（字符串…URL）{
字符串响应=”；
for（字符串url:url）{
DefaultHttpClient=新的DefaultHttpClient（）；
HttpGet HttpGet=新的HttpGet（url）；
试一试{
HttpResponse execute=client.execute（httpGet）；
InputStream内容=execute.getEntity（）.getContent（）；
BufferedReader buffer=新的BufferedReader(
新的InputStreamReader（内容））；
字符串s=“”；
而（（s=buffer.readLine（））！=null）{
响应+=s；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
返回响应；
}
受保护的void onPostExecute（字符串结果）{
//这就是我需要将数据返回到主活动的地方。（我猜）
}
}
public void getJSON（字符串myUrlString，字符串contentType）{
DownloadWebPagetTask=新建DownloadWebPagetTask（）；
task.execute（新字符串[]{”http://www.mywebsite.com/“+myUrlString}）；
}
}

将其序列化，然后读取。我知道的唯一方法是。

尽管我不同意为这个简单的任务创建一个新的活动

startActivityForResult()

从另一个活动获取数据

检查。您可以将您的数据存储到Intent的extras中。但是，如果您有大量数据，最好将其写入一个文件，从下载完成的其他活动中获取结果，然后读取该文件。

一些选项：

a） 使您的bean实现可序列化的接口，然后您可以通过Intent传递bean

---

b） 实现

Application

接口（您需要在清单中创建一个条目），在应用程序类中使用setter\getter方法。您可以从

AsyncTask

在应用程序中设置bean，然后从活动中检索。

修改

AsyncTask

，如下所示：

public class GetData extends AsyncTask<String, Void, String>
{
    DataDownloadListener dataDownloadListener;
    public GetData()
    {
        //Constructor may be parametric 
    }
    public void setDataDownloadListener(DataDownloadListener dataDownloadListener) {
        this.dataDownloadListener = dataDownloadListener;
    }
    @Override
    protected Object doInBackground(Object... param) 
    {
        // do your task...
        return null;
    }
    @Override
    protected void onPostExecute(Object results)
    {       
        if(results != null)
        {               
        dataDownloadListener.dataDownloadedSuccessfully(results);
        }
        else
        dataDownloadListener.dataDownloadFailed();
    }
    public static interface DataDownloadListener {
        void dataDownloadedSuccessfully(Object data);
        void dataDownloadFailed();
    }
}

---

注意：对于正在阅读此文章的人

---

请考虑这是最好的，也许是正确的实现。

< P>我的关键是创建一个名为URLWordPARAMS的类或某些东西，因为AssicTebug将只允许发送1种类型，并且我需要URL和PARAMs用于HTTP请求。

public class URLWithParams {

    public String url;
    public List<NameValuePair> nameValuePairs;

    public URLWithParams()
    {
        nameValuePairs = new ArrayList<NameValuePair>();
    }
}

公共类URLWithParams{
公共字符串url；
公开名单；
公共URLWithParams（）
{
nameValuePairs=新的ArrayList（）；
}
}

然后我将其发送到JSONClient：

public class JSONClient extends AsyncTask<URLWithParams, Void, String> {
    private final static String TAG = "JSONClient";

    ProgressDialog progressDialog ;
    GetJSONListener getJSONListener;
    public JSONClient(GetJSONListener listener){
        this.getJSONListener = listener;
    }

    @Override
    protected String doInBackground(URLWithParams... urls) {
        return connect(urls[0].url, urls[0].nameValuePairs);
    }

    public static String connect(String url, List<NameValuePair> pairs)
    {
        HttpClient httpclient = new DefaultHttpClient();

        if(url == null)
        {
            Log.d(TAG, "want to connect, but url is null");
        }
        else
        {
            Log.d(TAG, "starting connect with url " + url);
        }

        if(pairs == null)
        {
            Log.d(TAG, "want to connect, though pairs is null");
        }
        else
        {
            Log.d(TAG, "starting connect with this many pairs: " + pairs.size());
            for(NameValuePair dog : pairs)
            {
                Log.d(TAG, "example: " + dog.toString());
            }
        }

        // Execute the request
        HttpResponse response;
        try {
            // Prepare a request object
            HttpPost httpPost = new HttpPost(url); 
            httpPost.setEntity(new UrlEncodedFormEntity(pairs));
            response = httpclient.execute(httpPost);
            // Examine the response status
            Log.i(TAG,response.getStatusLine().toString());

            BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent(), "UTF-8"));
            String json = reader.readLine();
            return json;

        } catch (ClientProtocolException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }



    @Override
    protected void onPostExecute(String json ) {
        getJSONListener.onRemoteCallComplete(json);
    }


    public interface GetJSONListener {
        public void onRemoteCallComplete(String jsonFromNet);
    }

}

public类JSONClient扩展了异步任务{
私有最终静态字符串TAG=“JSONClient”；
进行对话进行对话；
GetJSONListener GetJSONListener；
公共JSONClient（GetJSONListener侦听器）{
this.getJSONListener=listener；
}
@凌驾
受保护的字符串doInBackground（URLWithParams…URL）{
返回连接（url[0].url，url[0].nameValuePairs）；
}
公共静态字符串连接（字符串url、列表对）
{
HttpClient HttpClient=新的DefaultHttpClient（）；
如果（url==null）
{
d（标记“想要连接，但url为空”）；
}
其他的
{
Log.d（标记“开始连接url”+url）；
}
if（pairs==null）
{
d（标记“虽然pairs为null，但想要连接”）；
}
其他的
{
Log.d（标记“开始连接这么多对：“+pairs.size（）”）；
for（NameValuePair狗：对）
{
Log.d（标记，“示例：+dog.toString（））；
}
}
//执行请求
HttpResponse响应；
试一试{
//准备一个请求对象
HttpPost HttpPost=新的HttpPost（url）；
setEntity（新的UrlEncodedFormEntity（对））；
response=httpclient.execute（httpPost）；
//检查响应状态
Log.i（标记，response.getStatusLine（）.toString（））；
BufferedReader=新的BufferedReader（新的InputStreamReader（response.getEntity（）.getContent（），“UTF-8”）；
字符串json=reader.readLine（）；
返回json；
}捕获（客户端协议例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回null；
}
@凌驾
受保护的void onPostExecute（字符串json）{
onRemoteCallComplete（json）；
}
公共接口GetJSONListener{
公共void onRemoteCallComplete（字符串jsonFromNet）；
}
}

然后从我的主课上这样叫它

public class BookCatalog implements GetJSONListener {
    private final String TAG = this.getClass().getSimpleName();

    private String catalog_url = "URL";

    private void getCatalogFromServer() {

        URLWithParams mURLWithParams = new URLWithParams();
        mURLWithParams.url = catalog_url;

        try {
            JSONClient asyncPoster = new JSONClient(this);
            asyncPoster.execute(mURLWithParams);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void onRemoteCallComplete(String jsonBookCatalogList) {

        Log.d(TAG, "received json catalog:");
        Log.d(TAG, jsonBookCatalogList);
    JSONObject bookCatalogResult;
    try {
        bookCatalogResult = (JSONObject) new JSONTokener(jsonBookCatalogList).nextValue();
        JSONArray books = bookCatalogResult.getJSONArray("books");

        if(books != null) {
            ArrayList<String> newBookOrdering = new ArrayList<String>();
            int num_books = books.length();
            BookCatalogEntry temp;

            DebugLog.d(TAG, "apparently we found " + Integer.toString(num_books) + " books.");
            for(int book_id = 0; book_id < num_books; book_id++) {
                JSONObject book = books.getJSONObject(book_id);
                String title = book.getString("title");
                int version = book.getInt("price");
            }
        }

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

    }


}

public类BookCatalog实现GetJSONListener{
私有最终字符串标记=this.getClass（）.getSimpleName（）；
私有字符串目录\u url=“url”；
私有void getCatalogFromServer（）{
URLWithParams mURLWithParams=新的URLWithParams（）；
mURLWithParams.url=目录\ url；
试一试{
JSONClient asyncPoster=新的JSONClient（此）；
asyncPoster.execute（mURLWithParams）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
public class BookCatalog implements GetJSONListener {
    private final String TAG = this.getClass().getSimpleName();

    private String catalog_url = "URL";

    private void getCatalogFromServer() {

        URLWithParams mURLWithParams = new URLWithParams();
        mURLWithParams.url = catalog_url;

        try {
            JSONClient asyncPoster = new JSONClient(this);
            asyncPoster.execute(mURLWithParams);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void onRemoteCallComplete(String jsonBookCatalogList) {

        Log.d(TAG, "received json catalog:");
        Log.d(TAG, jsonBookCatalogList);
    JSONObject bookCatalogResult;
    try {
        bookCatalogResult = (JSONObject) new JSONTokener(jsonBookCatalogList).nextValue();
        JSONArray books = bookCatalogResult.getJSONArray("books");

        if(books != null) {
            ArrayList<String> newBookOrdering = new ArrayList<String>();
            int num_books = books.length();
            BookCatalogEntry temp;

            DebugLog.d(TAG, "apparently we found " + Integer.toString(num_books) + " books.");
            for(int book_id = 0; book_id < num_books; book_id++) {
                JSONObject book = books.getJSONObject(book_id);
                String title = book.getString("title");
                int version = book.getInt("price");
            }
        }

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

    }


}