第一步：
第一层：Request--请求类型，JSON，字符串，文件
第二层：消息队列--维护了提交给网络框架的请求列表，并且根据响应的规则进行排序。默认情况下按照优先级和进入队列的顺序来执行，该队列使用的是线程安全的PriorityBlockingQueue<E>，因为我们的队列会被并发访问，因此需要保证队列访问的原子性
第三层：NetworkExecutor--网络执行者，该Eexcutor继承自Thread，在run方法中循环访问请求队列，从请求队列中获取并执行HTTP请求，请求完成之后将结果投递给UI线程
第四层：Response以及Response投递类，使用ResponseDelivery来封装Response的投递，保证Response执行在UI线程。而Response会根据用户的不同需求将返回结果格式化为特定的类型。
第二步：网络请求类
public static enum HttpMethod{
GET("GET"),
POST("POST"),
PUT("PUT"),
DELETE("DELETE");
/** http request type */
private String mHttpMethod = "";
privte HttpMethod(String method){
mHttpMethod = method;
}
@Override
public String toString(){
return mHttpMethod;
}
}
//优先级枚举
public static enum Priority{
LOW,
NORMAL,
HIGH,
IMMEDIATE
}
/**
* 网络请求类，注意GET和DELETE不能传递请求参数，因为其请求的性质所致，用户可以将参数构建到URL后传递进来并到Request中
* @param <T> T为请求返回的数据类型
*/
public abstract class Request<T> implements Comparable<Request<T>>{
//默认的编码方式
private static final String DEFAULT_PARAMS_ENCODING = "UTF-8";
//请求序列号
protected int mSerialNum = 0;
//优先级默认设置为Normal
protected Priority mPriority = Priority.NORMAL;
//是否取消该请求
protected boolean isCancel = false;
/** 改请求是否应该缓存*/
private boolean mShouldCache = true;
//请求Listener
protected RequestListener<T> mRequestlistener;
//请求的URL
private String mUrl = "";
//请求的方法
HttpMethod mHttpMethod = HttpMethod.GET;
//请求的header
private Map<String,String> mHeaders = new HashMap<String,String>();
//请求参数
private Map<String,String> mBodyParams = new HashMap<String,String>(); /**
* @param method 请求方式
* @param url 请求的目标URL
* @param listener 请求回调，将结果回调给用户
*/
public Request(HttpMethod method,String url,RequestListener<T> listener){
mHttpMethod = method;
mUrl = url;
mRequestlistener = listener;
} //从原生的网络请求中解析结果，子类必须覆写
public abstract T parseResponse(Response response); //处理Response，该方法需要运行在UI线程
public final void deliveryResponse(Response response){
//解析得到请求结果
T result = parseResponse(response);
if(mRequestlistener!=null){
int stCode = response !=null?response.getStatusCode:-1;
String msg = response !=null?response.getMessage():"unknown error";
mRequestlistener.onComplete(stCode,result,msg);
}
}
//代码省略 protected String getParamsEncoding(){
return DEFAULT_PARAMS_ENCODING;
} public String getBodyContentType(){
return "application/x-www-form-urlencoded;charset="+getParamsEncoding();
} //返回POST或者PUT请求时的Body参数字节数组
public byte[] getBody(){
Map<String,String> params = getParams();
if(params!=null && params.size()>0){
return encodeParameters(params,getParamsEncoding());
}
return null;
} //将参数转换为URL编码的参数串，格式为key1=value1&key2=value2
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(UnsupportEncodingException uee){
throw new RuntimeException("Encoding not supported:"+paramsEncoding,uee);
}
} //用于对请求的排序处理，根据优先级和加入到队列的序号进行排序
@Override
public int compareTo(Request<T> another){
Priority myPriority = this.getPriority();
Priority anotherPriority = another.getPriority();
//如果优先级相等，那么按照添加到队列的序列号顺序来执行
return myPriority.equals(another)?this.getSerialNumber()-another.getSerialNumber():myPriority.ordinal()-anotherPriority.ordinal();
} /**
*网络请求Listener，会被执行在UI线程
*@param <T> 请求的response类型
*/
public static interface RequestListener<T>{
//请求完成的回调
public void onComplete(int stCode,T response,String errMsg);
}
}
HTTP实际上是基于TCP协议，而TCP协议又是基于Socket，Socket实际上操作的也就是输入、输出流，输出流是向服务器写数据，输入流是从服务器读取数据。
第三步：响应类
//请求结果类，继承自BasicHttpResponse,将结果存储在rawData中
public class Response extends BasicHttpResponse{
//原始的Response主体数据
public byte[] rawData = new byte[0]; public Response(StatusLine statusLine){
super(statusLine);
} public Response(ProtocolVersion ver,int code,String reason){
super(ver,code,reason);
} @Override
public void setEntity(HttpEntity entity){
super.setEntity(entity);
rawData = entityToBytes(getEntity());
} public byte[] getRawData(){
return rawData;
} //代码省略
/**Reads the contents of HttpEntity into a byte[].*/
private byte[] entityToBytes(HttpEntity entity){
try{
return EntityUtils.toByteArray(entity);
}catch(IOException e){
e.printStackTrace();
}
return new byte[0];
}
}
第四步：请求队列
网络请求队列就是在内部封装了一个优先级队列，在构建队列时会启动指定个数的NetworkExecutor（继承自Thread）来从请求队列中获取、执行请求，请求队列会根据请求的优先级、序列号对所有Request进行排序。
//请求队列，使用优先队列，使得请求可以按照优先级进行处理
public final class RequsetQueue{
//线程安全的请求队列
private BlockingQueue<Request<?>> mRequestQueue = new PriorityBlockingQueue<Request<?>>();
//请求的序列化生成器
private AtomicInteger mSerialNumGenerator = new AtomicInteger(0);
//默认的核心数 为CPU格式加1
private int mDispatcherNums = DEFAULT_CORE_NUMS;
//NetworkExecutor,执行网络请求的线程
private NetworkExecutor[] mDispatchers = null;
//Http请求的真正执行者
private HttpStack mHttpStack; protected RequestQueue(int coreNums,HttpStack httpStack){
mDispatcherNums = coreNums; mHttpStack = httpStack !=null?httpStack:HttpStackFactory.createHttpStack();
} //启动NetworkExecutor
private final void startNetworkExecutors(){
mDispatchers = new NetworkExecutor[mDispatchNums];
for(int i=0;i<mDispatchNums;i++){
mDispatchers[i] = new NetworkExecutor(mRequestQueue,mHttpStack);
mDispatchers[i].start();
}
} public void start(){
stop();
startNetworkExecutors();
} /**
* 停止NetworkExecutor
*/
public void stop(){
if(mDispatchers!=null && mDispatchers.length>0){
for(int i=0;i<mDispatchers.length;i++){
mDispatchers[i].quit();
}
}
} //添加请求到队列中
public void addRequest(Request<?> request){
if(!mRequestQueue.contains(request)){
//为请求设置序列号
request.setSerialNumber(this.generateSerialNumber());
mRequestQueue.add(request);
}else{
Log.d("","### 请求队列中已经含有");
}
} //代码省略
//为每个请求生成一个系列号
private int generateSerialNumber(){
return mSerialNumGenerator.incrementAndGet();
}
}
第五步：NetworkExecutor网络执行器
多个NetworkExecutor共享一个消息队列，在各个NetworkExecutor的run函数中循环地取请求队列中的请求，拿到一个请求之后通过HttpStack对象来真正地执行请求，最终将请求结果通过ResponseDelivery分发给UI线程。
NetworkExecutor实质上是一个Thread，在run方法中我们会执行一个循环，不断地从请求队列中取得请求，然后交给HttpStack。
//网络请求Exector，继承自Thread，从网络请求队列中循环读取请求并且执行
final class NetworkExecutor extends Thread{
//网络请求队列
private BlockingQueue<Request<?>> mRequestQueue;
//网络请求栈
private HttpStack mHttpStack;
//结果分发器，将结果投递到主线程
private static ResponseDelivery mResponseDelivery = new ResponseDelivery();
//请求缓存
private static Cache<String,Response> mReqCache = new LruMemCache();
//是否停止
private boolean isStop = false; public NetworkExecutor(BlockingQueue<Request<?>> queue,HttpStack httpStack){
mRequestQueue = queue;
mHttpStack = httpStack;
} @Override
public void run(){
try{
while(!isStop){
final Request<?> request = mRequestQueue.take();
if(request.isCanceled()){
Log.d("###","### 取消执行了");
continue;
}
Response response = null;
if(isUseCache(request)){
//从缓存中取
response = mReqCache.get(request.getUrl());
}else{
//从网络中获取数据
response = mHttpCache.get(request.getUrl());
}else{
//从网络上获取数据
response = mHttpStack.performRequest(request);
//如果该请求需要缓存，那么请求成功则缓存到mResponseCache中
if(request.shouldCache() && isSuccess(response)){
mReqCache.put(request.getUrl(),response);
}
}
//分发请求结果
mResponseDelivery.deliveryResponse(request,response);
}
}catch(InterruptedExecption e){
Log.i("","### 请求分发器退出");
}
} private boolean isSuccess(Response response){
return reponse!=null && response.getStatusCode()==200;
} private boolean isUseCache(Request<?> request){
return request.shouldCache() && mReqCache.get(request.getUrl())!=null;
} public void quit(){
isStop = true;
interrupt();
}
}
第六步：执行网络请求的接口--HttpStack
//执行网络请求的接口
public interface HttpStack{
/**
* 执行HTTP请求
* @param request 待执行的请求
* @retrun 返回Response
*/
public Response performRequest(Request<?> request);
}
//使用HttpURLConnection执行网络请求的HttpStack
public class HttpUrlConnStack implements HttpStack{
@Override
public Response performRequest(Request<?> request){
HttpURLConnection urlConnection = null;
try{
//构建HttpURLConnection
urlConnection = createUrlConnection(request.getUrl());
//设置headers
setRequestHeaders(urlConnection,request);
//设置Body参数
setRequestParams(urlConnection,request);
return fetchResponse(urlConnection);
}catch(Exception e){
e.printStackTrace();
}finally{
if(urlConnection!=null){
urlConnection.disconnect();
}
}
return null;
} private HttpURLConnection createUrlConnection(String url) throws IOException{
URL newURL = new URL(url);
URLConnection urlConnection = newURL.openConnection();
urlConnection.setConnectTimeout(mConfig.connTimeOut);
urlConnection.setReadTimeout(mConfig.soTimeOut);
urlConnection.setDoInput(true);
urlConnection.setUseCaches(false);
return (HttpURLConnection)urlConnection;
} private void setRequestHeaders(HttpURLConnection connection,Request<?> request){
Set<String> headersKeys = request.getHeaders().keySet();
for(String headerName : headersKeys){
connection.addRequestProperty(headerName,request.getHeaders().get(headerName));
}
} protected void setRequestParams(HttpURLConnection connection,Request<?> request) throws ProtocolException,IOException{
HttpMethod method = request.getHttpMethod();
connection.setRequestMethod(method.toString());
//add params
byte[] body = request.getBody();
if(body!=null){
//enable output
connection.setDoOutput(true);
//set content type
connection.addRequestProperty(Request.HEADER_CONTENT_TYPE,request.getBodyContentType());
//write params data to connection
DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream());
dataOutputStream.write(body);
dataOutputStream.close();
}
} private Response fetchResponse(HttpURLConnection connection) throws IOException{
//Initialize HttpResponse with data from the HttpURLConnection
ProtocolVersion protocolVersion = new ProtocolVersion("HTTP",1,1);
int responseCode = connection.getResponseCode();
if(responseCode == -1){
throw new IOException("Could not retrieve response code from HttpURLConnection.");
}
//状态行数据
StatusLine responseStatus = new BasicStatusLine(ptocolVersion,connection.getResponseCode(),connection.getResponseMessage());
//构建response
Response response = new Response(responseStatus);
//设置response数据
response.setEntity(entityFromURLConnection(connection));
addHeadersToResponse(response,connection);
return response;
} /**
* 执行HTTP请求之后获取到其数据流，即返回请求结果的流
* @param connection
* @return
*/
private HttpEntity entityFromURLConnection(HttpURLConnection connection){
BasicHttpEntity entity = new BasicHttpEntity();
InputStream inputStream = null;
try{
inputStream = connection.getInputStream();
}catch(IOException e){
e.printStackTrace();
inputStream = connection.getErrorStream();
}
//TODO:GZIP
entity.setContent(inputStream);
entity.setContentlength(connection.getContentLength());
entity.setContentEncoding(connection.getContentEncoding());
entity.setContentType(connection.getContentType());
return entity;
} private void addHeadersToResponse(BasicHttpResponse response,HttpURLConnection connection){
for(Entry<String,List<String>> header : connection.getHeaderFields().entrySet()){
if(header.getKey() != null){
Header h = new BasicHeader(header.getKey(),header.getValue().get(0));
response.addHeader(h);
}
}
}
}
简单来说：构建HttpURLConnection，并通过HttpURLConnection对象设置请求Header、参数，然后发起请求，请求完成只有解析结果，并返回Response。
第七步：将请求的回调执行到UI线程--ResponseDelivery
//请求结果投递类，将请求结果投递给UI线程
class ResponseDelivery implements Executor{
//关联主线程消息队列的hander
Hander mResponseHandler = new Handler(Looper.getMainLooper());
/**
* 处理请求结果，将其执行在UI线程
* @param request
* @param response
*/
public void deliveryResponse(final Request<?> request,final Response response){
Runnable respRunnable = new Runnable(){
@Override
public void run(){
request.deliveryResponse(response);
}
}; execute(respRunnable);
} @Override
public void execute(Runnable command){
mResponseHandler.post(command);
}
}
ResponseDelivery其实就是封装了关联了UI线程消息队列的Handler。
使用：
//1.构建并启动请求队列
RequestQueue mQueue = SimpleNet.newRequestQueue();
/**
* 发送GET请求，返回的是String类型的数据，同理还有{@see JsonRequest}、{@see MultipartRequest}
*/
private void sendStringRequest(){
//2.构建请求
StringRequest request = new StringRequest(HttpMethod.GET,"http://www.baidu.com",
new RequestListener<String>(){
@Override
public void onComplete(int stCode,String response,String errMsg){
//处理结果
}
});
//3.将请求添加到请求队列中
mQueue.addRequest(request);
}