android网络框架volley学习之基本数据类

volley网络框架中并没有直接采用android中已有的请求类和响应类，而是自己定义了这些类，将请求和响应封装在自定义的类中。为了实现缓存机制，同时定义了缓存体类和缓存头类。

在介绍Request类之前，先介绍一下请求和响应的结构。请求体是客户端向服务器发出请求的数据的包装，它由请求行、请求头和请求体构成。其中请求行中包含着请求方法（一般是GET和POST）、请求路径和所使用的协议版本。整个请求的结构如下图所示：





请求消息的结构 响应消息的结构
备注：对于GET方法来说，请求体中一般为空，它的请求体一般放在请求路径中。
而响应同样由三部分构成：响应行(由协议版本、响应码和message组成)、响应头和响应体构成，结构如上图所示。
具体的请求头和响应头有如下几种：



下面逐个查看这几个基本的数据类：
Request类

public abstract class Request<T> implements Comparable<Request<T>>{

//设置参数的编码格式
private static final String DEFAULT_PARAMS_ENCODING = "utf-8";

//定义方法接口
public interface Methods{
int DEFAULT_GET_OR_POST = -1;
int GET = 0;
int POST = 1;
int PUT = 2;
int DELETE = 3;
}

//访问的网络地址
private final String mUrl;

//在请求队列中的位置
private Integer mSequeue;

//当前请求所在的队列
private RequestQueue mRequestQueue;

//当前请求是否需要缓存
private boolean mShouldCache;

//当前请求是否取消
private boolean mCanceled = false;

//当前请求的请求方法
private int mMethod;

//标志
private Object mTag;

//当前请求的 缓存体
private Cache.Entry mCacheEntry;

//错误传送接口
private Response.ErrorLister<T> mErrorListener;

//请求构造函数
public Request(int method,String url,Response.ErrorLister listener){
this.mMethod = method;
this.mUrl = url;
this.mErrorListener = listener;
}

//设置请求的方法
public void setMethod(int method){
this.mMethod = method;
}

//获取请求的方法
public int getMethod(){
return mMethod;
}

//设置标志
public void setTag(Object tag){
this.mTag = tag;
}
//获取标志
public Object getTag(){
return mTag;
}

//为当前请求设置它所属的请求队列
public void setRequestQueue(RequestQueue requestQueue){
this.mRequestQueue = requestQueue;
}

//为当前请求设置在队列中的位置
public final void setSequeue(int sequeue){
this.mSequeue = sequeue;
}

//获取当前请求在队列中的位置
public int getSequeue(){
return mSequeue;
}

//获取请求的url地址
public String getUrl(){
return mUrl;
}

//获取缓存的关键字 这里将url作为缓存的关键字
public String getCacheKey(){
return getUrl();
}

//设置缓存体
public void setCacheEntry(Cache.Entry entry){
this.mCacheEntry = entry;
}

//获取存在当前请求中的缓存体
public Cache.Entry getCacheEntry(){
return mCacheEntry;
}

//取消当前的请求
public void cancel(){
mCanceled = true;
}

//判断 当前请求是否取消
public boolean isCancel(){
return mCanceled;
}

//设置当前请求是否需要缓存
public final void setShouldCache(boolean shoulsCache){
mShouldCache = shoulsCache;
}

//判断当前请求是否需要缓存
public boolean shouldCache(){
return mShouldCache;
}

//获取当前请求的请求头。如果网络访问时需要此信息，则重写此方法向Map中添加请求头信息。
public Map<String,String> getHeaders(){
return Collections.emptyMap();
}

//获取当前请求的请求参数，请求有参数时需要重写此方法。
protected Map<String, String> getParams(){
return null;
}

//对于post请求获取它的请求参数，
protected Map<String, String> getPostParams(){
return getParams();
}

//获取post请求参数的编码格式
protected String getPostParamsEncoding(){
return getParamsEncoding();
}
//获取请求参数的编码
private String getParamsEncoding() {
return DEFAULT_PARAMS_ENCODING;
}

//获取post请求的请求内容类型
public String getPostBodyContentType(){
return getBodyContentType();
}

//获取请求的请求内容类型
public String getBodyContentType() {
return "application/x-www-form-urlencoded; charset="+DEFAULT_PARAMS_ENCODING;
}

public byte[] getBody(){
Map<String, String> params = getParams();
if(params != null && params.size()>0){
return encodeParameters(params,getParamsEncoding());
}
return null;
}
//根据传递的编码方式将获取到的参数转换成字节数组
private byte[] encodeParameters(Map<String, String> params,
String paramsEncoding) {
StringBuilder encodedParams = new StringBuilder();
try {
for(Map.Entry<String, String> entry : params.entrySet()){
encodedParams.append(URLEncoder.encode(entry.getKey(), paramsEncoding));
encodedParams.append('=');
encodedParams.append(URLEncoder.encode(entry.getValue(), paramsEncoding));
encodedParams.append('&');
}
return encodedParams.toString().getBytes(paramsEncoding);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

//需要重写的方法 将NetworkResponse对象转化成 Response对象
abstract protected Response<T> parseNetworkResponse(NetworkResponse response);

/*需要重写的方法 负责将response对象解析后传回客户端，一般情况下 自定义的request会在其构造函数中引入一个
response.Listener参数，再重写此方法时调用mListener.onResponse()方法，让response在其中被解析并传回客户端*/
abstract protected void deliverResponse(T response);

//发生错误时，移交给错误监听器处理
public void deliverError(VolleyError error){
if(mErrorListener != null){
mErrorListener.onErrorResponse(error);
}
}
public void finish(){
if(mRequestQueue != null){
mRequestQueue.finish(this);
}
}
//为请求事件添加一个事件输出，用于调试程序
public void addMarker(String tag) {
if(MarkerLog.ENABLED){
mEventLog.add(tag,Thread.currentThread().getId());
}else if(mRequestBirthTime == 0){
mRequestBirthTime = SystemClock.elapsedRealtime();
}
}
@Override
public int compareTo(Request<T> arg0) {
// TODO Auto-generated method stub
return 0;
}
public int getTimeoutMs() {
// TODO Auto-generated method stub
return 0;
}

}

NetworkResponse类

此类为response的一个过度类，由标准的HttpResponse响应重新构造而成。由它的构造函数不然看出，这个类中封装了响应的状态码、响应体和响应头以及判断服务器对应的资源是否修改。

//属性：状态码  数据   响应头
public NetworkResponse(int statusCode, byte[] data, Map<String, String> headers,
boolean notModified) {
this.statusCode = statusCode;
this.data = data;
this.headers = headers;
this.notModified = notModified;
}

Response类

response类相对简单点，它主要封装了由用户通过实现abstract protected Response<T> parseNetworkResponse( response)从networkResponse对象中将数据进行解析，转化成客户端所需要的数据格式(客户端需要图片则将数据通过文件输出流转换成图片，如果需要字符串则生成字符串)。

public static <T> Response<T> success(T result, Cache.Entry cacheEntry) {
return new Response<T>(result, cacheEntry);
}
private Response(T result, Cache.Entry cacheEntry) {
this.result = result;
this.cacheEntry = cacheEntry;
this.error = null;
}

Entry类

public class Entry {
//本地缓存的响应体
public byte[] data;
//标志
public String etag;
//缓存的生存时间
public long ttl;
//缓存的soft生存时间(不太懂)
public long softTtl;
//服务器做出此响应的时间
public long serverDate;
//响应头
public Map<String, String> responseHeaders = Collections.emptyMap();
//是否过期
public boolean isExpired(){
return this.ttl < System.currentTimeMillis();
}
//是否需要更新
public boolean refreshNeeded(){
return this.softTtl < System.currentTimeMillis();
}
}

CacheHeader类

此类将entry类的数据换成数据的长度。个人觉得这个类的存在就是为了减少内存的占有，不然在DiskBasedCache类中的map集合中要添加entry类显然是内存的过度的消耗，故volley设计者设计CacheHeader类提供一个类似于索引的功能。

static class CacheHeader {

//缓存的大小
public long size;

//缓存头的关键字
public String key;

//缓存头的标志
public String etag;
public long serverDate;
public long ttl;
public long softTtl;
public Map<String, String> responseHeaders;
private CacheHeader() { }
//由缓存体转换成缓存头
public CacheHeader(String key, Entry entry) {
this.key = key;
this.size = entry.data.length;
this.etag = entry.etag;
this.serverDate = entry.serverDate;
this.ttl = entry.ttl;
this.softTtl = entry.softTtl;
this.responseHeaders = entry.responseHeaders;
}
//由缓存头构造缓存体
public Entry toCacheEntry(byte[] data) {
Entry e = new Entry();
e.data = data;
e.etag = this.etag;
e.serverDate = this.serverDate;
e.softTtl = this.softTtl;
e.ttl = this.ttl;
e.responseHeaders = this.responseHesders;
return e;
}

以上就是Volley网络框架中的自定义的基本数据类，了解他们的结构有助于再往下深入学习此框架的逻辑处理结构。

不对请指正，谢谢！