Xutils HttpUtils上传文件的实现

今天解决了一个网络请求方面的bug， 在解决之余 熟悉了一下我们项目中网络请求用到的框架， 目前用的还是比较老的xUtils来处理http请求，闲暇之余对这部分流程进行了一番跟踪并做一下记录， 方便日后记忆学习

在理解Utils实现上传功能的流程之前， 需要对另外一个东东有所了解---HttpClient.java.  它是Apache http包里的一个类， 利用此类也可以实现上传文件的功能， 具体实现如下：

public void upload(String localFile){
         File file = new File(localFile);
         PostMethod filePost = new PostMethod(URL_STR);
         HttpClient client = new HttpClient();
         
         try {
             // 通过以下方法可以模拟页面参数提交
             filePost.setParameter("userName", userName);
             filePost.setParameter("passwd", passwd);
 
             Part[] parts = { new FilePart(file.getName(), file) };
             filePost.setRequestEntity(new MultipartRequestEntity(parts, filePost.getParams()));
             
             client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
             
             int status = client.executeMethod(filePost);
             if (status == HttpStatus.SC_OK) {
                 System.out.println("上传成功");
             } else {
                 System.out.println("上传失败");
             }
         } catch (Exception ex) {
             ex.printStackTrace();
         } finally {
             filePost.releaseConnection();
         }
}

如上所述，通过HttpClient.executeMethod(PostMethod)的方式也可以实现上传文件的功能，  而在本文所讲的xUtils的上传功能实际上也是对HttpClient的封装， 提供统一接口，不必书写冗长的代码， 并添加了缓冲，重连，断点续传等功能。

以下代码是使用xUtils实现上传的demo

//实例化HttpUtils对象， 参数设置链接超时
HttpUtils HTTP_UTILS = new HttpUtils(60 * 1000);
//实例化RequestParams对象
RequestParams requestParams = new RequestParams();
//requestParams.setContentType("multipart/form-data");
StringBuilder picFileName = new StringBuilder();
picFileName.append(DeviceInfo.getInstance().getGetuiClientId())
           .append(NotifyUtil.getCurrentTime()).append(".png");
requestParams.addBodyParameter("picFileName", picFileName.toString());
//imageFile是File格式的对象， 将此File传递给RequestParams
requestParams.addBodyParameter("picFile", imageFile, "image/png");
requestParams.addBodyParameter("platform", "Android");
String photoUrl = Config.getUploadPhotoUrl();
//通过HTTP_UTILS来发送post请求， 并书写回调函数
HTTP_UTILS.send(HttpMethod.POST, url, params, new com.lidroid.xutils.http.callback.RequestCallBack<String>() {
            @Override
            public void onFailure(HttpException httpException, String arg1) {
                
            }

            @Override
            public void onSuccess(ResponseInfo<String> responseInfo) {
                
            }
        });
}

可以看到使用方法就是创建一个RequestParams与一个Url， 然后通过xUtils中的HttpUtils.send方法发送请求上传imageFile这个文件，并通过RequestCallBack这个类来回调处理返回的数据， 接下来就看一下具体流程：

首先看先HttpUtils.java

public HttpUtils(int connTimeout, String userAgent) {
    HttpParams params = new BasicHttpParams();

    ConnManagerParams.setTimeout(params, connTimeout);
    HttpConnectionParams.setSoTimeout(params, connTimeout);
    HttpConnectionParams.setConnectionTimeout(params, connTimeout);

    if (TextUtils.isEmpty(userAgent)) {
        userAgent = OtherUtils.getUserAgent(null);
    }
    HttpProtocolParams.setUserAgent(params, userAgent);

    ConnManagerParams.setMaxConnectionsPerRoute(params, new ConnPerRouteBean(10));
    ConnManagerParams.setMaxTotalConnections(params, 10);

    HttpConnectionParams.setTcpNoDelay(params, true);
    HttpConnectionParams.setSocketBufferSize(params, 1024 * 8);
    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    schemeRegistry.register(new Scheme("https", DefaultSSLSocketFactory.getSocketFactory(), 443));

    <span style="color:#FF0000;">//这个是核心类，最终就是调用这个HttpClient的方法去向服务端发送请求，上传文件</span>
    httpClient = new DefaultHttpClient(new ThreadSafeClientConnManager(params, schemeRegistry), params);

    httpClient.setHttpRequestRetryHandler(new RetryHandler(DEFAULT_RETRY_TIMES));

    httpClient.addRequestInterceptor(new HttpRequestInterceptor() {
        @Override
        public void process(org.apache.http.HttpRequest httpRequest, HttpContext httpContext) throws org.apache.http.HttpException, IOException {
            if (!httpRequest.containsHeader(HEADER_ACCEPT_ENCODING)) {
                httpRequest.addHeader(HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
            }
        }
    });
    httpClient.addResponseInterceptor(new HttpResponseInterceptor() {
         @Override
         public void process(HttpResponse response, HttpContext httpContext) throws org.apache.http.HttpException, IOException {
             final HttpEntity entity = response.getEntity();
             if (entity == null) {
                 return;
             }
             final Header encoding = entity.getContentEncoding();
             if (encoding != null) {
                 for (HeaderElement element : encoding.getElements()) {
                     if (element.getName().equalsIgnoreCase("gzip")) {
                         response.setEntity(new GZipDecompressingEntity(response.getEntity()));
                         return;
                     }
                 }
             }
         }
     });
 }

就从RequestParams.java开始说起，它有几个重载的addBodyParameter的方法

当调用requestParams.addBodyParameter("picFile", imageFile, "image/png");时 看下具体代码：

<span style="font-size:18px;">public void addBodyParameter(String key, File file, String mimeType) {
    if (fileParams == null) {
        fileParams = new HashMap<String, ContentBody>();
    }
    fileParams.put(key, new FileBody(file, mimeType));
}</span>

fileParams是一个内部变量，声明是 private HashMap<String, ContentBody> fileParams; 可见，当传入的参数是File时，参数被保存在fileParams这个HashMap当中。OK至此， RequestParams的初始化已经结束。 接下来就是调用HttpUtils.send的方法来像服务端发送请求

<span style="font-size:18px;">public <T> HttpHandler<T> send(HttpRequest.HttpMethod method, String url, RequestParams params,
                               RequestCallBack<T> callBack) {
    if (url == null) throw new IllegalArgumentException("url may not be null");

    HttpRequest request = new HttpRequest(method, url);
    return sendRequest(request, params, callBack);
}</span>

通过method与url创建一个HttpRequest， 并调用sendRequest方法，首先来看一下这个HttpRequest

<span style="font-size:18px;">public HttpRequest(HttpMethod method, URI uri) {
    super();
    this.method = method;
    setURI(uri);
}</span>

将method和url传给内部变量，之后在调用client执行request的时候会用到这些参数， 接下来回到sendRequest方法：

<span style="font-size:18px;">private <T> HttpHandler<T> sendRequest(HttpRequest request, RequestParams params, RequestCallBack<T> callBack) {

    HttpHandler<T> handler = new HttpHandler<T>(httpClient, httpContext, responseTextCharset, callBack);

    handler.setExpiry(currentRequestExpiry);
    handler.setHttpRedirectHandler(httpRedirectHandler);
    request.setRequestParams(params, handler);

    if (params != null) {
        handler.setPriority(params.getPriority());
    }
    handler.executeOnExecutor(EXECUTOR, request);
    return handler;
}</span>

又冒出一个HttpHandler类， 创建它用到了4个参数， 其中第一个是httpClient， 这个client就是HttpUtils初始化的时候实例化的DefaultHttpClient的对象。

然后调用request.setRequestParams方法， 如下

<span style="font-size:18px;">public void setRequestParams(RequestParams param) {
    if (param != null) {
        if (uriCharset == null) {
            uriCharset = Charset.forName(param.getCharset());
        }
        List<RequestParams.HeaderItem> headerItems = param.getHeaders();
        if (headerItems != null) {
            for (RequestParams.HeaderItem headerItem : headerItems) {
                if (headerItem.overwrite) {
                    this.setHeader(headerItem.header);
                } else {
                    this.addHeader(headerItem.header);
                }
            }
        }
        this.addQueryStringParams(param.getQueryStringParams());
        this.setEntity(param.getEntity());
    }
}</span>

参数中的params就是我们调用HttpUtils.send方式之前，实例化的HttpParams对象， 至此 在HttpRequest对象中已经有method，url， 以及HttpParams的封装，最后调用handler.executeOnExecutor(EXECUTOR, request);来执行此request。 HttpHandler实现了PriorityAsyncTask, 你懂的，最终会调用doInBackground，看一下实现：

<span style="font-size:18px;">protected Void doInBackground(Object... params) {
    if (this.state == State.CANCELLED || params == null || params.length == 0) return null;

    if (params.length > 3) {
        fileSavePath = String.valueOf(params[1]);
        isDownloadingFile = fileSavePath != null;
        autoResume = (Boolean) params[2];
        autoRename = (Boolean) params[3];
    }

    try {
        if (this.state == State.CANCELLED) return null;
        // init request & requestUrl
        request = (HttpRequestBase) params[0];
        requestUrl = request.getURI().toString();
        if (callback != null) {
            callback.setRequestUrl(requestUrl);
        }

        this.publishProgress(UPDATE_START);

        lastUpdateTime = SystemClock.uptimeMillis();

        ResponseInfo<T> responseInfo = sendRequest(request);
        if (responseInfo != null) {
            this.publishProgress(UPDATE_SUCCESS, responseInfo);
            return null;
        }
    } catch (HttpException e) {
        this.publishProgress(UPDATE_FAILURE, e, e.getMessage());
    }

    return null;
}
</span>

params[0]就是传进来的HttpRequest， 之后调用sendRequest的方法先服务端发送请求， 并返回ResponseInfo的对象， 代码如下：

<span style="font-size:18px;">private ResponseInfo<T> sendRequest(HttpRequestBase request) throws HttpException {

    HttpRequestRetryHandler retryHandler = client.getHttpRequestRetryHandler();
    while (true) {

        if (autoResume && isDownloadingFile) {
            File downloadFile = new File(fileSavePath);
            long fileLen = 0;
            if (downloadFile.isFile() && downloadFile.exists()) {
                fileLen = downloadFile.length();
            }
            if (fileLen > 0) {
                request.setHeader("RANGE", "bytes=" + fileLen + "-");
            }
        }

        boolean retry = true;
        IOException exception = null;
        try {
            requestMethod = request.getMethod();
            if (HttpUtils.sHttpCache.isEnabled(requestMethod)) {
                String result = HttpUtils.sHttpCache.get(requestUrl);
                if (result != null) {
                    return new ResponseInfo<T>(null, (T) result, true);
                }
            }

            ResponseInfo<T> responseInfo = null;
            if (!isCancelled()) {
                HttpResponse response = client.execute(request, context);
                responseInfo = handleResponse(response);
            }
            return responseInfo;
        } catch (UnknownHostException e) {
            exception = e;
            retry = retryHandler.retryRequest(exception, ++retriedCount, context);
        } catch (IOException e) {
            exception = e;
            retry = retryHandler.retryRequest(exception, ++retriedCount, context);
        } catch (NullPointerException e) {
            exception = new IOException(e.getMessage());
            exception.initCause(e);
            retry = retryHandler.retryRequest(exception, ++retriedCount, context);
        } catch (HttpException e) {
            throw e;
        } catch (Throwable e) {
            exception = new IOException(e.getMessage());
            exception.initCause(e);
            retry = retryHandler.retryRequest(exception, ++retriedCount, context);
        }
        if (!retry) {
            throw new HttpException(exception);
        }
    }
}
</span>

先获取下client.getHttpRequestRetryHandler()，获取retry的设置； 如果使用了缓存则通过requestUrl去httpCache去获取，获取到了则创建ResponseInfo对象。如果没有缓存，调用httpClient执行http请求，获取到得结果交由handleResponse处理。

至此，上传流程基本结束，做一下总结吧：

1 创建并实例化HttpUtils类，  在构造方法中会实例化最核心的类DefaultHttpClient对象---此对象用来执行request，向服务端发送上传请求，并返回结果

2 创建并实例化HttpParams对象， 通过addBodyParameter方法将要上传的File传给HttpParams

3 创建并实例化HttpHandler对象， 将DefaultHttpClient的实例通过参数形式，传给HttpHandler

4 创建并实例化HttpRequest对象，在此对象中，封装好了method， url， 以及params， 然后通过HttpHandler对象来执行此request，并最终调用DefaultHttpClient来执行此request， 返回HttpResponse