Volley+OkHttp+Gson自定义框架

本篇博客内容：

• 讲解volley部分源码

• 在框架源码中，添加OkHttp作为传输层

• 在框架源码中，添加Gson解析的 GsonRequest

• 在框架源码中，添加 文件上传的MultiPartRequest

在前面两篇博客，已经记录如何自定义项目需求的请求。这里来讲解如何修改Volley源码，自定义需求框架。

1.先来了解下Volley部分源码：

在Volley.java中，可以看到一些配置，例如联网操作类（HttpURLConnection或者androids-http-clients），磁盘缓存，线程池（实际上是4个网路线程，一个缓存线程）。

/**
 * 用途：
 *  初始化Volley中网络配置，异步线程配置，磁盘缓存配置
 */
public class Volley {

    /** Default on-disk cache directory.   默认缓存的文件夹名*/
    private static final String DEFAULT_CACHE_DIR = "volley";

    /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @param stack An {@link HttpStack} to use for the network, or null for default.
     * @return A started {@link RequestQueue} instance.
     *
     * 创建一个默认的工作池对象，且调用RequestQueue的start()
     *  参数Contentxt用于创建磁盘缓存的文件夹
     *  参数HttpStack用于网络工作，默认是nulll
     */
    public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        //在手机内存中创建一个缓存数据的文件夹
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

        String userAgent = "volley/0";
        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }

        if (stack == null) {
            //api版本不小于9，则使用java中HttpURLConnection作为联网方式
            if (Build.VERSION.SDK_INT >= 9) {
                stack = new HurlStack();
            } else {
                // Prior to Gingerbread, HttpUrlConnection was unreliable.
                // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }
        //创建一个执行网络工作的操作类
        Network network = new BasicNetwork(stack);
        //创建一个请求队列，添加磁盘缓存的操作类，执行网络工作的操作类
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        //开启。
        queue.start();

        return queue;
    }

    /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @return A started {@link RequestQueue} instance.
     *
     * 创建一个默认的工作池对象，且调用RequestQueue的start()
     * 参数Contentxt用于创建磁盘缓存的文件夹
     *
     */
    public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, null);
    }
}

从上面源码可知，当当前手机系统的api>=9 时候，volley才有HttpURLConnection来连接服务器。磁盘缓存，线程池这里暂时省略不讲解。接下来了解下，HurlStack这类。

HurlStack这个类包括了这几个操作，设置请求的header和body，以及读取响应数据。

/**
 * An {@link HttpStack} based on {@link HttpURLConnection}.
 *
 * 用途：
 *      用HttpURLConnection作为联网通讯类。
 */
public class HurlStack implements HttpStack { 

    ...................//部分源码未贴出
       /**
     *  执行HttpURLConnection，返回HttpResponse
     *
     * @param request the request to perform
     * @param additionalHeaders additional headers to be sent together with
     *         {@link Request#getHeaders()}
     * @return
     * @throws IOException
     * @throws AuthFailureError
     */
    @Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders) 
       throws IOException, AuthFailureError { 

       ...................//部分源码未贴出  
        String url = request.getUrl();
        //创建一个HttpUrlConnection或者其子类，进行网络连接。
        URL parsedUrl = new URL(url);
        HttpURLConnection connection = openConnection(parsedUrl, request);
        //添加Http的标头
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }
        //根据volley中请求，来设置HttpUrlConnection的连接方式，和传递的内容
        setConnectionParametersForRequest(connection, request);  

         ...................//部分源码未贴出  
    }   


    /**
     * Opens an {@link HttpURLConnection} with parameters.
     * @param url
     * @return an open connection
     * @throws IOException
     *
     * 根据url中带有的协议，来开启一个带有参数的HttpURLConnection，或者HttpsURLConnection
     */
    private HttpURLConnection openConnection(URL url, Request<?> request) throws IOException {
        HttpURLConnection connection = createConnection(url);

        int timeoutMs = request.getTimeoutMs();
        //设置连接时间
        connection.setConnectTimeout(timeoutMs);
        //设置读取时间
        connection.setReadTimeout(timeoutMs);
        //不设置http缓存
        connection.setUseCaches(false);
        connection.setDoInput(true);

        // use caller-provided custom SslSocketFactory, if any, for HTTPS
        // 若是HTTPS协议，则使用HttpsURLConnection进行连接，且添加自定义的SSLSocketFactory
        if ("https".equals(url.getProtocol()) && mSslSocketFactory != null) {
            ((HttpsURLConnection)connection).setSSLSocketFactory(mSslSocketFactory);
        }
        return connection;
    }  

    /**
     * Create an {@link HttpURLConnection} for the specified {@code url}.
     * 通过URL开启一个客户端与url指向资源的间的网络通道。
     */
    protected HttpURLConnection createConnection(URL url) throws IOException {
        return (HttpURLConnection) url.openConnection();
    } 

    /**
     * 若是请求中存在Body(post传递的参数),则写入body到流中。
     * @param connection
     * @param request
     * @throws IOException
     * @throws AuthFailureError
     */
    private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
            throws IOException, AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            //设置post请求方法，允许写入客户端传递的参数
            connection.setDoOutput(true);
            //设置标头的Content-Type属性
            connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            //写入post传递的参数
            out.write(body);
            out.close();
        }
    }
}

从上面源码可知：
1.创建HttpUrlConnection对象时通过createConnection(URL url)来实现的

2.添加请求的body会在addBodyIfExists（）内调用request.getBody()来实现

3.添加请求的标头Content-type是调用request.getBodyContentType()来实现的。

了解联网操作类HttpUrlConnection如何创建，如何添加请求的Body和Header，便可以知道如何修改Volley源码。

2.使用OkHttp作为传输层：

OkHttp的描述：一个http+spdy的客户端，可以用于android 和java运用程序。

OkHttp的优势：

• Http/2 支持允许全部（访问同一主机的）请求共享一个socket.

• 连接池减少请求延迟（若是Http/2不能使用）

• 3.数据压缩成GZIP格式，来缩小下载大小。

• 4.响应缓存可以避免重复（已经完成的网络操作的）请求

• 5.OkHttp perseveres，正当网络是麻烦：
  它会默默地从常见连接问题池中恢复。
  若是你的服务器有多个IP地址，当第一次连接失败，OkHttp会尝试使用备用地址。
  这是必需的，对于IP4+IP6和（沉珂数据中的）主机服务

• OkHttp初始化新连接是通过现今TLS功能（SNI,ALPN）,若是握手失败，则回退到TLS1.0中
• 使用Okhttp是容易的，它的请求/响应的API是被设计成流畅builder和immutability.
  它支持同步阻塞回调和异步回调。

OkHttp的版本变化：

• OkHttp1.x 存在一些问题：
  问题： OkHttp changes the global SSL context, breaks other HTTP clients
  原因：OkHttp更改全局的SSL context，打断其他Http客户端
  解决方式：创建自己的SSL context，不使用系统默认的。但是存在问题，自定义的SSLcontext会失去自定义的属性，这可能打破一些特征，例如证书固定。

  /**
   * 自定义一个SSLContext，而不使用默认的。
   *
   * @return
   */
  public static OkHttpClient createOkHttpClient(){
      OkHttpClient okHttpClient=new OkHttpClient();
      try {
          SSLContext sslContext = SSLContext.getInstance("TLS");
          sslContext.init(null, null, null);
          okHttpClient.setSslSocketFactory( sslContext.getSocketFactory());
      //避免OkHttp与UrlHttpConnection混合，出现某些方法找不到
      //参考链接：https://github.com/square/okhttp/issues/673
          URL.setURLStreamHandlerFactory(okHttpClient);
        ;
      } catch (GeneralSecurityException e) {
          throw new AssertionError(); // The system has no TLS. Just give up.
      }
  
      return  okHttpClient;
  }

  获取HttpUrlConnection对象的方式：okHttpClient.open(url)

• OkHttp2.x 存在一些问题：版本2.x修复以上的问题，但是仍然存在些问题：
  问题：java.io.IOException: stream was reset: PROTOCOL_ERROR
  原因：导致原因： OkHttp 发送标头使用的格式：accept-encoding: gzip 。 这导致nginx服务器报告一个protocol error
  解决方式：http://mailman.nginx.org/pipermail/nginx/2015-October/048978.html

  // 强迫使用HTTP1.1：
  OkHttpClient client = new OkHttpClient();
  // Disable HTTP/2 for interop with NGINX 1.9.5.
  client.setProtocols(Collections.singletonList(Protocol.HTTP_1_1));    

  获取HttpUrlConnection对象的方式：OkUrlFactory(okHttpClient).open（）

• OkHttp3.x 版本已经比较成熟，实用起来也比较方便，通过构建者方式来创建对象。

• 更多关于OkHttp的信息，可以阅读 在github上的OkHttp项目连接：https://github.com/square/okhttp

原本打算都讲解下如何让OkHttp各个版本作为Volley的传输层，但是考虑到大多数人都是使用OkHttp3.x。故这里就不在讲解如何实现各个版本的OkHttp作为传输层。

先在Volley源码的Gradle中添加依赖库：

dependencies {
    //OkHttp库
    compile 'com.squareup.okhttp3:okhttp:3.5.0'
    //okhttp-urlconnection库
    compile 'com.squareup.okhttp3:okhttp-urlconnection:3.5.0'
   //Gson库
    compile 'com.google.code.gson:gson:2.2.4'
}

然后，创建一个OkHttpClientStatck,来作为传输层（若是有需要的，可以在源码下自定义一个包，在包下创建）

思路：采用OkHttp作为传输层，替代原生的HttpUrlConnection。

实现方式：继承HurlStack 类，复写createConnection(URL url)返回OkHttpClient中的HttpURLConnection

OkHttpClientStatck.java完整代码如下：

/**
 * Created by ${新根} on 2016/11/3.
 * 博客：http://blog.csdn.net/hexingen
 *
 * 采用OkHttp作为传输层，替代原生的HttpUrlConnection
 */
public class OkHttpClientStatck extends HurlStack {
    private OkHttpClient okHttpClient;

    /**
     * 采购构建者方式创建OkHttpClient
     * OkHttpClient可以自定义拦截器，缓存，联网时间和写入时间等设置。
     * Volley默认有这些东西，这里就不在设置。
     */
    public OkHttpClientStatck(){
        OkHttpClient.Builder builder=new OkHttpClient.Builder();
        okHttpClient=builder.build();
    }
    /**
     * 获取到OkHttpClient();
     * @return
     */
    private  OkHttpClient getOkHttpClient(){
        return  okHttpClient;
    }
    /**
     * 这里采用OkHttp框架中HttpURLConnection，而不使用原生的。
     *
     * OkHttpClient1.x:通过OkHttpClient.open(url)来获取
     *
     * OkHttpClient2.x:可以通过OkUrlFactory.open(URL url)来获取
     *
     * @param url
     * @return
     * @throws IOException
     */
    @Override
    protected HttpURLConnection createConnection(URL url) throws IOException {
        String protocol=  url.getProtocol();
        if (protocol.equals("http")) return new OkHttpURLConnection(url, getOkHttpClient(),null);

        if (protocol.equals("https")) return new OkHttpsURLConnection(url, getOkHttpClient(),null);
        throw new IllegalArgumentException("Unexpected protocol: " + protocol);
    }
}

然后将OkHttpClientStatck添加到Volley中，作为默认的传输层：
在Volley.java中修改如下：

public class Volley { 

   ............//部分源码未贴出

   /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @return A started {@link RequestQueue} instance.
     *
     * 创建一个默认的工作池对象，且调用RequestQueue的start()
     * 参数Contentxt用于创建磁盘缓存的文件夹
     *
     */
    public static RequestQueue newRequestQueue(Context context) {
        //修改源码：这里采用OkHttp作为传输层
        return newRequestQueue(context, new OkHttpClientStatck());
    }
}

有人好奇为什么不用系统默认的HttpUrlConnetion，而用OkHttp作为传输层？
单纯的HttpUrlConnetion的使用起来存在一些问题，OkHttp不止针对其问题做了处理，还对连接服务器过程中一些问题做了处理。

Volley与OkHttp的整合已经完成了，整合后的Volley框架使用起来和原本的一样，自我鼓励下。

3.添加自定义的Request:

既然改了Volley的传输层，那再改Request也是顺手之劳。

• 在框架源码中，添加 GsonRequest，这里不再贴代码，感兴趣的可以阅读Gson解析的 GsonRequest

• 在框架源码中，添加 文件上传的MultiPartRequest ，这里有部分代码进行了修改，原本是上传文件的byte[]，变成了上传file。省略了转化过程，使用起来更方便。

  完整代码代码如下：

/**
 * Created by 新根 on 2016/8/9.
 * 用途：
 * 各种数据上传到服务器的内容格式：
 * <p/>
 * 文件上传（内容格式）：multipart/form-data
 * String字符串传送（内容格式）：application/x-www-form-urlencoded
 * json传递（内容格式）：application/json
 *
 * 博客：http://blog.csdn.net/hexingen
 */
public class MultiPartRequest<T> extends Request<T> {
    private  static  final  String TAG=MultiPartRequest.class.getSimpleName();
    /**
     * 解析后的实体类
     */
    private final Class<T> clazz;

    private final Response.Listener<T> listener;

    /**
     * 自定义header:
     */
    private Map<String, String> headers;
    private final Gson gson = new Gson();
    /**
     * 字符编码格式
     */
    private static final String PROTOCOL_CHARSET = "utf-8";

    private static final String BOUNDARY = "----------" + System.currentTimeMillis();
    /**
     * Content type for request.
     */
    private static final String PROTOCOL_CONTENT_TYPE = "multipart/form-data; boundary=" + BOUNDARY;

    /**
     * 文件列表。参数1是文件名，参数2是文件
     */
    private Map<String, File > fileList;
    /**
     * 多个文件间的间隔
     */
    private static final String FILEINTERVAL = "\r\n";

    public MultiPartRequest(int method, String url,
                            Class<T> clazz,
                            Response.Listener<T> listener, Response.ErrorListener errorListenerr) {
        super(method, url, errorListenerr);
        this.clazz = clazz;
        this.listener = listener;
        headers = new HashMap<>();
        fileList = new HashMap<>();
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String json = new String(
                    response.data,
                    "utf-8");
            T t = gson.fromJson(json, clazz);
            return Response.success(t, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(T t) {
        listener.onResponse(t);
    }


    /**
     * 重写getHeaders(),添加自定义的header
     *
     * @return
     * @throws AuthFailureError
     */
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return headers;
    }

    /**
     * 设置请求的标头
     * @param key
     * @param content
     * @return
     */
    public Map<String, String> setHeader(String key, String content) {
        if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(content)) {
            headers.put(key, content);
        }
        return headers;
    }

    /**
     * 添加文件名和文件数据
     *
     * @param fileName
     * @param file
     */
    public void addFile(String fileName, File file) {
        if (!TextUtils.isEmpty(fileName) && file != null) {
            fileList.put(fileName, file);
        }
    }


    /**
     * 重写Content-Type:设置为json
     */
    @Override
    public String getBodyContentType() {
        return PROTOCOL_CONTENT_TYPE;
    }

    /**
     * post参数类型
     */
    @Override
    public String getPostBodyContentType() {
        return getBodyContentType();
    }

    /**
     * post参数
     */
    @Override
    public byte[] getPostBody() throws AuthFailureError {

        return getBody();
    }

    /**
     * 将string编码成byte
     *
     * @return
     * @throws AuthFailureError
     */
    @Override
    public byte[] getBody() throws AuthFailureError {
        byte[] body;
        ByteArrayOutputStream outputStream = null;
        try {
            outputStream = new ByteArrayOutputStream();
            Set<Map.Entry<String, File>> set = fileList.entrySet();
            int i=1;
            for (Map.Entry<String,File> entry : set) {
                //添加文件的头部格式
                writeByte(outputStream, getFileHead( entry.getKey()));
                //添加文件数据
                writeByte(outputStream,fileTranstateToByte(entry.getValue()));
                //添加文件间的间隔
                if (set.size() > 1&&i<set.size()) {
                    i++;
                    Log.i(TAG,"添加文件间隔");
                    writeByte(outputStream, FILEINTERVAL.getBytes(PROTOCOL_CHARSET));
                }
            }
            writeByte(outputStream, getFileFoot());
            outputStream.flush();
            body = outputStream.toByteArray();
            return body == null ? null : body;
        } catch (Exception e) {
            return null;
        } finally {
            try {
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (Exception e) {

            }
        }
    }

    /**
     * 将file转成byte[]数据
     */
    public byte[] fileTranstateToByte(File file){
        byte[] data=null;
        FileInputStream fileInputStream=null;
        ByteArrayOutputStream outputStream = null;
        try {
            fileInputStream=new FileInputStream(file);
            byte[] buffer=new byte[1024];
            int length=0;
            while ((length=fileInputStream.read(buffer))!=-1){
                outputStream.write(buffer,0,length);
            }
            outputStream.flush();
           data= outputStream.toByteArray();
        }catch (Exception e){
              data=null;
            e.printStackTrace();
        }finally {
            try {
                if (outputStream != null) {
                    outputStream.close();
                }
                if(fileInputStream!=null){
                    fileInputStream.close();
                }
            } catch (Exception e) {

            }
        }
        return data;
    }
    public void writeByte(ByteArrayOutputStream outputStream, byte[] bytes) {
        if(bytes!=null){
            outputStream.write(bytes, 0, bytes.length);
        }
    }


    /**
     * 获取到文件的head
     *
     * @return
     */
    public byte[] getFileHead(String fileName) {
        try {
            StringBuffer buffer = new StringBuffer();
            buffer.append("--");
            buffer.append(BOUNDARY);
            buffer.append("\r\n");
            buffer.append("Content-Disposition: form-data;name=\"media\";filename=\"");
            buffer.append(fileName);
            buffer.append("\"\r\n");
            buffer.append("Content-Type:application/octet-stream\r\n\r\n");
            String s = buffer.toString();
            return s.getBytes("utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取文件的foot
     *
     * @return
     */
    public byte[] getFileFoot() {
        try {
            StringBuffer buffer = new StringBuffer();
            buffer.append("\r\n--");
            buffer.append(BOUNDARY);
            buffer.append("--\r\n");
            String s = buffer.toString();
            return s.getBytes("utf-8");
        } catch (Exception e) {
            return null;
        }
    }

}

最终项目结构如下：

总结：
1. Volley框架的设计是相当不错的，具备1个缓存线程，4个网络线程，可以避免相同的Url的请求并发访问服务器
2. Volley框架带有图片处理ImageLoader,防止在ImageView在listview,gridview,recycleview中错乱。
3. Volley也带有磁盘缓存，可以自行配置内存缓存。
4. OkHttp也是带有磁盘缓存（需配置），异步或者同步执行，请求重试,拦截器等等。

这篇 Volley+OkHttp+Gson结合使用，较为适合普通项目中需求。例如加上断点续传，下载大数据的文件（volley不具备的优势），还可以继续深入的修改结合使用。慢慢长征路，还需继续走下去。