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

}

巴特西

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

最新文章

热门文章