Java Android异步任务重用

我正在开发一个应用程序，在许多活动中，我需要通过Http检索数据。 一旦有了数据，我就在onPostExecute（）回调方法中处理它

如果我将异步任务定义为一个内联类，那么这很好，但是由于我想在许多活动中执行相同的处理，所以我将它定义为一个外部类

所以问题是，使用外部类如何向调用类发送“事件”信号，作为返回数据的一种方式。我知道如何在C语言中实现这一点，但我对Java还不熟悉，不知道如何实现这一点。

一种方法：

定义一个名为

ParentActivity

（当然是扩展活动）的父抽象类。包含名为

onAsyncCallback（）的抽象方法

让每个使用任务的类扩展该类并实现该方法

在AsyncTask构造函数中，让它在父活动中接受

乙二醇

在
onPostExecute（）
中完成时，只需执行

activity.onAsyncCallback(data);

这也适用于接口，它做同样的事情，除了在侦听器实例中有构造函数接受的intead之外。
使用侦听器模式。看看这里，虽然听众在技术上是正确的，但我认为这要么太复杂，要么不够复杂

这里有一个更简单的解决方案：

class Foo {
   class Bar extends AsyncTask<Void, Void, Result> {

      public void onPostExecute(Result res) {
         doSomething(res);
      }
   }

   public void doSomething(Result res) {
      /// process result
   }

   public void startTask() {
       new Bar().execute();
   }
}

class-Foo{
类栏扩展了异步任务{
PostExecute上的公共void（Result res）{
剂量测定法（res）；
}
}
公共无效剂量测定（结果res）{
///过程结果
}
公共无效startTask（）{
新建条（）.execute（）；
}
}

相当于：

class Bar extends AsyncTask<Void, Void, Result> {
     private final Foo foo;
     public Bar(Foo foo) { this.foo = foo; }

     public void onPostExecute(Result res) {
       foo.doSomething(res);
     }
}


class Foo {
   public void doSomething(Result res) {
      /// process result
   }

   public void startTask() {
       new Bar(this).execute();
   }
}

类栏扩展了异步任务{
私人决赛福福；
公共酒吧（Foo-Foo）{this.Foo=Foo；}
PostExecute上的公共void（Result res）{
食物剂量测定法（res）；
}
}
福班{
公共无效剂量测定（结果res）{
///过程结果
}
公共无效startTask（）{
新建条（this.execute（）；
}
}

。。。这就是您要问的：当您拉出内部类时，您将丢失隐式指针。把它说清楚，然后把它传进去

坏消息是，这种解决方案会导致各种内存泄漏和生命周期问题。我非常建议，在您的程序变得更大之前，您考虑使用IntentService而不是AsyncTask，并使用处理程序或Activity.runOnUiThread将结果返回到UI线程。
尝试创建自己的http请求类来扩展AsyncTask，然后将代码放入其中“doInBackground”调用。这是一种只需使用url和参数实例化类并读取响应的方法。这对我很有用

下面是一个例子：

public class HttpRequest extends AsyncTask<String, Void, String> {
    public String url;
    public List<NameValuePair> nameValuePairs;
    public String httpResponse =null;

    public HttpRequest(String _url, List<NameValuePair> _nameValuePairs) {
        url = _url;
        nameValuePairs=_nameValuePairs;
    }

    @Override
    protected String doInBackground(String... params) {
        httpResponse = getWebPageWithFormData(url, nameValuePairs);
        return "";
    }

    public static String getWebPageWithFormData( String url, List<NameValuePair> nameValuePairs ){
        String html = "";
        HttpClient httpclient = new DefaultHttpClient();
        HttpPost httppost = new HttpPost(url);
        if (nameValuePairs!=null){
            try {httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));}
            catch (Exception e){}
        }
        HttpResponse response = null;
        try {
            response = httpclient.execute(httppost);
        }
        catch (ClientProtocolException e) { return ""; }
        catch (IOException e) { return ""; }
        int responseCode = response.getStatusLine().getStatusCode();
        switch(responseCode) {
            case 200:
                HttpEntity entity = response.getEntity();
                if(entity != null) {
                    try{ html = EntityUtils.toString(entity);}
                    catch (Exception e) {}
                }
                break;
        }
        return html;
    }
}

公共类HttpRequest扩展异步任务{
公共字符串url；
公开名单；
公共字符串httpResponse=null；
公共HttpRequest（字符串url，列表nameValuePairs）{
url=url；
nameValuePairs=\u nameValuePairs；
}
@凌驾
受保护的字符串doInBackground（字符串…参数）{
httpResponse=getWebPageWithFormData（url、nameValuePairs）；
返回“”；
}
公共静态字符串getWebPageWithFormData（字符串url、列表名称值对）{
字符串html=“”；
HttpClient HttpClient=新的DefaultHttpClient（）；
HttpPost HttpPost=新的HttpPost（url）；
if（nameValuePairs！=null）{
请尝试{httppost.setEntity（新的UrlEncodedFormEntity（nameValuePairs））；}
捕获（例外e）{}
}
HttpResponse响应=null；
试一试{
response=httpclient.execute（httppost）；
}
catch（ClientProtocolException e）{return”“；}
catch（ioe）{return”“；}
int responseCode=response.getStatusLine（）.getStatusCode（）；
开关（响应代码）{
案例200：
HttpEntity=response.getEntity（）；
如果（实体！=null）{
试试{html=EntityUtils.toString（entity）；}
捕获（例外e）{}
}
打破
}
返回html；
}
}
如果您想以干净的方式完成，请尝试以下方法

首先创建一个包含所有异步调用名的枚举

public enum TaskType {
    USER_LOGIN(1), GET_PRODUCTS(2), GET_EMPLOYEE(3);

    int value;

    private TaskType(int value) {
        this.value = value;
    }
}

然后创建一个接口

public interface AsyncTaskListener {
    public void onTaskCompleted(String result, TaskType taskType);
}

现在在要调用GetAsyncTask的活动中实现此接口
例如：-

最后，这是您的任务

public class GetAsyncTask extends AsyncTask<String, Void, String> {
    String outputStr;
    ProgressDialog dialog;
    Context context;
    AsyncTaskListener taskListener;
    TaskType taskType;

    public GetAsyncTask(Context context, AsyncTaskListener taskListener, TaskType taskType){
        this.context = context;
        this.taskListener = taskListener;
        this.taskType = taskType;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        dialog = ProgressDialog.show(context, "Loading", "Please wait...", true);
    }
    @Override
    protected String doInBackground(String... params) {
        String urlString = params[0];

        try {

            URL url = new URL(urlString);
            HttpURLConnection conn
                    = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(5000);
            if (conn.getResponseCode() != 200) {
                throw new IOException(conn.getResponseMessage());
            }

            // Buffer the result into a string
            BufferedReader rd = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = rd.readLine()) != null) {
                sb.append(line);
            }
            rd.close();
            conn.disconnect();
            String jsonStr = sb.toString();
            outputStr = jsonStr;
        } catch (SocketTimeoutException e) {
            outputStr = "timeout";
        }catch(Exception e){
            e.printStackTrace();
            outputStr = "error";
        }

        return outputStr;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        taskListener.onTaskCompleted(result, taskType);
        dialog.dismiss();
    }

}

公共类GetAsyncTask扩展了AsyncTask{
字符串输出str；
进程对话；
语境；
异步任务监听器；
任务类型任务类型；
公共GetAsyncTask（上下文上下文、AsyncTaskListener taskListener、TaskType TaskType）{
this.context=上下文；
this.taskListener=taskListener；
this.taskType=taskType；
}
@凌驾
受保护的void onPreExecute（）{
super.onPreExecute（）；
dialog=ProgressDialog.show（上下文，“正在加载”，“请稍候…”，true）；
}
@凌驾
受保护的字符串doInBackground（字符串…参数）{
字符串urlString=params[0]；
试一试{
URL=新URL（URL字符串）；
HttpUrl连接连接
=（HttpURLConnection）url.openConnection（）；
连接设置连接超时（5000）；
如果（连接getResponseCode（）！=200）{
抛出新IOException（conn.getResponseMessage（））；
}
//将结果缓冲到字符串中
BufferedReader rd=新的BufferedReader(
新的InputStreamReader（conn.getInputStream（））；
StringBuilder sb=新的StringBuilder（）；
弦线；
而（（line=rd.readLine（））！=null）{
某人附加（行）；
}
rd.close（）；
连接断开（）；
字符串jsonStr=sb.toString（）；
 public class LoginActivity extends Activity implements AsyncTaskListener {

 protected void onCreate(Bundle savedInstanceState) {
     String url = ".....";
     new GetAsyncTask(LoginActivity.this, LoginActivity.this, TaskType.USER_LOGIN).execute(url);
 }
    ...
    public void onTaskCompleted(String result, TaskType taskType) {
       if(taskType == TaskType.USER_LOGIN){
       //your login result handling here
       }
}

public class GetAsyncTask extends AsyncTask<String, Void, String> {
    String outputStr;
    ProgressDialog dialog;
    Context context;
    AsyncTaskListener taskListener;
    TaskType taskType;

    public GetAsyncTask(Context context, AsyncTaskListener taskListener, TaskType taskType){
        this.context = context;
        this.taskListener = taskListener;
        this.taskType = taskType;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        dialog = ProgressDialog.show(context, "Loading", "Please wait...", true);
    }
    @Override
    protected String doInBackground(String... params) {
        String urlString = params[0];

        try {

            URL url = new URL(urlString);
            HttpURLConnection conn
                    = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(5000);
            if (conn.getResponseCode() != 200) {
                throw new IOException(conn.getResponseMessage());
            }

            // Buffer the result into a string
            BufferedReader rd = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()));
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = rd.readLine()) != null) {
                sb.append(line);
            }
            rd.close();
            conn.disconnect();
            String jsonStr = sb.toString();
            outputStr = jsonStr;
        } catch (SocketTimeoutException e) {
            outputStr = "timeout";
        }catch(Exception e){
            e.printStackTrace();
            outputStr = "error";
        }

        return outputStr;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        taskListener.onTaskCompleted(result, taskType);
        dialog.dismiss();
    }

}