【移动应用开发技术】怎么在Android中对volley进行封装

【移动应用开发技术】怎么在Android中对volley进行封装

本篇文章给大家分享的是有关怎么在Android中对volley进行封装，在下觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着在下一起来看看吧。public

void

get()

{

String

url

=

"/cc/json/mobile_tel_segment.htm?tel=";

StringRequest

request

=

new

StringRequest(Request.Method.GET,

url,

new

Response.Listener<String>()

{

@Override

public

void

onResponse(String

s)

{

Toast.makeText(MainActivity.this,s,Toast.LENGTH_SHORT).show();

}

},

new

Response.ErrorListener()

{

@Override

public

void

onErrorResponse(VolleyError

volleyError)

{

Toast.makeText(MainActivity.this,volleyError.toString(),Toast.LENGTH_SHORT).show();

}

});

request.setTag("abcGet");

MyApplication.getHttpQueues().add(request);

}首先看一下我封装后的使用例子:

private

void

initData()

{

NewsApi.getInfo(new

NetCallback<News>()

{

@Override

public

void

OnSuccess(final

News

result)

{

mAdapter.setData(result.getResult().getData());

}

@Override

public

void

OnError(RestfulError

error)

{

}

});

}有没有看起来很舒服的感觉。好吧，让我开始盘它吧！1.首先我先去写了一个基类，用来创建一个新的request并把它加入到volley内部封装的请求队列中，代码如下：public

abstract

class

AuthenticatedRequestBase<T>

extends

Request<T>

{

private

final

static

String

TAG

=

"AuthenticatedRequestBase";

private

static

final

int

TIME_OUT

=

30000;

private

static

final

int

MAX_RETRIES

=

1;

private

static

final

float

BACKOFF_MULT

=

2f;

protected

Context

mContext;

protected

RequestQueue

mRequestQueue;

/**

*

创建新的请求，并把请求加入到请求队列requestQueue中

*

*

@param

method

*

@param

url

*

@param

cache

*

@param

errorListener

*/

@SuppressLint("LongLogTag")

public

AuthenticatedRequestBase(int

method,

String

url,

boolean

cache,

Response.ErrorListener

errorListener)

{

super(method,

url,

errorListener);

//this.setShouldCache(cache);

this.setRetryPolicy(new

DefaultRetryPolicy(

TIME_OUT,

MAX_RETRIES,

BACKOFF_MULT));

mRequestQueue

=

YZ.getInstance().getRequestQueue();

if

(mRequestQueue

==

null)

{

throw

new

IllegalArgumentException("mRequestQueue

can't

be

null");

}

mContext

=

YZ.getInstance().getContext();

if

(mContext

==

null)

{

throw

new

IllegalArgumentException("mContext

can't

be

null");

}

//如果重新发出服务器请求的时候，需要清除之前的缓存。

if

(!cache)

{

Cache

volleyCache

=

mRequestQueue.getCache();

Cache.Entry

cacheEntry

=

volleyCache.get(url);

if

(cacheEntry

!=

null)

{

volleyCache.remove(url);

Log.d(TAG,

"remove

volley

cache:"

+

url);

}

}

mRequestQueue.add(this);

}

/**

*

重写这个方法，可以在http请求头里面加入token，客户端能接受的数据类型

*

*

@return

*

@throws

AuthFailureError

*/

@CallSuper

@Override

public

Map<String,

String>

getHeaders()

throws

AuthFailureError

{

Map<String,

String>

headers

=

new

HashMap<>();

String

token

=

"";

//headers.put("Authorization",

"bearer

"

+

token);

//针对Get方法，申明接受的enum类型

//

headers.put("Accept",

"charset=utf-8");

return

headers;

}

/**

*

网络错误问题统一处理

*

*

@param

volleyError

*

@return

*/

@CallSuper

@Override

protected

VolleyError

parseNetworkError(VolleyError

volleyError)

{

return

super.parseNetworkError(volleyError);

}

}代码注释比较清晰，就不在赘述。2.以get方法为例，新建一个GetRequest去继承这个基类，并出解析结果：public

class

GetRequest<TResponse>

extends

AuthenticatedRequestBase<TResponse>

{

private

final

Response.Listener<TResponse>

listener;

private

final

Class<TResponse>

clazz;

private

final

static

String

TAG

=

"GetRequest";

private

String

mUrl;

private

NetCallback<TResponse>

cb;

private

boolean

cacheHit;

public

GetRequest(String

url,

Class<TResponse>

clazz,

boolean

cache,

NetCallback<TResponse>

callback)

{

super(Request.Method.GET,

url,

cache,

callback.getErrorListener());

this.listener

=

callback.getSuccessListener();

this.clazz

=

clazz;

this.mUrl

=

url;

this.cb

=

callback;

//无网络时300ms后返回callback

if

(!NetUtils.isConnect(mContext)

&&

mRequestQueue.getCache().get(url)

==

null)

{

Handler

handler

=

new

Handler();

handler.postDelayed(new

Runnable()

{

@Override

public

void

run()

{

cb.OnNetworkOff();

}

},

300);

}

}

/**

*

这个是缓存的标记，与本地缓存相关

*

@param

tag

*/

@Override

public

void

addMarker(String

tag)

{

super.addMarker(tag);

cacheHit

=

tag.equals("cache-hit");

}

@Override

protected

Response<TResponse>

parseNetworkResponse(NetworkResponse

response)

{

Gson

gson

=

new

Gson();

//无网络时，使用本地缓存,通过url去匹配缓存，volley

sdk是通过url创建不同的文件来实现缓存的

if

(!NetUtils.isConnect(mContext)

&&

mRequestQueue.getCache().get(mUrl)

!=

null)

{

String

json

=

new

String(mRequestQueue.getCache().get(mUrl).data);

Log.d(TAG,

"url=="

+

mUrl

+

",json"

+

json);

cb.fResponseCacheStatus

=

ResponseCacheStatus.StaleFromCache;

return

Response.success(gson.fromJson(json,

clazz),

parseCacheHeaders(response));

}

//数据是否有更新

try

{

if

(response.statusCode

==

304)

{

//服务端返回缓存数据

cb.fResponseCacheStatus

=

ResponseCacheStatus.NotModifiedFromServer;

}

else

if

(response.statusCode

==

200)

{

if

(cacheHit)

{

//使用本地缓存

cb.fResponseCacheStatus

=

ResponseCacheStatus.FreshFromCache;

}

else

{

//使用服务端更新数据

cb.fResponseCacheStatus

=

ResponseCacheStatus.NewFromServer;

}

}

else

{

cb.fResponseCacheStatus

=

ResponseCacheStatus.NewFromServer;

}

Log.d(TAG,

"fResponseCacheStatus

=

"

+

cb.fResponseCacheStatus);

String

json

=

new

String(response.data,

parseCharset(response.headers));

return

Response.success(gson.fromJson(json,

clazz),

parseCacheHeaders(response));

}

catch

(UnsupportedEncodingException

|

JsonSyntaxException

e)

{

return

Response.error(new

ParseError(e));

}

}

@Override

protected

void

deliverResponse(TResponse

response)

{

listener.onResponse(response);

}

@Override

protected

VolleyError

parseNetworkError(VolleyError

volleyError)

{

return

super.parseNetworkError(volleyError);

}

}3.上面只做了返回成功的处理方式，返回失败时由NetCallback内部统一处理：@UiThread

public

abstract

class

NetCallback<TResponse>

{

public

ResponseCacheStatus

fResponseCacheStatus

=

ResponseCacheStatus.NewFromServer;

private

String

TAG

=

this.getClass().getSimpleName();

public

boolean

enableAutomaticToastOnError

=

true;

public

NetCallback()

{

}

public

NetCallback(boolean

enableAutomaticToastOnError)

{

this.enableAutomaticToastOnError

=

enableAutomaticToastOnError;

}

public

abstract

void

OnSuccess(TResponse

result);

public

abstract

void

OnError(RestfulError

error);

public

void

OnNetworkOff()

{

//do

nothing

,use

it

according

to

requirement

}

public

Response.Listener<TResponse>

getSuccessListener()

{

return

new

Response.Listener<TResponse>()

{

@Override

public

void

onResponse(TResponse

result)

{

OnSuccess(result);

}

};

}

public

Response.ErrorListener

getErrorListener()

{

return

new

Response.ErrorListener()

{

@Override

public

void

onErrorResponse(VolleyError

volleyError)

{

if

(volleyError

instanceof

TimeoutError)

{

Log.e(TAG,

"networkResponse

==

null");

//volley

TimeoutError

OnError(new

RestfulError());

}

if

(volleyEworkResponse

!=

null)

{

int

statusCode

=

volleyEworkResponse.statusCode;

String

errorMessage

=

new

String(volleyEworkResponse.data);

switch

(statusCode)

{

case

401:

//post

a

Permission

authentication

failed

event

break;

default:

Log.d(TAG,

"errorMessage

="

+

errorMessage);

try

{

RestfulError

error

=

new

Gson().fromJson(errorMessage,

RestfulError.class);

if

(enableAutomaticToastOnError

&&

error.getCode()

!=

null)

{

//toast(error.ExceptionMessage);

//toast

it

in

main

thread

}

OnError(error);

}

catch

(Exception

e)

{

OnError(new

RestfulError());

Log.d(TAG,

"e

="

+

e.toString());

}

break;

}

}

}

};

}

}4.注意到没有，在AuthenticatedRequestBase内部有一个环境类YZ,主要负责获取项目主程序中的context和请求队列：public

class

YZ

implements

AppRequestQueue

{

private

static

final

int

DEFAULT_VOLLEY_CACHE_SIZE

=

100

*

1024

*

1024;

private

Context

context;

private

int

cacheSize;

private

YZ()

{

}

@Override

public

RequestQueue

getRequestQueue()

{

return

Volley.newRequestQueue(context,

cacheSize);

}

public

Context

getContext()

{

return

context;

}

private

static

class

SingletonHolder

{

private

static

YZ

instance

=

new

YZ();

}

public

static

YZ

getInstance()

{

return

SingletonHolder.instance;

}

/**

*

need

a

app

context

*

*

@param

appContext

*/

public

void

init(final

Context

appContext)

{

init(appContext,

DEFAULT_VOLLEY_CACHE_SIZE);

}

/**

*

@param

appContext

*

@param

cacheSize

*/

pub