Java 优雅地处理异常_Java_Android_Android Asynctask

Java 优雅地处理异常

java android

Java 优雅地处理异常,java,android,android-asynctask,Java,Android,Android Asynctask,我有一个函数，它发出http请求并解析响应json数据。该函数在AsyncTask类中调用。我定义了一个函数，用于在调用asynctask之前检查是否存在连接。但是一旦连接检查器函数返回true…我的函数在asynctask类中运行，并且设备失去连接，应用程序强制关闭 private void parseJson() { // HTTP request and JSON parsing done here } class getData extends AsyncTask <Vo

我有一个函数，它发出http请求并解析响应json数据。该函数在AsyncTask类中调用。我定义了一个函数，用于在调用asynctask之前检查是否存在连接。但是一旦连接检查器函数返回true…我的函数在asynctask类中运行，并且设备失去连接，应用程序强制关闭

private void parseJson()
{
    // HTTP request and JSON parsing done here
}

class getData extends AsyncTask <Void,Void,Void>
{


@Override
protected Void onPreExecute(Void...arg0)
{
    super.onPreExecute();
    //progress dialog invoked here
}

@Override
protected Void doInBackground(Void...arg0)
{
    parseJSON();
    return null;
}
@Override
protected Void onPostExecute(Void...arg0)
{
    super.onPostExecute();
    //UI manipulated here
}

}

private void parseJson（）
{
//HTTP请求和JSON解析在这里完成
}
类getData扩展异步任务
{
@凌驾
受保护的Void onPreExecute（Void…arg0）
{
super.onPreExecute（）；
//在此调用进度对话框
}
@凌驾
受保护的Void doInBackground（Void…arg0）
{
parseJSON（）；
返回null；
}
@凌驾
受保护的Void onPostExecute（Void…arg0）
{
super.onPostExecute（）；
//这里操纵的用户界面
}
}

由于doInBackground（）不允许触发toast消息之类的操作，因此如何通知用户doInBackground（）方法中发生的异常并正确处理异常。

在

getData

类中创建一个字段。在

doBackground

中设置它，在

onPostExecute

中检查它，在

getData

类中创建一个字段。在

doBackground

中设置它，在

onPostExecute中检查它

这样做

class getData extends AsyncTask <Void,Void,Boolaen>
{


@Override
protected Void onPreExecute(Void...arg0)
{
    super.onPreExecute();
    //progress dialog invoked here
}

@Override
protected Boolaen doInBackground(Void...arg0)
{
    try{ 
          parseJSON();
          return true;
    }catch(Exception e){
      e.printStackStrace();
    }

    return false;
}
@Override
protected Void onPostExecute(Boolaen result)
{
    super.onPostExecute(result);
    if(result){
      //success
    }else{
      // Failure
    } 

    //UI manipulated here
}

}

class getData扩展异步任务
{
@凌驾
受保护的Void onPreExecute（Void…arg0）
{
super.onPreExecute（）；
//在此调用进度对话框
}
@凌驾
受保护的Boolaen doInBackground（无效…arg0）
{
试试{
parseJSON（）；
返回true；
}捕获（例外e）{
e、 printStackStrace（）；
}
返回false；
}
@凌驾
受保护的Void onPostExecute（Boolaen结果）
{
super.onPostExecute（结果）；
如果（结果）{
//成功
}否则{
//失败
} 
//这里操纵的用户界面
}
}

这样做

class getData extends AsyncTask <Void,Void,Boolaen>
{


@Override
protected Void onPreExecute(Void...arg0)
{
    super.onPreExecute();
    //progress dialog invoked here
}

@Override
protected Boolaen doInBackground(Void...arg0)
{
    try{ 
          parseJSON();
          return true;
    }catch(Exception e){
      e.printStackStrace();
    }

    return false;
}
@Override
protected Void onPostExecute(Boolaen result)
{
    super.onPostExecute(result);
    if(result){
      //success
    }else{
      // Failure
    } 

    //UI manipulated here
}

}

class getData扩展异步任务
{
@凌驾
受保护的Void onPreExecute（Void…arg0）
{
super.onPreExecute（）；
//在此调用进度对话框
}
@凌驾
受保护的Boolaen doInBackground（无效…arg0）
{
试试{
parseJSON（）；
返回true；
}捕获（例外e）{
e、 printStackStrace（）；
}
返回false；
}
@凌驾
受保护的Void onPostExecute（Boolaen结果）
{
super.onPostExecute（结果）；
如果（结果）{
//成功
}否则{
//失败
} 
//这里操纵的用户界面
}
}

我的方法是这样的。引入一个通用的AsyncTaskResult，您可以在其中存储实际返回值（如果需要），也可以存储在

doInBackground（）中发生的异常。在onPostExecute
中，您可以检查是否发生异常并通知用户（或处理返回值）
AsyncTaskResult:
public class AsyncTaskResult<T> {
    private T mResult;
    private Exception mException = null;

    public AsyncTaskResult() {
    }

    public AsyncTaskResult(T pResult) {
        this.mResult = pResult;
    }

    public AsyncTaskResult(Exception pException) {
        this.mException = pException;
    }

    public T getResult() {
        return mResult;
    }

    public boolean exceptionOccured() {
        return mException != null;
    }

    public Exception getException() {
        return mException;
    }
}

public class RessourceLoaderTask extends AsyncTask<String, String, AsyncTaskResult<String>> {

    public RessourceLoaderTask() {
    }

    @Override
    protected AsyncTaskResult<String> doInBackground(String... params) {
        try {
            // Checked Exception
        } catch (Exception e) {
            return new AsyncTaskResult<String>(e);
        }
        return new AsyncTaskResult<String>();
    }

    @Override
    protected void onPostExecute(AsyncTaskResult<String> pResult) {
        if (!pResult.exceptionOccured()) {
            //...
        } else {
            // Notify user
        }

    }
}

公共类AsyncTaskResult{
私人T-mResult；
私有异常mException=null；
公共AsyncTaskResult（）{
}
公共异步任务结果（T预设）{
this.mResult=pResult；
}
公共AsyncTaskResult（异常pException）{
this.mException=pException；
}
公共T getResult（）{
返回mResult；
}
public boolean exceptionOccured（）{
返回MEException！=null；
}
公共异常getException（）{
返回异常；
}
}


异步任务：
public class AsyncTaskResult<T> {
    private T mResult;
    private Exception mException = null;

    public AsyncTaskResult() {
    }

    public AsyncTaskResult(T pResult) {
        this.mResult = pResult;
    }

    public AsyncTaskResult(Exception pException) {
        this.mException = pException;
    }

    public T getResult() {
        return mResult;
    }

    public boolean exceptionOccured() {
        return mException != null;
    }

    public Exception getException() {
        return mException;
    }
}

public class RessourceLoaderTask extends AsyncTask<String, String, AsyncTaskResult<String>> {

    public RessourceLoaderTask() {
    }

    @Override
    protected AsyncTaskResult<String> doInBackground(String... params) {
        try {
            // Checked Exception
        } catch (Exception e) {
            return new AsyncTaskResult<String>(e);
        }
        return new AsyncTaskResult<String>();
    }

    @Override
    protected void onPostExecute(AsyncTaskResult<String> pResult) {
        if (!pResult.exceptionOccured()) {
            //...
        } else {
            // Notify user
        }

    }
}

公共类RessourceLoaderTask扩展异步任务{
公共资源加载任务（）{
}
@凌驾
受保护的AsyncTaskResult doInBackground（字符串…参数）{
试一试{
//检查异常
}捕获（例外e）{
返回新的AsyncTaskResult（e）；
}
返回新的AsyncTaskResult（）；
}
@凌驾
受保护的void onPostExecute（AsyncTaskResult pResult）{
如果（！pResult.exceptionOccured（））{
//...
}否则{
//通知用户
}
}
}
我的方法是这样的。引入一个通用的AsyncTaskResult，您可以在其中存储实际返回值（如果需要），也可以存储在doInBackground（）中发生的异常。在onPostExecute
中，您可以检查是否发生异常并通知用户（或处理返回值）
AsyncTaskResult:
public class AsyncTaskResult<T> {
    private T mResult;
    private Exception mException = null;

    public AsyncTaskResult() {
    }

    public AsyncTaskResult(T pResult) {
        this.mResult = pResult;
    }

    public AsyncTaskResult(Exception pException) {
        this.mException = pException;
    }

    public T getResult() {
        return mResult;
    }

    public boolean exceptionOccured() {
        return mException != null;
    }

    public Exception getException() {
        return mException;
    }
}

public class RessourceLoaderTask extends AsyncTask<String, String, AsyncTaskResult<String>> {

    public RessourceLoaderTask() {
    }

    @Override
    protected AsyncTaskResult<String> doInBackground(String... params) {
        try {
            // Checked Exception
        } catch (Exception e) {
            return new AsyncTaskResult<String>(e);
        }
        return new AsyncTaskResult<String>();
    }

    @Override
    protected void onPostExecute(AsyncTaskResult<String> pResult) {
        if (!pResult.exceptionOccured()) {
            //...
        } else {
            // Notify user
        }

    }
}

公共类AsyncTaskResult{
私人T-mResult；
私有异常mException=null；
公共AsyncTaskResult（）{
}
公共异步任务结果（T预设）{
this.mResult=pResult；
}
公共AsyncTaskResult（异常pException）{
this.mException=pException；
}
公共T getResult（）{
返回mResult；
}
public boolean exceptionOccured（）{
返回MEException！=null；
}
公共异常getException（）{
返回异常；
}
}


异步任务：
public class AsyncTaskResult<T> {
    private T mResult;
    private Exception mException = null;

    public AsyncTaskResult() {
    }

    public AsyncTaskResult(T pResult) {
        this.mResult = pResult;
    }

    public AsyncTaskResult(Exception pException) {
        this.mException = pException;
    }

    public T getResult() {
        return mResult;
    }

    public boolean exceptionOccured() {
        return mException != null;
    }

    public Exception getException() {
        return mException;
    }
}

public class RessourceLoaderTask extends AsyncTask<String, String, AsyncTaskResult<String>> {

    public RessourceLoaderTask() {
    }

    @Override
    protected AsyncTaskResult<String> doInBackground(String... params) {
        try {
            // Checked Exception
        } catch (Exception e) {
            return new AsyncTaskResult<String>(e);
        }
        return new AsyncTaskResult<String>();
    }

    @Override
    protected void onPostExecute(AsyncTaskResult<String> pResult) {
        if (!pResult.exceptionOccured()) {
            //...
        } else {
            // Notify user
        }

    }
}

公共类RessourceLoaderTask扩展异步任务{
公共资源加载任务（）{
}
@凌驾
受保护的AsyncTaskResult doInBackground（字符串…参数）{
试一试{
//检查异常
}捕获（例外e）{
返回新的AsyncTaskResult（e）；
}
返回新的AsyncTaskResult（）；
}
@凌驾
受保护的void onPostExecute（AsyncTaskResult pResult）{
如果（！pResult.exceptionOccured（））{
//...
}否则{
//通知用户
}
}
}
我在这里有点困惑…如果在doInBackground（）方法中的任何地方捕获到异常，整个AsyncTask类不是都冻结了吗…它到达onPostExecute方法了吗？@NirajAdhikari检查其他答案，他们有我刚才非常简要地描述的代码。这种方法很简单，但是如果你想返回一个真实的值而不是doInBackground中的“success bool”，那该怎么办呢？我在这里有点困惑……如果在doInBackground（）方法中的任何地方捕捉到异常，整个异步过程都不会停止