Jorgen's blog
Jorgen
2023-11-15
目录

Android网络编程完全指南-从HTTP到Retrofit的实践之路

# 前言

在当今移动应用开发中，网络编程是不可或缺的一部分。无论是获取最新资讯、加载社交媒体动态，还是与后端API交互，网络请求都扮演着至关重要的角色。🌐

作为一名Android开发者，掌握网络编程技能不仅能提升应用的用户体验，还能让你更好地理解现代应用的工作原理。本文将带你从零开始，全面了解Android网络编程的核心概念和最佳实践。

"网络是现代应用的血脉，理解网络编程就是理解应用的呼吸方式。"

# Android网络基础

在深入探讨具体的网络请求库之前，我们需要了解一些基础知识。

# 网络权限

首先，确保在AndroidManifest.xml中添加网络权限：

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

对于Android 9.0 (API级别28)及以上，默认情况下应用只能使用HTTPS连接。如果需要使用HTTP，需要在networkSecurityConfig.xml中配置：

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ...>
    
    <network-security-config>
        <domain-config cleartextTrafficPermitted="true">
            <domain includeSubdomains="true">example.com</domain>
        </domain-config>
    </network-security-config>
1
2
3
4
5
6
7
8
9

# HTTP/HTTPS协议

HTTP（超文本传输协议）是互联网上应用最广泛的网络协议。HTTPS则是HTTP的安全版本，通过SSL/TLS加密传输数据，保护数据不被窃取或篡改。

提示

从Android 9.0开始，默认禁用了HTTP明文流量，推荐使用HTTPS确保数据安全。

# 传统网络请求方式

在第三方网络库流行之前，Android主要使用HttpURLConnection和HttpClient进行网络请求。

# HttpURLConnection

HttpURLConnection是Java标准库提供的HTTP客户端，Android对其进行了优化：

URL url = new URL("https://example.com/api/data");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setConnectTimeout(15000);
connection.setReadTimeout(15000);

int responseCode = connection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
    InputStream inputStream = connection.getInputStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    StringBuilder response = new StringBuilder();
    String line;
    while ((line = reader.readLine()) != null) {
        response.append(line);
    }
    reader.close();
    // 处理响应数据
}
connection.disconnect();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# HttpClient

HttpClient是Apache提供的HTTP客户端库，功能更丰富但已被废弃，不推荐在新项目中使用。

THEOREM

注意：HttpClient在Android API 23+已被移除，如果需要使用，需添加外部依赖。

# OkHttp详解

OkHttp是Square公司开发的一款优秀的HTTP客户端，已成为Android网络请求的事实标准。

# OkHttp基本使用

首先添加依赖：

implementation("com.squareup.okhttp3:okhttp:4.10.0")
1

# GET请求

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
    .url("https://example.com/api/data")
    .build();

client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 请求失败处理
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (response.isSuccessful()) {
            String responseData = response.body().string();
            // 处理响应数据
        }
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# POST请求

OkHttpClient client = new OkHttpClient();

MediaType JSON = MediaType.parse("application/json; charset=utf-8");
JSONObject jsonObject = new JSONObject();
jsonObject.put("key", "value");

RequestBody body = RequestBody.create(JSON, jsonObject.toString());

Request request = new Request.Builder()
    .url("https://example.com/api/create")
    .post(body)
    .build();

client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 请求失败处理
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理响应
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# OkHttp高级特性

# 拦截器

拦截器是OkHttp最强大的功能之一，允许你在请求发送前和响应返回后进行干预：

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            
            // 添加公共头
            Request newRequest = request.newBuilder()
                .addHeader("Authorization", "Bearer token")
                .build();
                
            return chain.proceed(newRequest);
        }
    })
    .build();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 缓存

OkHttp内置了缓存机制，可以减少网络请求，提高应用性能：

int cacheSize = 10 * 1024 * 1024; // 10MB
Cache cache = new Cache(context.getCacheDir(), cacheSize);

OkHttpClient client = new OkHttpClient.Builder()
    .cache(cache)
    .build();
1
2
3
4
5
6

# Retrofit入门与实践

Retrofit是Square公司开发的类型安全的HTTP客户端，它基于OkHttp，将HTTP API转换为Java接口。

# 基本使用

首先添加依赖：

implementation("com.squareup.retrofit2:retrofit:2.9.0")
implementation("com.squareup.retrofit2:converter-gson:2.9.0") // JSON转换器
1
2

# 定义API接口

public interface ApiService {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);
}
1
2
3
4

# 创建Retrofit实例并调用API

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

ApiService service = retrofit.create(ApiService.class);

Call<List<Repo>> call = service.listRepos("octocat");
call.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
        if (response.isSuccessful()) {
            List<Repo> repos = response.body();
            // 处理数据
        }
    }

    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
        // 请求失败处理
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Retrofit高级特性

# 异步请求与协程

Retrofit 2.6+支持Kotlin协程，可以更优雅地处理异步请求：

interface ApiService {
    @GET("users/{user}/repos")
    suspend fun listRepos(@Path("user") user: String): List<Repo>
}

// 在协程中调用
viewModelScope.launch {
    try {
        val repos = apiService.listRepos("octocat")
        // 处理数据
    } catch (e: Exception) {
        // 错误处理
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 自定义适配器

Retrofit支持多种适配器，如RxJava、Guava等，可以轻松集成响应式编程：

implementation("com.squareup.retrofit2:adapter-rxjava2:2.9.0")
1
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .build();
1
2
3
4

# 网络状态监测

了解网络状态对于提供良好的用户体验至关重要。

# ConnectivityManager

ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
Network network = connectivityManager.getActiveNetwork();
NetworkCapabilities capabilities = connectivityManager.getNetworkCapabilities(network);

if (capabilities != null) {
    if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
        // WiFi连接
    } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
        // 移动数据连接
    }
}
1
2
3
4
5
6
7
8
9
10
11

# 网络状态变化监听

ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
    @Override
    public void onAvailable(Network network) {
        // 网络可用
    }

    @Override
    public void onLost(Network network) {
        // 网络丢失
    }
};

ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
connectivityManager.registerNetworkCallback(
    new NetworkRequest.Builder().build(), networkCallback);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 网络请求最佳实践

# 线程管理

网络请求应该在后台线程执行，避免阻塞UI线程。Retrofit的enqueue()方法已经处理了线程切换，但如果你使用的是同步请求，需要手动处理：

// 在子线程中执行
new Thread(() -> {
    try {
        Response response = call.execute();
        // 处理响应
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();
1
2
3
4
5
6
7
8
9

# 错误处理

网络请求可能因各种原因失败，应妥善处理错误情况：

call.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
        if (response.isSuccessful()) {
            // 处理成功响应
        } else {
            // 处理HTTP错误
            int code = response.code();
            String message = response.message();
        }
    }

    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
        // 处理网络错误
        if (t instanceof IOException) {
            // 网络错误
        } else {
            // 其他错误
        }
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 超时设置

合理设置连接超时和读取超时，避免请求长时间挂起：

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .writeTimeout(30, TimeUnit.SECONDS)
    .build();
1
2
3
4
5

# 缓存策略

合理使用缓存可以减少网络请求，提高应用性能：

@Headers("Cache-Control: public, max-age=640000")
@GET("api/data")
Call<Data> getData();
1
2
3

# 结语

Android网络编程是构建现代应用的核心技能之一。从传统的HttpURLConnection到现代的OkHttp和Retrofit，我们见证了网络请求方式的不断演进。

"网络是应用的血脉，而优秀的网络编程则是应用的强健心脏。"

通过本文的学习，你应该已经掌握了Android网络编程的基础知识和最佳实践。在实际开发中，还需要根据具体需求选择合适的网络请求库和策略，不断优化和改进。

未来，随着Jetpack Compose的普及，网络编程可能会迎来新的变革，但核心原理和最佳实践将保持不变。希望本文能为你Android网络编程之旅打下坚实的基础！

记住，优秀的网络编程不仅关乎技术，更关乎用户体验。在网络不稳定的情况下，优雅地降级处理，给用户带来流畅的体验，这才是网络编程的最高境界。

#Android#网络编程#OkHttp#Retrofit
上次更新: 2026/01/28, 10:42:53
Android依赖注入实战：从Dagger到Hilt的进化之路
Android数据持久化完全指南-从SharedPreferences到Room数据库

← Android数据持久化完全指南-从SharedPreferences到Room数据库→

最近更新
01
LLM
01-30
02
intro
01-30
03
intro
01-30
更多文章>
Theme by Vdoing | Copyright © 2019-2026 Jorgen | MIT License