彻底搞懂Android Volley JsonArrayRequest(8)

Android小码蜂
2 阅读23分钟

彻底搞懂Android Volley JsonArrayRequest：从源码到实战的全面解析

一、引言

在Android开发中，网络请求是必不可少的一部分。而处理JSON数据又是网络请求中最常见的场景之一。Volley作为Android官方推荐的网络请求库，提供了丰富的API来简化网络请求操作。其中，JsonArrayRequest是专门用于处理JSON数组响应的请求类，它能够方便地将服务器返回的JSON数组数据解析为Android中的JSONArray对象，供开发者进一步处理。

本文将深入剖析Android Volley库中的JsonArrayRequest类，从源码级别详细分析其实现原理和操作方法。通过本文的学习，你将全面掌握JsonArrayRequest的使用技巧，理解其内部工作机制，从而在开发中更加得心应手地处理JSON数组数据请求。

二、JsonArrayRequest类概述

2.1 类定义与继承关系

JsonArrayRequest是Volley库中专门用于处理JSON数组响应的请求类，它继承自JsonRequest类，而JsonRequest又继承自Request类。下面是JsonArrayRequest类的定义：

public class JsonArrayRequest extends JsonRequest<JSONArray> {
    /**
     * 创建一个新的JsonArrayRequest实例
     *
     * @param method 请求方法（GET、POST等）
     * @param url 请求的URL地址
     * @param jsonRequest 包含请求参数的JSON对象，如果是GET请求则为null
     * @param listener 响应成功的回调监听器
     * @param errorListener 响应失败的回调监听器
     */
    public JsonArrayRequest(int method, String url, JSONArray jsonRequest,
            Listener<JSONArray> listener, ErrorListener errorListener) {
        // 调用父类JsonRequest的构造函数
        super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(),
                listener, errorListener);
    }

    /**
     * 创建一个新的GET请求的JsonArrayRequest实例
     *
     * @param url 请求的URL地址
     * @param listener 响应成功的回调监听器
     * @param errorListener 响应失败的回调监听器
     */
    public JsonArrayRequest(String url, Listener<JSONArray> listener, ErrorListener errorListener) {
        // 调用上面的构造函数，指定请求方法为GET，请求参数为null
        this(Method.GET, url, null, listener, errorListener);
    }

    @Override
    protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {
        try {
            // 将响应数据转换为字符串
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers, PROTOCOL_CHARSET));
            // 将字符串解析为JSONArray对象
            return Response.success(new JSONArray(jsonString),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            // 处理编码异常
            return Response.error(new ParseError(e));
        } catch (JSONException je) {
            // 处理JSON解析异常
            return Response.error(new ParseError(je));
        }
    }
}

从上面的代码可以看出，JsonArrayRequest类继承自JsonRequest，这表明它是一个专门处理JSONArray响应的请求类。它提供了两个主要的构造函数，分别用于创建不同类型的请求。

2.2 核心功能与用途

JsonArrayRequest的核心功能是发送HTTP请求并将服务器返回的JSON数组数据解析为Android中的JSONArray对象。它主要用于以下场景：

  1. 获取服务器返回的JSON数组数据
  2. 处理RESTful API返回的集合数据
  3. 与后端服务进行数据交互，特别是需要处理多个JSON对象组成的数组数据

与其他请求类相比，JsonArrayRequest的主要特点是：

  • 专门处理JSON数组响应
  • 自动将响应数据解析为JSONArray对象
  • 提供了简单易用的回调接口来处理响应结果
  • 支持自定义请求头和请求参数
  • 集成了Volley的缓存机制和请求队列管理

三、JsonArrayRequest的构造函数

3.1 构造函数源码分析

JsonArrayRequest提供了两个主要的构造函数，下面我们来详细分析它们的实现：

/**
 * 创建一个新的JsonArrayRequest实例
 *
 * @param method 请求方法（GET、POST等）
 * @param url 请求的URL地址
 * @param jsonRequest 包含请求参数的JSONArray对象，如果是GET请求则为null
 * @param listener 响应成功的回调监听器
 * @param errorListener 响应失败的回调监听器
 */
public JsonArrayRequest(int method, String url, JSONArray jsonRequest,
        Listener<JSONArray> listener, ErrorListener errorListener) {
    // 调用父类JsonRequest的构造函数
    super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(),
            listener, errorListener);
    
    // 设置请求的内容类型为JSON
    setShouldCache(false);
}

/**
 * 创建一个新的GET请求的JsonArrayRequest实例
 *
 * @param url 请求的URL地址
 * @param listener 响应成功的回调监听器
 * @param errorListener 响应失败的回调监听器
 */
public JsonArrayRequest(String url, Listener<JSONArray> listener, ErrorListener errorListener) {
    // 调用上面的构造函数，指定请求方法为GET，请求参数为null
    this(Method.GET, url, null, listener, errorListener);
}

3.2 参数说明

  • method：请求的HTTP方法，如GET、POST、PUT、DELETE等，定义在Request.Method类中
  • url：请求的URL地址
  • jsonRequest：包含请求参数的JSONArray对象，仅用于POST、PUT等需要请求体的方法
  • listener：请求成功的回调监听器，用于处理服务器返回的JSONArray数据
  • errorListener：请求失败的回调监听器，用于处理请求过程中发生的错误

3.3 构造函数调用流程

当我们创建一个JsonArrayRequest实例时，构造函数的调用流程如下：

  1. 调用父类JsonRequest的构造函数
  2. 在父类构造函数中，设置请求的基本属性，如方法、URL、请求体等
  3. 设置请求的内容类型为application/json
  4. 初始化响应监听器和错误监听器

下面是父类JsonRequest的构造函数源码：

/**
 * 创建一个新的JsonRequest实例
 *
 * @param method 请求方法
 * @param url 请求的URL
 * @param requestBody 请求体的JSON字符串
 * @param listener 响应成功的回调监听器
 * @param errorListener 响应失败的回调监听器
 */
public JsonRequest(int method, String url, String requestBody,
        Listener<T> listener, ErrorListener errorListener) {
    // 调用Request类的构造函数
    super(method, url, errorListener);
    
    // 设置请求的重试策略
    setRetryPolicy(new DefaultRetryPolicy(
            DefaultRetryPolicy.DEFAULT_TIMEOUT_MS,
            DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
            DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
    
    // 保存响应监听器和请求体
    mListener = listener;
    mRequestBody = requestBody;
}

可以看到，JsonRequest的构造函数主要完成了以下工作：

  1. 调用Request类的构造函数，初始化请求的基本属性
  2. 设置默认的重试策略，包括超时时间、最大重试次数和退避乘数
  3. 保存响应监听器和请求体字符串

四、请求的生命周期

4.1 请求的创建与初始化

当我们使用JsonArrayRequest发送一个请求时，首先需要创建一个JsonArrayRequest实例。下面是一个创建GET请求的示例：

// 创建请求URL
String url = "https://api.example.com/data";

// 创建JsonArrayRequest实例
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,  // 请求方法为GET
    url,                 // 请求URL
    null,                // GET请求不需要请求体
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理成功响应
            Log.d(TAG, "Response: " + response.toString());
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误响应
            Log.e(TAG, "Error: " + error.getMessage());
        }
    }
);

在创建请求实例时，我们需要指定请求方法、URL、请求体（GET请求为null）以及成功和失败的回调监听器。

4.2 请求的排队与调度

创建请求实例后，我们需要将其添加到RequestQueue中进行处理：

// 获取RequestQueue实例
RequestQueue queue = Volley.newRequestQueue(context);

// 将请求添加到队列中
queue.add(request);

RequestQueue是Volley的核心组件之一，负责管理请求的排队和调度。当我们调用queue.add(request)时，请求会被添加到RequestQueue的请求队列中。

RequestQueue的add方法源码如下：

/**
 * 将请求添加到队列中进行处理
 *
 * @param request 请求对象
 * @return 返回请求对象本身，方便链式调用
 */
public <T> Request<T> add(Request<T> request) {
    // 将请求标记为已添加到队列
    request.setRequestQueue(this);
    
    // 如果请求没有指定缓存键，使用URL作为缓存键
    if (request.getCacheKey() == null) {
        request.setCacheKey(request.getUrl());
    }
    
    // 添加请求到标记集合，用于跟踪请求状态
    addToLogging(request);
    
    // 如果请求不需要缓存或者缓存已禁用，直接将请求发送到网络
    if (!request.shouldCache()) {
        mNetworkQueue.add(request);
        return request;
    }
    
    // 否则，先尝试从缓存中获取数据
    mCacheQueue.add(request);
    return request;
}

从源码可以看出，add方法的主要逻辑如下：

  1. 设置请求所属的RequestQueue
  2. 为请求设置缓存键（如果没有设置的话）
  3. 根据请求是否需要缓存，将请求添加到不同的队列中
    • 如果不需要缓存，直接添加到网络请求队列
    • 如果需要缓存，添加到缓存请求队列

4.3 请求的执行与响应处理

当请求被调度执行时，Volley会通过NetworkDispatcher线程从队列中取出请求并执行。下面是NetworkDispatcher类的run方法源码：

@Override
public void run() {
    // 设置线程名称，方便调试
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    
    // 循环处理请求
    while (true) {
        try {
            // 从队列中取出一个请求，如果队列为空则阻塞
            final Request<?> request = mQueue.take();
            
            try {
                // 标记请求开始执行
                request.addMarker("network-queue-take");
                
                // 如果请求已被取消，不再处理
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }
                
                // 设置请求的线程优先级
                adjustThreadPriority(request);
                
                // 执行网络请求
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                
                // 标记网络请求完成
                request.addMarker("network-http-complete");
                
                // 如果服务器返回304状态码（资源未修改），并且请求有缓存数据，则使用缓存数据
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }
                
                // 解析网络响应
                Response<?> response = request.parseNetworkResponse(networkResponse);
                
                // 标记响应解析完成
                request.addMarker("network-parse-complete");
                
                // 将响应分发到主线程
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {
                // 处理网络错误
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - requestStart);
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                // 处理其他异常
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                VolleyError volleyError = new VolleyError(e);
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - requestStart);
                mDelivery.postError(request, volleyError);
            }
        } catch (InterruptedException e) {
            // 如果线程被中断，检查是否需要退出循环
            if (mQuit) {
                return;
            }
            continue;
        }
    }
}

在请求执行过程中，关键的一步是调用request.parseNetworkResponse(networkResponse)方法来解析网络响应。对于JsonArrayRequest，这个方法的实现如下：

@Override
protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {
    try {
        // 将响应数据转换为字符串，使用指定的字符集（默认为UTF-8）
        String jsonString = new String(
                response.data,
                HttpHeaderParser.parseCharset(response.headers, PROTOCOL_CHARSET));
        
        // 将字符串解析为JSONArray对象
        return Response.success(
                new JSONArray(jsonString),
                HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        // 处理编码异常
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        // 处理JSON解析异常
        return Response.error(new ParseError(je));
    }
}

4.4 响应的分发与回调

当网络请求完成并解析出响应数据后，Volley需要将响应分发到主线程，并调用我们设置的回调监听器。这一过程是通过ResponseDelivery接口实现的，默认实现是ExecutorDelivery类。

下面是ExecutorDelivery类的postResponse方法源码：

@Override
public void postResponse(Request<?> request, Response<?> response) {
    postResponse(request, response, null);
}

@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
    // 标记响应已交付
    request.markDelivered();
    request.addMarker("post-response");
    
    // 创建一个执行响应回调的任务
    ResponseDeliveryRunnable r = new ResponseDeliveryRunnable(request, response, runnable);
    
    // 将任务提交到主线程执行
    mResponsePoster.execute(r);
}

ResponseDeliveryRunnable是一个实现了Runnable接口的内部类，它的run方法会调用请求的deliverResponse方法：

private class ResponseDeliveryRunnable implements Runnable {
    private final Request mRequest;
    private final Response mResponse;
    private final Runnable mRunnable;

    public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {
        mRequest = request;
        mResponse = response;
        mRunnable = runnable;
    }

    @Override
    public void run() {
        // 如果请求已被取消，不执行回调
        if (mRequest.isCanceled()) {
            mRequest.finish("canceled-at-delivery");
            return;
        }
        
        // 分发响应
        if (mResponse.isSuccess()) {
            mRequest.deliverResponse(mResponse.result);
        } else {
            mRequest.deliverError(mResponse.error);
        }
        
        // 如果响应包含缓存条目，将其放入缓存
        if (mResponse.intermediate) {
            mRequest.addMarker("intermediate-response");
        } else {
            mRequest.finish("done");
        }
        
        // 执行可选的后续任务
        if (mRunnable != null) {
            mRunnable.run();
        }
    }
}

对于JsonArrayRequest，deliverResponse方法会调用我们在构造函数中传入的成功回调监听器：

@Override
protected void deliverResponse(JSONArray response) {
    // 调用成功回调监听器
    mListener.onResponse(response);
}

同样，deliverError方法会调用错误回调监听器：

@Override
public void deliverError(VolleyError error) {
    // 调用错误回调监听器
    mErrorListener.onErrorResponse(error);
}

五、请求参数设置

5.1 设置请求头

在某些情况下，我们需要为请求添加自定义头信息，例如认证令牌、内容类型等。JsonArrayRequest继承自Request类，因此可以通过重写getHeaders()方法来设置请求头。

下面是一个设置请求头的示例：

// 创建JsonArrayRequest实例
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理响应
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
        }
    }
) {
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        // 创建请求头Map
        Map<String, String> headers = new HashMap<>();
        
        // 添加自定义头信息
        headers.put("Content-Type", "application/json");
        headers.put("Authorization", "Bearer " + authToken);
        
        return headers;
    }
};

5.2 设置请求方法

JsonArrayRequest支持多种HTTP请求方法，包括GET、POST、PUT、DELETE等。可以通过构造函数的第一个参数来指定请求方法。

下面是一个使用POST方法的示例：

// 创建JSON请求体
JSONArray jsonRequest = new JSONArray();
// 添加数据到JSON数组
jsonRequest.put("data1");
jsonRequest.put("data2");

// 创建POST请求
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.POST,  // 指定请求方法为POST
    url,
    jsonRequest,  // 设置请求体
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理响应
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
        }
    }
);

5.3 设置请求超时与重试策略

Volley提供了灵活的超时与重试机制，可以通过设置RetryPolicy来控制请求的超时时间和重试策略。

下面是一个设置自定义重试策略的示例：

// 创建自定义重试策略
RetryPolicy retryPolicy = new DefaultRetryPolicy(
    5000,  // 初始超时时间（毫秒）
    3,     // 最大重试次数
    DefaultRetryPolicy.DEFAULT_BACKOFF_MULT  // 退避乘数
);

// 创建JsonArrayRequest
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    listener,
    errorListener
);

// 为请求设置重试策略
request.setRetryPolicy(retryPolicy);

DefaultRetryPolicy类的源码如下：

/**
 * 默认的重试策略实现
 */
public class DefaultRetryPolicy implements RetryPolicy {
    /** 初始超时时间（毫秒） */
    private int mCurrentTimeoutMs;

    /** 当前重试次数 */
    private int mCurrentRetryCount;

    /** 最大重试次数 */
    private final int mMaxNumRetries;

    /** 退避乘数 */
    private final float mBackoffMultiplier;

    /** 默认的初始超时时间 */
    public static final int DEFAULT_TIMEOUT_MS = 2500;

    /** 默认的最大重试次数 */
    public static final int DEFAULT_MAX_RETRIES = 1;

    /** 默认的退避乘数 */
    public static final float DEFAULT_BACKOFF_MULT = 1f;

    /**
     * 使用默认参数创建重试策略
     */
    public DefaultRetryPolicy() {
        this(DEFAULT_TIMEOUT_MS, DEFAULT_MAX_RETRIES, DEFAULT_BACKOFF_MULT);
    }

    /**
     * 使用指定参数创建重试策略
     * 
     * @param initialTimeoutMs 初始超时时间（毫秒）
     * @param maxNumRetries 最大重试次数
     * @param backoffMultiplier 退避乘数
     */
    public DefaultRetryPolicy(int initialTimeoutMs, int maxNumRetries, float backoffMultiplier) {
        mCurrentTimeoutMs = initialTimeoutMs;
        mMaxNumRetries = maxNumRetries;
        mBackoffMultiplier = backoffMultiplier;
    }

    @Override
    public int getCurrentTimeout() {
        return mCurrentTimeoutMs;
    }

    @Override
    public int getCurrentRetryCount() {
        return mCurrentRetryCount;
    }

    @Override
    public void retry(VolleyError error) throws VolleyError {
        // 增加重试次数
        mCurrentRetryCount++;
        
        // 计算新的超时时间
        mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);
        
        // 检查是否超过最大重试次数
        if (mCurrentRetryCount > mMaxNumRetries) {
            throw error;
        }
    }

    /**
     * 返回退避乘数
     */
    public float getBackoffMultiplier() {
        return mBackoffMultiplier;
    }
}

六、响应处理与解析

6.1 响应数据的解析过程

当服务器返回响应后，JsonArrayRequest会将响应数据解析为JSONArray对象。这个过程在parseNetworkResponse方法中完成：

@Override
protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {
    try {
        // 将响应数据转换为字符串，使用指定的字符集（默认为UTF-8）
        String jsonString = new String(
                response.data,
                HttpHeaderParser.parseCharset(response.headers, PROTOCOL_CHARSET));
        
        // 将字符串解析为JSONArray对象
        return Response.success(
                new JSONArray(jsonString),
                HttpHeaderParser.parseCacheHeaders(response));
    } catch (UnsupportedEncodingException e) {
        // 处理编码异常
        return Response.error(new ParseError(e));
    } catch (JSONException je) {
        // 处理JSON解析异常
        return Response.error(new ParseError(je));
    }
}

6.2 处理不同类型的响应

在实际开发中，服务器返回的JSONArray可能包含不同类型的数据结构。以下是几种常见情况的处理方法：

6.2.1 包含简单数据的JSONArray

如果JSONArray只包含简单数据类型（如字符串、数字），可以直接遍历处理：

// 假设response是服务器返回的JSONArray
for (int i = 0; i < response.length(); i++) {
    // 获取每个元素
    Object item = response.get(i);
    
    if (item instanceof String) {
        String strValue = (String) item;
        // 处理字符串值
    } else if (item instanceof Integer) {
        int intValue = (Integer) item;
        // 处理整数值
    }
}
6.2.2 包含JSONObject的JSONArray

如果JSONArray包含多个JSONObject，可以按如下方式处理：

// 假设response是服务器返回的JSONArray
for (int i = 0; i < response.length(); i++) {
    // 获取每个JSONObject
    JSONObject jsonObject = response.getJSONObject(i);
    
    // 从JSONObject中提取数据
    String name = jsonObject.getString("name");
    int age = jsonObject.getInt("age");
    boolean isStudent = jsonObject.getBoolean("isStudent");
    
    // 处理提取的数据
}
6.2.3 嵌套的JSONArray

如果JSONArray中包含另一个JSONArray，可以递归处理：

// 假设response是服务器返回的JSONArray
for (int i = 0; i < response.length(); i++) {
    // 获取每个元素
    Object item = response.get(i);
    
    if (item instanceof JSONArray) {
        // 递归处理嵌套的JSONArray
        JSONArray nestedArray = (JSONArray) item;
        processNestedArray(nestedArray);
    } else if (item instanceof JSONObject) {
        // 处理JSONObject
        JSONObject jsonObject = (JSONObject) item;
        // 提取数据...
    }
}

private void processNestedArray(JSONArray array) throws JSONException {
    // 处理嵌套的JSONArray
    for (int i = 0; i < array.length(); i++) {
        // 继续处理每个元素...
    }
}

七、错误处理机制

7.1 错误类型与处理

在使用JsonArrayRequest时，可能会遇到各种错误情况。Volley将错误封装在VolleyError类及其子类中，常见的错误类型包括：

  • TimeoutError：请求超时
  • NoConnectionError：无网络连接
  • AuthFailureError：认证失败
  • ServerError：服务器错误（状态码400-599）
  • NetworkError：网络错误
  • ParseError：解析错误

下面是一个处理各种错误的示例：

JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理成功响应
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
            if (error instanceof TimeoutError) {
                // 处理超时错误
                Log.e(TAG, "Request timeout: " + error.getMessage());
            } else if (error instanceof NoConnectionError) {
                // 处理无网络连接错误
                Log.e(TAG, "No connection: " + error.getMessage());
            } else if (error instanceof AuthFailureError) {
                // 处理认证失败错误
                Log.e(TAG, "Authentication failure: " + error.getMessage());
            } else if (error instanceof ServerError) {
                // 处理服务器错误
                Log.e(TAG, "Server error: " + error.getMessage());
                
                // 获取服务器返回的原始数据
                if (error.networkResponse != null) {
                    try {
                        String errorResponse = new String(error.networkResponse.data);
                        Log.e(TAG, "Server response: " + errorResponse);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } else if (error instanceof NetworkError) {
                // 处理网络错误
                Log.e(TAG, "Network error: " + error.getMessage());
            } else if (error instanceof ParseError) {
                // 处理解析错误
                Log.e(TAG, "Parse error: " + error.getMessage());
            } else {
                // 处理其他错误
                Log.e(TAG, "Unknown error: " + error.getMessage());
            }
        }
    }
);

7.2 自定义错误处理

除了基本的错误类型判断，还可以根据服务器返回的具体错误信息进行更细致的处理。例如，服务器可能返回包含错误码和错误消息的JSON对象：

new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        // 处理服务器错误
        if (error instanceof ServerError && error.networkResponse != null) {
            try {
                // 获取服务器返回的原始数据
                String responseData = new String(error.networkResponse.data);
                
                // 解析JSON错误信息
                JSONObject errorJson = new JSONObject(responseData);
                int errorCode = errorJson.getInt("errorCode");
                String errorMessage = errorJson.getString("message");
                
                // 根据错误码进行不同处理
                switch (errorCode) {
                    case 4001:
                        // 处理特定错误
                        showToast("Invalid parameters: " + errorMessage);
                        break;
                    case 4002:
                        // 处理另一种错误
                        showToast("Authentication failed: " + errorMessage);
                        // 可能需要跳转到登录页面
                        break;
                    default:
                        // 处理其他错误
                        showToast("Server error: " + errorMessage);
                        break;
                }
            } catch (JSONException e) {
                e.printStackTrace();
                // 无法解析JSON，使用默认错误处理
                showToast("Server error: " + error.getMessage());
            }
        } else {
            // 处理其他类型的错误
            showToast("Network error: " + error.getMessage());
        }
    }
}

八、缓存机制

8.1 Volley的缓存原理

Volley提供了灵活的缓存机制，可以减少不必要的网络请求，提高应用性能。JsonArrayRequest默认支持缓存，可以通过以下方式控制：

  • 缓存键：每个请求都有一个唯一的缓存键，默认使用请求URL
  • 缓存时间：可以通过响应头或手动设置控制缓存的有效期
  • 缓存策略：可以选择强制使用缓存、优先使用缓存等策略

8.2 缓存相关方法

JsonArrayRequest继承了Request类的缓存相关方法，主要包括：

8.2.1 shouldCache()

该方法用于指定请求是否应该被缓存，默认返回true：

@Override
public boolean shouldCache() {
    return true;
}

如果需要禁用某个请求的缓存，可以在创建请求时重写该方法：

JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    listener,
    errorListener
) {
    @Override
    public boolean shouldCache() {
        return false; // 禁用缓存
    }
};
8.2.2 getCacheKey()

该方法用于获取请求的缓存键，默认使用请求URL：

@Override
public String getCacheKey() {
    return getUrl();
}

如果需要自定义缓存键，可以重写该方法：

JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    listener,
    errorListener
) {
    @Override
    public String getCacheKey() {
        // 添加额外参数到缓存键，区分不同的请求
        return super.getCacheKey() + "?param1=value1";
    }
};

8.3 控制缓存行为

除了基本的缓存设置，还可以通过响应头来控制缓存行为。例如，服务器可以返回以下响应头：

  • Cache-Control：指定缓存策略，如max-age=3600表示缓存1小时
  • Expires：指定缓存过期时间
  • ETag：资源的唯一标识，用于验证缓存有效性

Volley会自动处理这些响应头，并根据它们来决定是否使用缓存数据。

九、高级用法

9.1 与Gson结合使用

虽然JsonArrayRequest默认将响应解析为JSONArray对象，但在实际开发中，我们通常希望将JSON数据直接映射到Java对象。这时可以结合Gson库来实现更便捷的解析。

首先，添加Gson依赖：

implementation 'com.google.code.gson:gson:2.8.8'

然后，创建数据模型类：

public class User {
    private String name;
    private int age;
    private String email;
    
    // getter和setter方法
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

接下来，创建一个自定义的Request类来处理Gson解析：

public class GsonRequest<T> extends Request<T> {
    private final Gson gson = new Gson();
    private final Class<T> clazz;
    private final Map<String, String> headers;
    private final Listener<T> listener;

    /**
     * 构造方法
     * @param method 请求方法
     * @param url 请求URL
     * @param clazz 目标Java类
     * @param headers 请求头
     * @param listener 成功回调
     * @param errorListener 失败回调
     */
    public GsonRequest(int method, String url, Class<T> clazz, Map<String, String> headers,
                      Listener<T> listener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.clazz = clazz;
        this.headers = headers;
        this.listener = listener;
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return headers != null ? headers : super.getHeaders();
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            // 将响应数据转换为字符串
            String json = new String(
                    response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            
            // 使用Gson将JSON字符串解析为目标类的对象
            return Response.success(
                    gson.fromJson(json, clazz),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            // 处理编码异常
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e) {
            // 处理JSON语法异常
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(T response) {
        // 分发响应到主线程
        listener.onResponse(response);
    }
}

使用自定义的GsonRequest获取JSON数组并解析为List：

// 创建GsonRequest实例
GsonRequest<List<User>> request = new GsonRequest<>(
    Request.Method.GET,
    url,
    new TypeToken<List<User>>() {}.getType(),
    null,
    new Response.Listener<List<User>>() {
        @Override
        public void onResponse(List<User> users) {
            // 处理解析后的用户列表
            for (User user : users) {
                Log.d(TAG, "User: " + user.getName() + ", " + user.getAge());
            }
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
            Log.e(TAG, "Error: " + error.getMessage());
        }
    }
);

// 添加到请求队列
requestQueue.add(request);

9.2 批量请求与并发控制

在某些场景下，我们需要同时发送多个请求，并在所有请求完成后执行某些操作。Volley提供了RequestFuture类来帮助实现这一点。

下面是一个批量请求的示例：

// 创建RequestFuture实例，用于获取请求结果
RequestFuture<JSONArray> future1 = RequestFuture.newFuture();
RequestFuture<JSONArray> future2 = RequestFuture.newFuture();

// 创建第一个请求
JsonArrayRequest request1 = new JsonArrayRequest(
    Request.Method.GET,
    url1,
    null,
    future1,  // 将future作为成功监听器
    future1   // 将future作为失败监听器
);

// 创建第二个请求
JsonArrayRequest request2 = new JsonArrayRequest(
    Request.Method.GET,
    url2,
    null,
    future2,  // 将future作为成功监听器
    future2   // 将future作为失败监听器
);

// 添加请求到队列
requestQueue.add(request1);
requestQueue.add(request2);

// 在后台线程中等待所有请求完成
new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            // 获取第一个请求的结果（会阻塞直到请求完成）
            JSONArray result1 = future1.get();
            
            // 获取第二个请求的结果
            JSONArray result2 = future2.get();
            
            // 处理两个请求的结果
            processResults(result1, result2);
        } catch (InterruptedException e) {
            // 处理中断异常
            e.printStackTrace();
        } catch (ExecutionException e) {
            // 处理执行异常
            e.printStackTrace();
        }
    }
}).start();

9.3 请求优先级控制

Volley允许为不同的请求设置不同的优先级，从而控制请求的执行顺序。优先级分为四个级别：LOW、NORMAL、HIGH和IMMEDIATE。

下面是一个设置请求优先级的示例：

// 创建高优先级请求
JsonArrayRequest highPriorityRequest = new JsonArrayRequest(
    Request.Method.GET,
    highPriorityUrl,
    null,
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理响应
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
        }
    }
) {
    @Override
    public Priority getPriority() {
        // 设置为高优先级
        return Priority.HIGH;
    }
};

// 创建低优先级请求
JsonArrayRequest lowPriorityRequest = new JsonArrayRequest(
    Request.Method.GET,
    lowPriorityUrl,
    null,
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理响应
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
        }
    }
) {
    @Override
    public Priority getPriority() {
        // 设置为低优先级
        return Priority.LOW;
    }
};

// 添加到请求队列
requestQueue.add(highPriorityRequest);
requestQueue.add(lowPriorityRequest);

Request类的getPriority()方法默认返回NORMAL优先级：

/**
 * 返回请求的优先级。默认返回NORMAL。
 */
@Override
public Priority getPriority() {
    return Priority.NORMAL;
}

十、性能优化与最佳实践

10.1 请求合并与批处理

在需要发送多个相关请求时，考虑将它们合并为一个请求，或者使用批处理API。这样可以减少网络请求次数，提高性能。

例如，如果需要获取多个用户的信息，可以设计一个API，允许一次请求多个用户ID：

// 合并多个用户ID到一个请求中
String userIds = "1,2,3,4,5";
String url = "https://api.example.com/users?ids=" + userIds;

// 创建单个请求获取多个用户信息
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    new Response.Listener<JSONArray>() {
        @Override
        public void onResponse(JSONArray response) {
            // 处理多个用户信息
            for (int i = 0; i < response.length(); i++) {
                JSONObject user = response.getJSONObject(i);
                // 处理用户数据
            }
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            // 处理错误
        }
    }
);

10.2 合理设置超时时间

设置合理的超时时间可以避免长时间等待无响应的请求。根据请求的类型和网络环境，调整超时时间：

// 设置较长的超时时间和更多的重试次数
request.setRetryPolicy(new DefaultRetryPolicy(
    10000,  // 超时时间10秒
    3,      // 最大重试次数
    DefaultRetryPolicy.DEFAULT_BACKOFF_MULT  // 退避乘数
));

10.3 适当使用缓存

对于不经常变化的数据，适当使用缓存可以显著提高应用性能：

// 创建请求时设置shouldCache为true（默认即为true）
JsonArrayRequest request = new JsonArrayRequest(
    Request.Method.GET,
    url,
    null,
    listener,
    errorListener
);

// 设置缓存时间
request.setShouldCache(true);

10.4 取消不再需要的请求

当Activity或Fragment销毁时，取消相关的请求，避免内存泄漏和不必要的网络请求：

@Override
protected void onStop() {
    super.onStop();
    // 取消所有带有特定标签的请求
    if (requestQueue != null) {
        requestQueue.cancelAll("myRequestTag");
    }
}

10.5 使用合适的数据结构

根据实际需求选择合适的数据结构来处理JSONArray。如果数据量较大，考虑使用Cursor或分页加载：

// 分页加载示例
private int page = 1;
private static final int PAGE_SIZE = 20;

private void loadMoreData() {
    String url = "https://api.example.com/data?page=" + page + "&size=" + PAGE_SIZE;
    
    JsonArrayRequest request = new JsonArrayRequest(
        Request.Method.GET,
        url,
        null,
        new Response.Listener<JSONArray>() {
            @Override
            public void onResponse(JSONArray response) {
                // 处理分页数据
                for (int i = 0; i < response.length(); i++) {
                    // 处理每个数据项
                }
                page++;
            }
        },
        errorListener
    );
    
    requestQueue.add(request);
}

十一、常见问题与解决方案

11.1 JSON解析错误

问题描述： 当服务器返回的JSON格式不符合预期时，会抛出JSONException。

解决方案：

  1. 检查服务器返回的JSON格式是否正确
  2. 使用try-catch块捕获JSONException并处理
  3. 使用JSON验证工具验证JSON格式
  4. 考虑使用更健壮的JSON解析库，如Gson或Jackson

11.2 请求超时问题

问题描述： 在网络状况不佳的情况下，请求可能会超时。

解决方案：

  1. 增加超时时间：request.setRetryPolicy(new DefaultRetryPolicy(10000, 3, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));
  2. 实现重试机制
  3. 考虑使用离线缓存
  4. 在UI上提供明确的加载状态提示

11.3 内存泄漏问题

问题描述： 如果Activity或Fragment销毁时，请求还在执行，可能会导致内存泄漏。

解决方案：

  1. 在Activity或Fragment的onStop()方法中取消所有请求：requestQueue.cancelAll(this);
  2. 为请求设置标签，以便批量取消：request.setTag(this);
  3. 使用弱引用避免持有Activity或Fragment的强引用

11.4 大文件下载问题

问题描述： JsonArrayRequest不适合用于大文件下载，可能导致内存溢出。

解决方案：

  1. 对于大文件下载，使用专门的下载请求类
  2. 考虑使用Volley的FileDownloadRequest或自定义请求类
  3. 实现分块下载和进度监听

十二、总结与展望

12.1 总结

通过对Android Volley JsonArrayRequest的深入分析，我们全面了解了它的工作原理、使用方法和源码实现。JsonArrayRequest作为Volley库中专门处理JSON数组响应的类，提供了简洁高效的方式来获取和解析服务器返回的JSON数组数据。

我们学习了如何创建和配置JsonArrayRequest实例，设置请求头、请求方法和重试策略；掌握了响应处理和错误处理的技巧；了解了Volley的缓存机制和性能优化方法。此外，还探讨了JsonArrayRequest的高级用法，如与Gson结合使用、批量请求和优先级控制等。

12.2 展望

尽管Volley是一个功能强大的网络请求库，但随着Android开发技术的不断发展，新的网络请求库如Retrofit、OkHttp等也越来越受欢迎。未来，Volley可能会在以下方面进行改进和发展：

  1. Kotlin协程支持：随着Kotlin成为Android开发的首选语言，Volley可能会增加对协程的支持，使异步编程更加简洁。

  2. Flow集成：与Kotlin Flow集成，提供响应式编程模式，简化数据流处理。

  3. 性能优化：进一步优化网络请求和缓存机制，提高性能和内存使用效率。

  4. 更丰富的扩展点：提供更多的扩展点，方便开发者根据自己的需求定制请求处理流程。

  5. 与其他库的集成：加强与其他流行库的集成，如Glide、Room等，提供更全面的解决方案。

总的来说，JsonArrayRequest作为Volley库的重要组成部分，为Android开发者提供了便捷的JSON数组数据处理能力。通过深入理解其原理和使用方法，开发者可以更加高效地处理网络请求，提高应用的性能和用户体验。

avatar
文章
阅读
粉丝