《android开发进阶从小工到专家》读书笔记--网络框架的设计与实现 _Android开发

归志宁无五亩园，读书本意在元元。这篇文章主要讲述《android开发进阶从小工到专家》读书笔记--网络框架的设计与实现相关的知识，希望能为你提供帮助。
第一步：

文章图片

第一层：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 = https://www.songbingjia.com/android/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); }

【《android开发进阶从小工到专家》读书笔记--网络框架的设计与实现】