Volley学习笔记 | 关于源码中Request、Response、Listener泛型的理解（附XMLRequest自定义代码）

凌川江雪

发布于 2019-07-10 14:40:14

6410

发布于 2019-07-10 14:40:14

话不多说，理解了这个几个泛型之间的联系，也就能把Volley框架中自定义Request的步骤过程和原理理解个七七八八；

首先看下StringRequest的源码，如下所示：

/**
 * A canned request for retrieving the response body at a given URL as a String.
 */
public class StringRequest extends Request<String> {
    private final Listener<String> mListener;
 
    /**
     * Creates a new request with the given method.
     *
     * @param method the request {@link Method} to use
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public StringRequest(int method, String url, Listener<String> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }
 
    /**
     * Creates a new GET request.
     *
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }
 
    @Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }
 
    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }
}

类型Request源码中的parseNetworkResponse() 是对Response进行第一步的解析—— 把服务器的响应数据组织成对应类型Request的类型的Response，如：
- StringRequest中的parseNetworkResponse() 把服务器的响应数据组织成String类型， Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response)); （ Response<String> parseNetworkResponse(NetworkResponse response)，String parsed）； ImageRequest是bitmap： Response.success(bitmap, HttpHeaderParser.parseCacheHeaders(response)); （Response<Bitmap> parseNetworkResponse(NetworkResponse response) ） XMLRequest是XmlPullParser Response<XmlPullParser> parseNetworkResponse(NetworkResponse response)

@Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }

然后这个Response会传给Response.success()， Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
接着会在deliverResponse()中将这个response传给mListener.onResponse()

    @Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }

在实例化一个类型Request的时候，我们传给了构造方法一个重写了onResponse()的Listener<对应类型>，也就是说， 我们在实例化一个类型Request的时候， 在重写的onResponse()中，对Response进行了第二次解析—— 即，把首次解析组织好的数据/对象 提现成具体的业务实现；

下面是XMLRequest的自定义代码与使用例程：

使用例程：

        XMLRequest xmlRequest = new XMLRequest(
                "http://flash.weather.com.cn/wmaps/xml/china.xml",
                new Response.Listener<XmlPullParser>() {
                    @Override
                    public void onResponse(XmlPullParser response) {
                        try {
                            int eventType = response.getEventType();
                            while (eventType != XmlPullParser.END_DOCUMENT) {
                                switch (eventType) {
                                    case XmlPullParser.START_TAG:
                                        String nodeName = response.getName();
                                        if ("city".equals(nodeName)) {
                                            String pName = response.getAttributeValue(0);
                                            Log.d("TAG", "pName is " + pName);

                                            reponseContent += pName;
                                            reponseContent += "\n";
                                        }
                                        break;
                                }
                                eventType = response.next();
                            }
                            oriString = new String(reponseContent.getBytes("ISO-8859-1"), "utf-8");
                            responseText.setText(oriString);
                        } catch (XmlPullParserException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("TAG", error.getMessage(), error);
            }
        });
        mQueue.add(xmlRequest);

XMLRequest的自定义代码：

public class XMLRequest extends Request<XmlPullParser> {
 
    private final Listener<XmlPullParser> mListener;
 
    public XMLRequest(int method, String url, Listener<XmlPullParser> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }
 
    public XMLRequest(String url, Listener<XmlPullParser> listener, ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }
 
    @Override
    protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
        try {
            String xmlString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser xmlPullParser = factory.newPullParser();
            xmlPullParser.setInput(new StringReader(xmlString));
            return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (XmlPullParserException e) {
            return Response.error(new ParseError(e));
        }
    }
 
    @Override
    protected void deliverResponse(XmlPullParser response) {
        mListener.onResponse(response);
    }
 
}

附上写demo时候遇到的两个bug，以及相关的解决办法的文章： 网络安全配置问题：

Android高版本联网失败报错:Cleartext HTTP traffic to xxx not permitted解决方法

xml解析结果乱码 解决方法： new String(reponseContent.getBytes("ISO-8859-1"), "utf-8"); 相关文章：

如何去改变String的编码格式
关于"ISO-8859-1"
小结一下， 总而言之我们可以看到， public class XMLRequest extends Request<XmlPullParser>中 Request<XmlPullParser>的泛型， protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response)中 Response<XmlPullParser>的泛型， private final Listener<XmlPullParser> mListener;中 Listener<XmlPullParser>的泛型， 都是一致的， 是因，
- Request<XmlPullParser>的泛型指定自定义二级Request的类型，
- Response<XmlPullParser>的泛型表明 parseNetworkResponse()进行第一步解析的返回结果类型， 把服务器的响应数据组织成对应类型Request的类型；
- Listener<XmlPullParser>的泛型 对应着Listener传递的Response的类型， 也即表明二次解析提现业务时的操作对象（即Response，第一步解析的返回结果类型） 也即onResponse()的参数类型
另外，自定义Gson的时候，因为类型不明确，所以用T占位，使用时用对应的类作为参数即可：如例程： Response.success(mGson.fromJson(jsonString, mClass)中 mGson.fromJson(jsonString, mClass)的 mClass（private Class<T> mClass;） 对应gson.fromJson(jsonData, new TypeToken<List<T>>(){}.getType());中的 new TypeToken<List<T>>(){}.getType()