使用独立AsyncTask类实现网络连接遇阻，求解决方案

首先，咱们先搞清楚为什么你拿不到数据，以及UI线程在这里的核心作用：

为什么网络请求不能在UI线程？ #

Android系统有个严格的规则：耗时操作（比如网络请求）绝对不能放在UI线程（主线程）执行。因为UI线程要负责界面渲染、响应用户点击这些实时操作，如果被网络请求这种慢操作卡住，界面会直接僵死，甚至触发ANR（应用无响应）弹窗。从API 11开始，系统还会直接抛出NetworkOnMainThreadException来强制阻止你这么做。

你之前的问题大概率出在这里：要么是直接在MainActivity的UI线程里调用了HttpHandler的方法，要么是你的Temp类（AsyncTask子类）实现有问题——没把网络请求放到后台线程执行，或者没把结果正确传回MainActivity。

先给你一套能跑通的现有架构代码 #

咱们把你现有的三个类调整成正确的复用性架构：

1. 独立可复用的HttpHandler（网络工具类） #

这个类专门封装网络请求的底层逻辑，以后所有Activity都能直接调用：

import android.util.Log;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;

public class HttpHandler {
    private static final String TAG = HttpHandler.class.getSimpleName();
    // 单例模式，避免重复创建实例浪费资源
    private static HttpHandler instance;

    private HttpHandler() {}

    public static synchronized HttpHandler getInstance() {
        if (instance == null) {
            instance = new HttpHandler();
        }
        return instance;
    }

    // 执行GET请求，返回服务器响应的JSON字符串
    public String makeServiceCall(String reqUrl) {
        String response = null;
        try {
            URL url = new URL(reqUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            // 读取服务器返回的输入流
            InputStream in = new BufferedInputStream(conn.getInputStream());
            response = convertStreamToString(in);
        } catch (MalformedURLException e) {
            Log.e(TAG, "URL格式错误: " + e.getMessage());
        } catch (ProtocolException e) {
            Log.e(TAG, "请求协议错误: " + e.getMessage());
        } catch (IOException e) {
            Log.e(TAG, "IO异常: " + e.getMessage());
        } catch (Exception e) {
            Log.e(TAG, "未知异常: " + e.getMessage());
        }
        return response;
    }

    // 将输入流转换为字符串的工具方法
    private String convertStreamToString(InputStream is) {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();
        String line;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line).append('\n');
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}

2. 修复后的Temp类（AsyncTask子类，负责后台执行请求） #

这里用接口回调的方式，把网络请求的结果安全传回MainActivity（自动切换回UI线程）：

import android.os.AsyncTask;

public class Temp extends AsyncTask<String, Void, String> {
    private OnDataReceivedListener listener;

    // 通过构造方法传入回调接口，让Activity接收结果
    public Temp(OnDataReceivedListener listener) {
        this.listener = listener;
    }

    // 这个方法在后台线程执行，专门处理耗时的网络请求
    @Override
    protected String doInBackground(String... params) {
        if (params.length == 0) return null;
        String url = params[0];
        // 调用HttpHandler的网络请求方法
        return HttpHandler.getInstance().makeServiceCall(url);
    }

    // 这个方法在UI线程执行，把结果传回Activity
    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        if (listener != null) {
            if (result != null) {
                listener.onSuccess(result);
            } else {
                listener.onFailure("获取数据失败");
            }
        }
    }

    // 定义回调接口，让需要接收结果的Activity实现它
    public interface OnDataReceivedListener {
        void onSuccess(String jsonData);
        void onFailure(String errorMessage);
    }
}

3. MainActivity中调用的正确方式 #

让MainActivity实现回调接口，接收并处理网络请求结果：

import android.os.Bundle;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity implements Temp.OnDataReceivedListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 启动后台任务，传入你的请求URL
        new Temp(this).execute("https://你的请求地址.com/data.json");
    }

    // 请求成功时触发，在这里解析JSON并更新UI
    @Override
    public void onSuccess(String jsonData) {
        Toast.makeText(this, "数据获取成功", Toast.LENGTH_SHORT).show();
        // 示例：把JSON显示到TextView
        // textView.setText(jsonData);
    }

    // 请求失败时触发，处理错误提示
    @Override
    public void onFailure(String errorMessage) {
        Toast.makeText(this, errorMessage, Toast.LENGTH_SHORT).show();
    }
}

别忘了加网络权限！ #

在AndroidManifest.xml里添加以下权限，否则应用连不上网络：

<uses-permission android:name="android.permission.INTERNET" />

关于独立网络类的优化建议 #

你想把网络逻辑抽成独立类的想法非常棒，能大幅提升代码复用性。上面的HttpHandler已经是标准的独立工具类了，不过还有更现代的方案可以替代AsyncTask：

推荐用Retrofit替代AsyncTask #

AsyncTask已经在Android API 30中被弃用，它存在内存泄漏、线程池管理不灵活等问题。现在更推荐用Retrofit（Square公司的成熟网络库），它能自动处理线程切换，代码更简洁易维护。

举个简单的示例：

1. 先在build.gradle（Module级别）添加依赖：

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

2. 定义API接口：

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Url;
import okhttp3.ResponseBody;

public interface ApiService {
    @GET
    Call<ResponseBody> getData(@Url String url);
}

3. 封装Retrofit客户端：

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {
    private static Retrofit retrofit;
    // 填你的基础URL，如果是全URL请求可以填任意合法地址，比如"https://example.com/"
    private static final String BASE_URL = "https://你的基础地址.com/";

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

4. 在Activity中调用：

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import okhttp3.ResponseBody;

// 在MainActivity的onCreate方法里调用
ApiService apiService = RetrofitClient.getRetrofitInstance().create(ApiService.class);
Call<ResponseBody> call = apiService.getData("https://你的请求地址.com/data.json");
call.enqueue(new Callback<ResponseBody>() {
    @Override
    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
        if (response.isSuccessful()) {
            try {
                String jsonData = response.body().string();
                // 处理获取到的JSON数据
                Toast.makeText(MainActivity.this, "数据获取成功", Toast.LENGTH_SHORT).show();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onFailure(Call<ResponseBody> call, Throwable t) {
        // 处理请求失败的情况
        Toast.makeText(MainActivity.this, "请求失败: " + t.getMessage(), Toast.LENGTH_SHORT).show();
    }
});

内容的提问来源于stack exchange，提问作者pp chan