目录

1. 核心概念：为什么需要数据传输？
2. 通信协议：如何传输数据？
3. 数据格式：传输什么？
4. Android 客户端实现：如何发送和接收数据？
   • 1 使用 HttpURLConnection (原生,较基础)
   • 2 使用第三方库：OkHttp (推荐)
   • 3 使用第三方库：Retrofit (最推荐，用于 RESTful API)
5. 服务器端实现简介 (以 Node.js 和 Java Spring Boot 为例)
6. 最佳实践与注意事项
7. 如何选择？

核心概念：为什么需要数据传输？

Android App 通常需要与服务器交互来：

• 用户认证：登录、注册、获取用户信息。
• 数据同步：获取新闻、动态、商品列表等。
• 数据提交：发布动态、上传图片、提交订单、保存用户设置。
• 实时通信：即时消息、在线状态、推送通知。

这个过程本质上是 客户端 和 服务器 之间的一个 请求-响应 循环。

通信协议：如何传输数据？

协议是客户端和服务器之间“沟通的语言”,目前主流的有两种：

a) HTTP/HTTPS (超文本传输协议/安全超文本传输协议)

这是最常用、最标准的协议，客户端发送一个 HTTP 请求，服务器处理并返回一个 HTTP 响应。

• 特点：
  • 请求-响应模式：客户端必须先发起请求,服务器才能响应。
  • 无状态：服务器不保存客户端的状态，每次请求都是独立的，需要客户端自己维护状态（例如通过 Cookie 或 Token）。
  • 基于 TCP：非常可靠,数据传输稳定。
• HTTPS：在 HTTP 的基础上加上了 SSL/TLS 加密层，所有数据传输都是加密的，可以有效防止数据被窃听或篡改。现代 App 强烈推荐使用 HTTPS。

b) WebSocket

一种在单个 TCP 连接上进行全双工通信的协议。

• 特点：
  • 全双工通信：服务器可以主动向客户端推送数据，客户端也可以随时向服务器发送数据,无需客户端先请求。
  • 持久连接：连接一旦建立就会保持,直到某一方主动关闭。
  • 低延迟：非常适合实时性要求高的场景，如聊天室、在线游戏、实时股票行情等。
• 使用场景：需要服务器主动向客户端推送数据的场景。

数据格式：传输什么？

数据在网络上传输时需要被序列化成一种通用的格式,常见的数据格式有：

a) JSON (JavaScript Object Notation)

目前最主流、最推荐的数据格式。

• 优点：
  • 轻量级：相比 XML，数据更小,传输更快。
  • 易于阅读和编写：结构清晰,人眼可读。
  • 易于解析：所有主流编程语言都有成熟的 JSON 解析库。
• 示例：

  {
    "userId": 123,
    "username": "john_doe",
    "email": "john@example.com",
    "isActive": true
  }

b) XML (eXtensible Markup Language)

曾经非常流行，但现在已逐渐被 JSON 取代。

• 优点：
  • 可扩展性强：可以定义自己的标签。
  • 支持验证：通过 DTD 或 XSD 可以验证数据结构的正确性。
• 缺点：
  • 冗余：标签占用了大量空间，数据量比 JSON 大。
  • 解析复杂：解析通常比 JSON 更慢、更复杂。
• 示例：

  <user>
    <userId>123</userId>
    <username>john_doe</username>
    <email>john@example.com</email>
    <isActive>true</isActive>
  </user>

c) Protocol Buffers (Protobuf)

由 Google 开发的高效、灵活的数据序列化格式。

• 优点：
  • 高性能：序列化和反序列化速度极快,数据体积小。
  • 强类型：需要先定义 .proto 文件，数据结构严格,减少运行时错误。
• 缺点：
  • 可读性差：二进制格式,不适合直接阅读和调试。
  • 需要预编译：需要为客户端和服务器分别生成对应语言的代码。
• 使用场景：对性能和带宽有极致要求的内部系统或微服务通信。

Android 客户端实现：如何发送和接收数据？

1 使用 HttpURLConnection (原生 API)

这是 Android SDK 自带的，无需添加依赖，但代码较为繁琐，且需要手动处理线程（网络请求不能在主线程执行）。

示例代码 (GET 请求):

// 必须在子线程中执行
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            URL url = new URL("https://api.example.com/users/123");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(5000); // 5秒连接超时
            connection.setReadTimeout(5000);    // 5秒读取超时
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                InputStream inputStream = connection.getInputStream();
                String response = readStream(inputStream);
                // 在这里处理 response (通过 Handler 发送到主线程更新UI)
                Log.d("Response", response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}).start();
// 辅助方法：将输入流转换为字符串
private String readStream(InputStream inputStream) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    StringBuilder response = new StringBuilder();
    String line;
    while ((line = reader.readLine()) != null) {
        response.append(line);
    }
    reader.close();
    return response.toString();
}

2 使用第三方库：OkHttp (Google 推荐的网络库)

OkHttp 是一个现代、高效、易于使用的网络请求库，它简化了网络操作,并内置了线程管理。

添加依赖 (build.gradle):

implementation("com.squareup.okhttp3:okhttp:4.12.0")

示例代码 (GET 请求):

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
        .url("https://api.example.com/users/123")
        .build();
// 异步请求 (推荐)
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(@NonNull Call call, @NonNull IOException e) {
        // 请求失败，在子线程执行
        e.printStackTrace();
    }
    @Override
    public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
        // 请求成功，在子线程执行
        if (response.isSuccessful()) {
            String responseData = response.body().string();
            // 在这里处理 responseData，并通过 Handler/Runable 更新UI
            Log.d("OkHttp Response", responseData);
        }
    }
});

3 使用第三方库：Retrofit (RESTful API 的最佳选择)

Retrofit 是一个类型安全的 HTTP 客户端，它将网络请求接口化，通过注解来描述请求，并自动将 JSON 响应转换成 Java/Kotlin 对象，它底层通常使用 OkHttp。

添加依赖 (build.gradle):

// Retrofit 核心库
implementation("com.squareup.retrofit2:retrofit:2.9.0")
// JSON 转换器 (Gson)
implementation("com.squareup.retrofit2:converter-gson:2.9.0")
// 协程支持 (如果使用 Kotlin)
implementation("com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.9.2")

定义 API 接口:

public interface ApiService {
    // GET https://api.example.com/users/123
    @GET("users/{id}")
    Call<User> getUser(@Path("id") int userId);
    // POST https://api.example.com/users
    @POST("users")
    Call<User> createUser(@Body User user); // User 对象会被自动转成 JSON
}

创建 Retrofit 实例并发起请求:

// 创建 Retrofit 实例
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addConverterFactory(GsonConverterFactory.create()) // 添加Gson转换器
        .build();
// 创建 API 接口的实现
ApiService apiService = retrofit.create(ApiService.class);
// 发起请求
Call<User> call = apiService.getUser(123);
// 异步执行
call.enqueue(new Callback<User>() {
    @Override
    public void onFailure(@NonNull Call<User> call, @NonNull Throwable t) {
        // 请求失败
        t.printStackTrace();
    }
    @Override
    public void onResponse(@NonNull Call<User> call, @NonNull Response<User> response) {
        // 请求成功
        if (response.isSuccessful()) {
            User user = response.body();
            // user 对象已经自动解析好了
            Log.d("Retrofit Response", "User: " + user.getUsername());
        }
    }
});

• HttpURLConnection：简单任务,不想引入第三方库时使用。
• OkHttp：功能强大，灵活性好,是网络请求的底层好选择。
• Retrofit：强烈推荐，它封装了 OkHttp，提供了更高级、更优雅的 API，尤其适合处理复杂的 RESTful API,能极大提升开发效率和代码可维护性。

服务器端实现简介

服务器端的语言和框架非常多，但核心逻辑都是类似的：监听端口 -> 接收请求 -> 解析请求 -> 处理业务逻辑 -> 返回响应。

• Node.js + Express/Koa：轻量、异步、高性能，适合 I/O 密集型应用。
• Java + Spring Boot：生态成熟、稳定、企业级首选，非常适合构建复杂的 RESTful API。
• Python + Django/Flask：开发效率高，库丰富，数据科学和 Web 开发领域常用。
• Go + Gin：性能极高，并发能力强,适合微服务架构。
• PHP + Laravel：Web 开发领域老牌劲旅,生态完善。

服务器端需要做的：

1. 创建一个 HTTP 服务器。
2. 定义路由（URL 路径和 HTTP 方法）。
3. 编写处理函数，从请求中获取数据（如 JSON），进行业务逻辑处理（如查询数据库）。
4. 将处理结果序列化成 JSON，并设置正确的 Content-Type 头（application/json）,然后返回给客户端。

最佳实践与注意事项

1. 网络线程：永远不要在主线程（UI 线程）中进行网络请求，否则会导致应用卡顿甚至被 Android 系统杀死（抛出 NetworkOnMainThreadException），使用异步请求（如 enqueue）或 Thread/Handler/Coroutine 来处理。
2. HTTPS：生产环境必须使用 HTTPS,保护用户数据安全。
3. 数据加密：对于非常敏感的数据（如密码），即使使用 HTTPS，也建议在客户端先进行一次哈希（如 SHA-256）再传输。
4. 错误处理：网络请求可能会因为各种原因失败（无网络、超时、服务器 500 错误等），必须妥善处理所有可能的错误,并向用户友好的提示。
5. 数据验证：不要信任任何来自客户端的数据，服务器端必须对收到的数据进行严格的验证和过滤，防止 SQL 注入、XSS 等安全攻击。
6. 版本控制：API 应该有版本控制（如 v1, v2），这样可以在不破坏旧版 App 功能的情况下迭代 API。
7. 超时设置：为连接和读取设置合理的超时时间，避免 App 无限等待。

如何选择？

对于绝大多数 Android 掌握 Retrofit 和 OkHttp 的使用，并以 JSON 作为数据交换格式，是构建高效、健壮的客户端-服务器应用的核心技能。