如何在Android多个Activity中调用同一个服务？

作为从React转过来的新手，你肯定习惯了把API请求抽成单独的service文件——Android里也能做到一模一样，把所有HttpURLConnection的调用逻辑封装到单独的类/文件夹里，让任何Activity都能轻松调用并获取响应结果。

下面一步步教你实现：

第一步：创建单独的网络工具类 #

首先在你的Android项目里新建一个专门放网络逻辑的文件夹（比如叫network或者utils），然后在里面创建一个NetworkService类，用来封装所有HttpURLConnection的请求逻辑。

1. 定义回调接口（处理异步结果） #

因为Android不允许在主线程执行网络请求，所以我们需要用异步方式发起请求，然后通过回调把结果传递回Activity。先定义一个回调接口：

public interface NetworkCallback {
    void onSuccess(String response); // 请求成功时返回响应内容
    void onError(String errorMessage); // 请求失败时返回错误信息
}

2. 封装GET/POST请求方法 #

在NetworkService里写封装好的请求方法，这里以Java为例：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;

public class NetworkService {

    // 封装GET请求
    public static void makeGetRequest(String url, final NetworkCallback callback) {
        // 用AsyncTask做异步操作（Android原生异步工具）
        new android.os.AsyncTask<Void, Void, String>() {
            @Override
            protected String doInBackground(Void... voids) {
                HttpURLConnection connection = null;
                BufferedReader reader = null;
                try {
                    URL requestUrl = new URL(url);
                    connection = (HttpURLConnection) requestUrl.openConnection();
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(5000); // 连接超时5秒
                    connection.setReadTimeout(5000); // 读取超时5秒

                    // 判断响应码
                    if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                        reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                        StringBuilder response = new StringBuilder();
                        String line;
                        while ((line = reader.readLine()) != null) {
                            response.append(line);
                        }
                        return response.toString();
                    } else {
                        return "Error: 响应码 " + connection.getResponseCode();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    return "Error: " + e.getMessage();
                } finally {
                    // 关闭资源
                    if (connection != null) connection.disconnect();
                    if (reader != null) {
                        try {
                            reader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

            @Override
            protected void onPostExecute(String result) {
                super.onPostExecute(result);
                // 这里已经回到主线程，直接调用回调传递结果
                if (result.startsWith("Error:")) {
                    callback.onError(result);
                } else {
                    callback.onSuccess(result);
                }
            }
        }.execute();
    }

    // 封装POST请求（比如提交表单数据）
    public static void makePostRequest(String url, String postData, final NetworkCallback callback) {
        new android.os.AsyncTask<String, Void, String>() {
            @Override
            protected String doInBackground(String... params) {
                String data = params[0];
                HttpURLConnection connection = null;
                OutputStreamWriter writer = null;
                BufferedReader reader = null;
                try {
                    URL requestUrl = new URL(url);
                    connection = (HttpURLConnection) requestUrl.openConnection();
                    connection.setRequestMethod("POST");
                    connection.setConnectTimeout(5000);
                    connection.setReadTimeout(5000);
                    connection.setDoOutput(true); // 允许写入数据
                    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

                    // 写入POST参数
                    writer = new OutputStreamWriter(connection.getOutputStream());
                    writer.write(data);
                    writer.flush();

                    // 处理响应
                    if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                        reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                        StringBuilder response = new StringBuilder();
                        String line;
                        while ((line = reader.readLine()) != null) {
                            response.append(line);
                        }
                        return response.toString();
                    } else {
                        return "Error: 响应码 " + connection.getResponseCode();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    return "Error: " + e.getMessage();
                } finally {
                    // 关闭资源
                    if (connection != null) connection.disconnect();
                    if (writer != null) {
                        try {
                            writer.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (reader != null) {
                        try {
                            reader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

            @Override
            protected void onPostExecute(String result) {
                super.onPostExecute(result);
                if (result.startsWith("Error:")) {
                    callback.onError(result);
                } else {
                    callback.onSuccess(result);
                }
            }
        }.execute(postData);
    }
}

第二步：在任意Activity中调用 #

现在你可以在任何Activity里直接调用NetworkService的方法，通过回调获取结果，比如在MainActivity里：

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

public class MainActivity extends AppCompatActivity {

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

        // 调用GET请求
        NetworkService.makeGetRequest("https://你的后端接口地址/data", new NetworkCallback() {
            @Override
            public void onSuccess(String response) {
                // 请求成功，更新UI（这里已经在主线程，可以直接操作UI）
                TextView responseTv = findViewById(R.id.tv_response);
                responseTv.setText(response);
            }

            @Override
            public void onError(String errorMessage) {
                // 请求失败，显示错误提示
                Toast.makeText(MainActivity.this, errorMessage, Toast.LENGTH_SHORT).show();
            }
        });

        // 调用POST请求（比如登录接口）
        String postParams = "username=test&password=123456";
        NetworkService.makePostRequest("https://你的后端接口地址/login", postParams, new NetworkCallback() {
            @Override
            public void onSuccess(String response) {
                // 处理登录成功逻辑，比如跳转到首页
            }

            @Override
            public void onError(String errorMessage) {
                // 处理登录失败
                Toast.makeText(MainActivity.this, "登录失败：" + errorMessage, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

第三步：添加网络权限 #

别忘了在AndroidManifest.xml里添加网络权限，否则请求会失败：

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

进阶：用Kotlin协程替代AsyncTask #

如果你的项目用Kotlin开发，推荐用协程来替代AsyncTask，代码更简洁易维护：

// NetworkService.kt
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.net.HttpURLConnection
import java.net.URL

class NetworkService {
    suspend fun makeGetRequest(url: String): Result<String> {
        return withContext(Dispatchers.IO) {
            try {
                val connection = URL(url).openConnection() as HttpURLConnection
                connection.requestMethod = "GET"
                connection.connectTimeout = 5000
                connection.readTimeout = 5000

                if (connection.responseCode == HttpURLConnection.HTTP_OK) {
                    val response = connection.inputStream.bufferedReader().readText()
                    Result.success(response)
                } else {
                    Result.failure(Exception("响应码：${connection.responseCode}"))
                }
            } catch (e: Exception) {
                Result.failure(e)
            } finally {
                connection.disconnect()
            }
        }
    }
}

在Activity里调用：

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    private val networkService = NetworkService()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycleScope.launch {
            val result = networkService.makeGetRequest("https://你的后端接口地址/data")
            result.onSuccess { response ->
                // 更新UI
                tv_response.text = response
            }.onFailure { error ->
                Toast.makeText(this@MainActivity, error.message, Toast.LENGTH_SHORT).show()
            }
        }
    }
}

这样你就实现了和React一样的代码复用逻辑——把网络请求抽成单独模块，在任何地方都能调用，完美适配你的开发习惯！

内容的提问来源于stack exchange，提问作者San Daniel