安卓怎么获取json数据

安卓开发中获取JSON数据的完整指南

在安卓开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其易读性和灵活性，成为客户端与服务器交互的主流数据格式，无论是获取用户信息、加载文章列表，还是同步配置数据，都离不开对JSON数据的解析，本文将详细介绍安卓开发中获取JSON数据的多种方式，从基础的网络请求到数据解析，再到异步处理和错误处理,帮助开发者核心技能。

获取JSON数据的基础流程

安卓端获取JSON数据通常遵循以下核心流程：

1. 发起网络请求：通过HTTP/HTTPS协议从服务器获取JSON格式的字符串数据；
2. 解析JSON数据：将获取到的JSON字符串转换为安卓可用的对象（如List、Map或自定义实体类）；
3. 处理数据：将解析后的数据更新到UI或其他业务逻辑中。

网络请求是前提，JSON解析是核心,异步处理和错误保障是关键。

发起网络请求获取JSON字符串

安卓系统出于安全考虑，禁止在主线程（UI线程）中执行网络操作，因此网络请求必须在子线程中完成,以下是几种主流的网络请求方式：

使用HttpURLConnection（原生API，无需依赖）

HttpURLConnection是安卓提供的原生HTTP请求工具，适用于简单场景，无需第三方依赖,但代码相对繁琐。

示例代码：

// 在子线程中发起请求
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            URL url = new URL("https://api.example.com/data.json");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET"); // 设置请求方法
            connection.setConnectTimeout(5000); // 连接超时时间（毫秒）
            connection.setReadTimeout(5000);    // 读取超时时间
            // 获取响应码
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                // 读取输入流（JSON字符串）
                InputStream inputStream = connection.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                StringBuilder stringBuilder = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    stringBuilder.append(line);
                }
                String jsonString = stringBuilder.toString();
                // 解析JSON数据（后续步骤）
                Log.d("JSON Response", jsonString);
            } else {
                Log.e("HTTP Error", "Request failed, response code: " + responseCode);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}).start();

使用OkHttp（第三方库，推荐）

OkHttp是安卓开发中最流行的网络请求库，支持同步/异步请求、连接池、拦截器等功能，效率高且易用,需先添加依赖：

app/build.gradle中添加：

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
}

示例代码（异步GET请求）：

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
        .url("https://api.example.com/data.json")
        .build();
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 请求失败（如网络异常、超时）
        e.printStackTrace();
    }
    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 请求成功，获取JSON字符串
        if (response.isSuccessful()) {
            String jsonString = response.body().string();
            // 解析JSON数据（后续步骤）
            Log.d("JSON Response", jsonString);
        }
    }
});

使用Retrofit（第三方库，适合RESTful API）

Retrofit是Square公司推出的类型安全的HTTP客户端，通过接口定义API请求，支持自动将JSON数据转换为Java对象，适合处理复杂的RESTful API,需添加依赖：

app/build.gradle中添加：

dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0") // JSON解析器
}

步骤1：定义API接口

public interface ApiService {
    @GET("data.json")
    Call<List<User>> getUsers(); // 假设返回用户列表
}

步骤2：创建Retrofit实例并发起请求

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addConverterFactory(GsonConverterFactory.create()) // 添加Gson解析器
        .build();
ApiService apiService = retrofit.create(ApiService.class);
Call<List<User>> call = apiService.getUsers();
// 异步请求
call.enqueue(new Callback<List<User>>() {
    @Override
    public void onResponse(Call<List<User>> call, Response<List<User>> response) {
        if (response.isSuccessful()) {
            List<User> users = response.body(); // 直接解析为List<User>
            // 更新UI或处理数据
        }
    }
    @Override
    public void onFailure(Call<List<User>> call, Throwable t) {
        t.printStackTrace();
    }
});

解析JSON数据

获取到JSON字符串后，需将其转换为安卓可用的对象，常见的JSON解析方式包括：原生API、Gson、Moshi等。

使用安卓原生API（JSONObject/JSONArray）

无需依赖，适合简单的JSON结构,但代码冗长且易出错。

示例：解析JSON数组

假设JSON字符串为：

[
    {"id": 1, "name": "张三", "age": 25},
    {"id": 2, "name": "李四", "age": 30}
]

解析代码：

try {
    JSONArray jsonArray = new JSONArray(jsonString);
    List<User> userList = new ArrayList<>();
    for (int i = 0; i < jsonArray.length(); i++) {
        JSONObject jsonObject = jsonArray.getJSONObject(i);
        int id = jsonObject.getInt("id");
        String name = jsonObject.getString("name");
        int age = jsonObject.getInt("age");
        User user = new User(id, name, age);
        userList.add(user);
    }
    // 处理userList
} catch (JSONException e) {
    e.printStackTrace();
}

使用Gson（第三方库，推荐）

Gson是Google开发的JSON库，支持自动将JSON字符串与Java对象相互转换，代码简洁高效,需添加依赖：

implementation("com.google.code.gson:gson:2.10.1")

步骤1：定义实体类（与JSON字段对应）

public class User {
    private int id;
    private String name;
    private int age;
    // 无参构造、getter/setter（或使用@注解简化）
    public User() {}
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}';
    }
}

步骤2：解析JSON字符串

// 解析JSON对象
String jsonUser = "{\"id\": 1, \"name\": \"张三\", \"age\": 25}";
Gson gson = new Gson();
User user = gson.fromJson(jsonUser, User.class);
Log.d("User", user.toString());
// 解析JSON数组
String jsonArray = "[{\"id\": 1, \"name\": \"张三\", \"age\": 25}, {\"id\": 2, \"name\": \"李四\", \"age\": 30}]";
List<User> userList = gson.fromJson(jsonArray, new TypeToken<List<User>>() {}.getType());
Log.d("UserList", userList.toString());

使用Moshi（第三方库，现代替代方案）

Moshi是Square推出的JSON库，性能优于Gson，支持Kotlinotlin的默认参数和密封类，适合现代安卓开发,需添加依赖：

implementation("com.squareup.moshi:moshi:1.15.0")
implementation("com.squareup.moshi:moshi-kotlin:1.15.0") // Kotlin支持

示例（Kotlin代码）：

// 定义实体类（使用data class）
data class User(val id: Int, val name: String, val age: Int)
// 解析JSON
val json = """{"id": 1, "name": "张三", "age": 25}"""
val moshi = Moshi.Builder().build()
val jsonAdapter = moshi.adapter(User::class.java)
val user = jsonAdapter.fromJson(json)
println(user) // 输出: User(id=1, name=张三, age=25)

异步处理与线程切换

网络请求和JSON解析均在子线程中完成，而UI更新必须在主线程,以下是常见的线程切换方式：

使用Handler（原生方式）

通过Handler将子线程数据传递到主线程更新UI：