《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 = 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);
}