devbox
cp456
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OkHttp3简单使用：请求和响应，post，get_okhttp3 bytearray.torequestbody 使用示例

作者：cp456 | 2024-01-29 23:30:49

赞

踩

okhttp3 bytearray.torequestbody 使用示例

一，HTTP请求、响应报文格式

要弄明白网络框架，首先需要先掌握Http请求的，响应的报文格式。

HTTP请求报文格式:

HTTP请求报文主要由请求行、请求头部、请求正文3部分组成.

request.png

 

  1. 请求行：由请求方法，URL，协议版本三部分构成，之间用空格隔开
    请求方法包括：POST、GET、HEAD、PUT、POST、TRACE、OPTIONS、DELETE等
    协议版本：HTTP/主版本号.次版本号，常用的有HTTP/1.0和HTTP/1.1

    请求方法.png

  2. 请求头部:
    请求头部为请求报文添加了一些附加信息，由“名/值”对组成，每行一对，名和值之间使用冒号分隔
    常见请求头如下：
    Host ----接受请求的服务器地址，可以是IP:端口号，也可以是域名
    User-Agent ----发送请求的应用程序名称
    Connection ---- 指定与连接相关的属性，如Connection:Keep-Alive
    Accept-Charset ---- 通知服务端可以发送的编码格式
    Accept-Encoding ---- 通知服务端可以发送的数据压缩格式
    Accept-Language ---- 通知服务端可以发送的语言
  3. 请求正文
    可选部分，比如GET请求就没有请求正文
  4. 请求示例：

    image.png

HTTP响应报文格式:

HTTP响应报文主要由状态行、响应头部、响应正文3部分组成

响应报文.png

 

  1. 状态行：
    由3部分组成，分别为：协议版本，状态码，状态码描述，之间由空格分隔
    状态码:为3位数字，200-299的状态码表示成功，300-399的状态码指资源重定向，400-499的状态码指客户端请求出错，500-599的状态码指服务端出错（HTTP/1.1向协议中引入了信息性状态码，范围为100-199)
    常见的：
    200：响应成功
    302：重定向跳转，跳转地址通过响应头中的Location属性指定
    400：客户端请求有语法错误，参数错误，不能被服务器识别
    403：服务器接收到请求，但是拒绝提供服务（认证失败）
    404：请求资源不存在
    500：服务器内部错误

    image.png

     

  2. 响应头部 :
    与请求头部类似，为响应报文添加了一些附加信息
    Server - 服务器应用程序软件的名称和版本
    Content-Type - 响应正文的类型（是图片还是二进制字符串）
    Content-Length - 响应正文长度
    Content-Charset - 响应正文使用的编码
    Content-Encoding - 响应正文使用的数据压缩格式
    Content-Language - 响应正文使用的语言

  1. Server: bfe/1.0.8.1 
  2. Date: Sat, 04 Apr 2015 02:49:41 GMT 
  3. Content-Type: text/html; charset=utf-8 
  4. Vary: Accept-Encoding 
  5. Cache-Control: private 
  6. cxy_all: baidu+8ee3da625d74d1aa1ac9a7c34a2191dc 
  7. Expires: Sat, 04 Apr 2015 02:49:38 GMT 
  8. X-Powered-By: HPHP 
  9. bdpagetype: 1 
  10. bdqid: 0xb4eababa0002db6e 
  11. bduserid: 0 
  12. Set-Cookie: BDSVRTM=0; path=/ 
  13. BD_HOME=0; path=/ 
  14. H_PS_PSSID=13165_12942_1430_13075_12867_13322_12691_13348_12723_12797_13309_13325_13203_13161_13256_8498; path=/; domain=.baidu.com 
  15. __bsi=18221750326646863206_31_0_I_R_2_0303_C02F_N_I_I; expires=Sat, 04-Apr-15 02:49:46 GMT; domain=www.baidu.com; path=/ 
  16. Content-Encoding: gzip 
  17. X-Firefox-Spdy: 3.1
  1. 响应正文
    是请求响应的最终结果，都在响应体里。
    报文可以承载很多类型的数字数据：图片、视频、HTML文档、软件应用程序等
  2. 响应示例

    image.png

二，HTTP请求和响应的基本使用

主要包含：

  • 一般的get请求
  • 一般的post请求
  • 基于Http的文件上传
  • 文件下载
  • 加载图片
  • 支持请求回调，直接返回对象、对象集合
  • 支持session的保持
  1. 添加网络访问权限并添加库依赖
  1.   <uses-permission android:name="android.permission.INTERNET" />
  2. api 'com.squareup.okhttp3:okhttp:3.9.0'
  1. HTTP的GET请求
  1. //1,创建okHttpClient对象
  2. OkHttpClient mOkHttpClient = new OkHttpClient();
  3. //2,创建一个Request
  4. final Request request = new Request.Builder()
  5.                 .url("https://www.baidu.com")
  6.                 .build();
  7. //3,新建一个call对象
  8. Call call = mOkHttpClient.newCall(request); 
  9. //4，请求加入调度，这里是异步Get请求回调
  10. call.enqueue(new Callback()
  11.         {
  12.             @Override
  13.             public void onFailure(Request request, IOException e)
  14.             {
  15.             }
  16.  
  17.             @Override
  18.             public void onResponse(final Response response) throws IOException
  19.             {
  20.                     //String htmlStr =  response.body().string();
  21.             }
  22.         });             
  23.

对以上的简单请求的构成：

  • 发送一个GET请求的步骤，首先构造一个Request对象，参数最起码有个URL，当然也可以通过Request.Builder设置更多的参数比如：header、method等。
  1. //URL带的参数
  2. HashMap<String,String> params = new HashMap<>();
  3. //GET 请求带的Header
  4. HashMap<String,String> headers= new HashMap<>();
  5. //HttpUrl.Builder构造带参数url
  6.  HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
  7.         if (params != null) {
  8.  
  9.             for (String key : params.keySet()) {
  10.                 urlBuilder.setQueryParameter(key, params.get(key));
  11.             }
  12.         }
  13.         Request request = new Request.Builder()
  14.                 .url(urlBuilder.build())
  15.                 .headers(headers == null ? new Headers.Builder().build() : Headers.of(headers))
  16.                 .get()
  17.                 .build();
  • 通过Request的对象去构造得到一个Call对象，类似于将你的请求封装成了任务，既然是任务，就会有execute(),enqueue()和cancel()等方法。
    execute():同步GET请求
  1.  //同步
  2. Response response = call.execute()
  3. if(response.isSuccessful()){
  4.      //响应成功
  5. }

enqueue():异步GET请求，将call加入调度队列，然后等待任务执行完成，我们在Callback中即可得到结果。
cancel():Call请求的取消，okHttp支持请求取消功能，当调用请求的cancel()时，请求就会被取消，抛出异常。又是需要监控许多Http请求的执行情况，可以把这些请求的Call搜集起来，执行完毕自动剔除，如果在请求执行过程中(如下载)，想取消执行，可使用call.cancel()取消。

  • 请求的响应Response
    对于同步GET请求，Response对象是直接返回的。异步GET请求，通过onResponse回调方法传参数，需要注意的是这个onResponse回调方法不是在主线程回调，可以使用runInUIThread(new Runnable(){})。
    我们希望获得返回的字符串，可以通过response.body().string()获取；
    如果希望获得返回的二进制字节数组，则调用response.body().bytes()；
    如果你想拿到返回的inputStream，则调用response.body().byteStream()

3. HTTP的POST请求
看来上面的简单的get请求，基本上整个的用法也就掌握了，比如post携带参数，也仅仅是Request的构造的不同。

  1.    //POST参数构造MultipartBody.Builder，表单提交
  2.    HashMap<String,String> params = new HashMap<>();
  3.      MultipartBody.Builder urlBuilder = new MultipartBody.Builder()
  4.                             .setType(MultipartBody.FORM);
  5.                     if (params != null) {
  6.                         for (String key : params.keySet()) {
  7.                             if (params.get(key)!=null){
  8.                                 urlBuilder.addFormDataPart(key, params.get(key));
  9.                             }
  10.                             //urlBuilder.addFormDataPart(key, params.get(key));
  11.  
  12.                         }
  13.                     }
  14. // 构造Request->call->执行
  15.  Request request = new Request.Builder()
  16.                             .headers(extraHeaders == null ? new Headers.Builder().build() : Headers.of(extraHeaders))//extraHeaders 是用户添加头
  17.                             .url(url)
  18.                             .post(urlBuilder.build())//参数放在body体里
  19.                             .build();
  20. Call call = httpClient.newCall(request);
  21.  try (Response response = call.execute()) {
  22.             if (response.isSuccessful()){
  23.              //响应成功
  24.              }
  25.   }

Post的时候，参数是包含在请求体中的，所以我们通过MultipartBody.Builder 添加多个String键值对，然后去构造RequestBody，最后完成我们Request的构造。
4. OKHTTP的上传文件
上传文件本身也是一个POST请求。在上面的POST请求中可以知道，POST请求的所有参数都是在BODY体中的，我们看看请求体的源码RequestBody:请求体=contentType + BufferedSink
RequestBody

  1. //抽象类请求体，**请求体=contentType + BufferedSink**
  2. public abstract class RequestBody {
  3.   /** Returns the Content-Type header for this body. */
  4.  //返回Body体的内容类型
  5.   public abstract @Nullable MediaType contentType();
  6.  
  7.   /**
  8.    * Returns the number of bytes that will be written to {@code sink} in a call to {@link #writeTo},
  9.    * or -1 if that count is unknown.
  10.    */
  11.   //返回写入sink的字节长度
  12.   public long contentLength() throws IOException {
  13.     return -1;
  14.   }
  15.  
  16.   /** Writes the content of this request to {@code sink}. */
  17.   //写入缓存sink
  18.   public abstract void writeTo(BufferedSink sink) throws IOException;
  19.  
  20.   /**
  21.    * Returns a new request body that transmits {@code content}. If {@code contentType} is non-null
  22.    * and lacks a charset, this will use UTF-8.
  23.    */
  24.    //创建一个请求体，如果contentType不等于null且缺少字符集，将使用UTF-8
  25.   public static RequestBody create(@Nullable MediaType contentType, String content) {
  26.     Charset charset = Util.UTF_8;
  27.     if (contentType != null) {
  28.       //contentType里面的字符集
  29.       charset = contentType.charset();
  30.       if (charset == null) {
  31.         charset = Util.UTF_8;
  32.         //contentType 里面加入字符集
  33.         contentType = MediaType.parse(contentType + "; charset=utf-8");
  34.       }
  35.     }
  36.     //按字符集变成字节
  37.     byte[] bytes = content.getBytes(charset);
  38.     return create(contentType, bytes);
  39.   }
  40.  
  41.   /** Returns a new request body that transmits {@code content}. */
  42.  //创建新的请求体，传输字节
  43.   public static RequestBody create(
  44.       final @Nullable MediaType contentType, final ByteString content) {
  45.     return new RequestBody() {
  46.       @Override public @Nullable MediaType contentType() {
  47.         //请求体需要的内容类型
  48.         return contentType;
  49.       }
  50.  
  51.       @Override public long contentLength() throws IOException {
  52.        //写入BufferedSink 的长度
  53.         return content.size();
  54.       }
  55.  
  56.       @Override public void writeTo(BufferedSink sink) throws IOException {
  57.        //将需要传输的字节，写入缓存BufferedSink 中
  58.         sink.write(content);
  59.       }
  60.     };
  61.   }
  62.  
  63.   /** Returns a new request body that transmits {@code content}. */
  64.   public static RequestBody create(final @Nullable MediaType contentType, final byte[] content) {
  65.     return create(contentType, content, 0, content.length);
  66.   }
  67.  
  68.   /** Returns a new request body that transmits {@code content}. */
  69.   public static RequestBody create(final @Nullable MediaType contentType, final byte[] content,
  70.       final int offset, final int byteCount) {
  71.     if (content == null) throw new NullPointerException("content == null");
  72.     Util.checkOffsetAndCount(content.length, offset, byteCount);
  73.     return new RequestBody() {
  74.       @Override public @Nullable MediaType contentType() {
  75.         return contentType;
  76.       }
  77.  
  78.       @Override public long contentLength() {
  79.         return byteCount;
  80.       }
  81.  
  82.       @Override public void writeTo(BufferedSink sink) throws IOException {
  83.         sink.write(content, offset, byteCount);
  84.       }
  85.     };
  86.   }
  87.  
  88.   /** Returns a new request body that transmits the content of {@code file}. */
  89.   //创建一个请求体，传输文件file内容，其实就是file写入bufferedSink
  90.   public static RequestBody create(final @Nullable MediaType contentType, final File file) {
  91.     if (file == null) throw new NullPointerException("content == null");
  92.  
  93.     return new RequestBody() {
  94.       @Override public @Nullable MediaType contentType() {
  95.         return contentType;
  96.       }
  97.  
  98.       @Override public long contentLength() {
  99.         return file.length();
  100.       }
  101.  
  102.       @Override public void writeTo(BufferedSink sink) throws IOException {
  103.         Source source = null;
  104.         try {
  105.          //文件写入BufferedSink 
  106.           source = Okio.source(file);
  107.           sink.writeAll(source);
  108.         } finally {
  109.           Util.closeQuietly(source);
  110.         }
  111.       }
  112.     };
  113.   }
  114. }
  115.

Http请求中Content-Type
客户端在进行http请求服务器的时候，需要告诉服务器请求的类型，服务器在返回给客户端的数据的时候，也需要告诉客户端返回数据的类型
默认的ContentType为 text/html 也就是网页格式. 常用的内容类型

  • text/plain ：纯文本格式 .txt
  • text/xml ： XML格式 .xml
  • image/gif ：gif图片格式 .gif
  • image/jpeg ：jpg图片格式 .jpg
  • image/png：png图片格式 .png
  • audio/mp3 : 音频mp3格式 .mp3
  • audio/rn-mpeg :音频mpga格式 .mpga
  • video/mpeg4 : 视频mp4格式 .mp4
  • video/x-mpg : 视频mpa格式 .mpg
  • video/x-mpeg :视频mpeg格式 .mpeg
  • video/mpg : 视频mpg格式 .mpg
    以application开头的媒体格式类型：
  • application/xhtml+xml ：XHTML格式
  • application/xml ： XML数据格式
  • application/atom+xml ：Atom XML聚合格式
  • application/json ： JSON数据格式
  • application/pdf ：pdf格式
  • application/msword ： Word文档格式
  • application/octet-stream ： 二进制流数据（如常见的文件下载）
    MultipartBody.Builder 添加多个String键值对
  1. //MultipartBody源码，MultipartBody其实也是RequestBody ，需要在此RequestBody 体内，添加多个Part
  2. /** An <a href="http://www.ietf.org/rfc/rfc2387.txt">RFC 2387</a>-compliant request body. */
  3. public final class MultipartBody extends RequestBody {
  4.   /**
  5.    * The "mixed" subtype of "multipart" is intended for use when the body parts are independent and
  6.    * need to be bundled in a particular order. Any "multipart" subtypes that an implementation does
  7.    * not recognize must be treated as being of subtype "mixed".
  8.    */
  9.   //混合的内容类型
  10.   public static final MediaType MIXED = MediaType.parse("multipart/mixed");
  11.  
  12.   /**
  13.    * The "multipart/alternative" type is syntactically identical to "multipart/mixed", but the
  14.    * semantics are different. In particular, each of the body parts is an "alternative" version of
  15.    * the same information.
  16.    */
  17.   public static final MediaType ALTERNATIVE = MediaType.parse("multipart/alternative");
  18.  
  19.   /**
  20.    * This type is syntactically identical to "multipart/mixed", but the semantics are different. In
  21.    * particular, in a digest, the default {@code Content-Type} value for a body part is changed from
  22.    * "text/plain" to "message/rfc822".
  23.    */
  24.   public static final MediaType DIGEST = MediaType.parse("multipart/digest");
  25.  
  26.   /**
  27.    * This type is syntactically identical to "multipart/mixed", but the semantics are different. In
  28.    * particular, in a parallel entity, the order of body parts is not significant.
  29.    */
  30.   public static final MediaType PARALLEL = MediaType.parse("multipart/parallel");
  31.  
  32.   /**
  33.    * The media-type multipart/form-data follows the rules of all multipart MIME data streams as
  34.    * outlined in RFC 2046. In forms, there are a series of fields to be supplied by the user who
  35.    * fills out the form. Each field has a name. Within a given form, the names are unique.
  36.    */
  37.   public static final MediaType FORM = MediaType.parse("multipart/form-data");
  38.  
  39.   private static final byte[] COLONSPACE = {':', ' '};
  40.   private static final byte[] CRLF = {'\r', '\n'};
  41.   private static final byte[] DASHDASH = {'-', '-'};
  42.  
  43.   private final ByteString boundary;
  44.   private final MediaType originalType;
  45.  
  46.  //请求体的内容类型
  47.   private final MediaType contentType;
  48.   //MultiPartBody需要添加多个Part对象，一起请求
  49.   private final List<Part> parts;
  50.   private long contentLength = -1L;
  51.   //构造函数
  52.   MultipartBody(ByteString boundary, MediaType type, List<Part> parts) {
  53.     this.boundary = boundary;
  54.     this.originalType = type;
  55.     this.contentType = MediaType.parse(type + "; boundary=" + boundary.utf8());
  56.     this.parts = Util.immutableList(parts);
  57.   }
  58.  
  59.   public MediaType type() {
  60.     return originalType;
  61.   }
  62.  
  63.   public String boundary() {
  64.     return boundary.utf8();
  65.   }
  66.  
  67.   /** The number of parts in this multipart body. */
  68.   //multipart 的数量
  69.   public int size() {
  70.     return parts.size();
  71.   }
  72.  //多个parts
  73.   public List<Part> parts() {
  74.     return parts;
  75.   }
  76.  
  77.   public Part part(int index) {
  78.     return parts.get(index);
  79.   }
  80.  
  81.   /** A combination of {@link #type()} and {@link #boundary()}. */
  82.   //MultiPart的内容类型
  83.   @Override public MediaType contentType() {
  84.     return contentType;
  85.   }
  86.  
  87.   @Override public long contentLength() throws IOException {
  88.     long result = contentLength;
  89.     if (result != -1L) return result;
  90.     return contentLength = writeOrCountBytes(null, true);
  91.   }
  92.   //将每个part写入BufferedSink中，传输
  93.   @Override public void writeTo(BufferedSink sink) throws IOException {
  94.     writeOrCountBytes(sink, false);
  95.   }
  96.  
  97.   /**
  98.    * Either writes this request to {@code sink} or measures its content length. We have one method
  99.    * do double-duty to make sure the counting and content are consistent, particularly when it comes
  100.    * to awkward operations like measuring the encoded length of header strings, or the
  101.    * length-in-digits of an encoded integer.
  102.    */
  103.   //将每个Part的内容都写入，MultiPartBody的BufferedSink 中
  104.   private long writeOrCountBytes(@Nullable BufferedSink sink, boolean countBytes) throws IOException {
  105.     long byteCount = 0L;
  106.  
  107.     Buffer byteCountBuffer = null;
  108.     if (countBytes) {
  109.       sink = byteCountBuffer = new Buffer();
  110.     }
  111.    //写每个part
  112.     for (int p = 0, partCount = parts.size(); p < partCount; p++) {
  113.       Part part = parts.get(p);
  114.      //Part的Headers和RequestBody 
  115.       Headers headers = part.headers;
  116.       RequestBody body = part.body;
  117.  
  118.       sink.write(DASHDASH);
  119.       sink.write(boundary);
  120.       sink.write(CRLF);
  121.  
  122.       //Part的Headers写入sink
  123.       if (headers != null) {
  124.      
  125.         for (int h = 0, headerCount = headers.size(); h < headerCount; h++) {
  126.           sink.writeUtf8(headers.name(h))
  127.               .write(COLONSPACE)
  128.               .writeUtf8(headers.value(h))
  129.               .write(CRLF);
  130.         }
  131.       }
  132.       //Part的RequestBody写入Part
  133.      //1,写contentType 
  134.       MediaType contentType = body.contentType();
  135.       if (contentType != null) {
  136.         sink.writeUtf8("Content-Type: ")
  137.             .writeUtf8(contentType.toString())
  138.             .write(CRLF);
  139.       }
  140.      //2,写contentLength 
  141.       long contentLength = body.contentLength();
  142.       if (contentLength != -1) {
  143.         sink.writeUtf8("Content-Length: ")
  144.             .writeDecimalLong(contentLength)
  145.             .write(CRLF);
  146.       } else if (countBytes) {
  147.         // We can't measure the body's size without the sizes of its components.
  148.         byteCountBuffer.clear();
  149.         return -1L;
  150.       }
  151.  
  152.       sink.write(CRLF);
  153.       //3，写body体
  154.       if (countBytes) {
  155.         byteCount += contentLength;
  156.       } else {
  157.         body.writeTo(sink);
  158.       }
  159.  
  160.       sink.write(CRLF);
  161.     }
  162.  
  163.     sink.write(DASHDASH);
  164.     sink.write(boundary);
  165.     sink.write(DASHDASH);
  166.     sink.write(CRLF);
  167.  
  168.     if (countBytes) {
  169.       byteCount += byteCountBuffer.size();
  170.       byteCountBuffer.clear();
  171.     }
  172.  
  173.     return byteCount;
  174.   }
  175.  
  176.   /**
  177.    * Appends a quoted-string to a StringBuilder.
  178.    *
  179.    * <p>RFC 2388 is rather vague about how one should escape special characters in form-data
  180.    * parameters, and as it turns out Firefox and Chrome actually do rather different things, and
  181.    * both say in their comments that they're not really sure what the right approach is. We go with
  182.    * Chrome's behavior (which also experimentally seems to match what IE does), but if you actually
  183.    * want to have a good chance of things working, please avoid double-quotes, newlines, percent
  184.    * signs, and the like in your field names.
  185.    */
  186.     //装换换行符，tab符号，引号
  187.   static StringBuilder appendQuotedString(StringBuilder target, String key) {
  188.     target.append('"');
  189.     for (int i = 0, len = key.length(); i < len; i++) {
  190.       char ch = key.charAt(i);
  191.       switch (ch) {
  192.         case '\n':
  193.           target.append("%0A");
  194.           break;
  195.         case '\r':
  196.           target.append("%0D");
  197.           break;
  198.         case '"':
  199.           target.append("%22");
  200.           break;
  201.         default:
  202.           target.append(ch);
  203.           break;
  204.       }
  205.     }
  206.     target.append('"');
  207.     return target;
  208.   }
  209.  //Part 的定义，Part 是由Headers+RequestBody组成
  210.   public static final class Part {
  211.     public static Part create(RequestBody body) {
  212.       return create(null, body);
  213.     }
  214.  
  215.     public static Part create(@Nullable Headers headers, RequestBody body) {
  216.       if (body == null) {
  217.         throw new NullPointerException("body == null");
  218.       }
  219.       //Part的headers不能存在Content-Type和Content-Length字段
  220.       if (headers != null && headers.get("Content-Type") != null) {
  221.         throw new IllegalArgumentException("Unexpected header: Content-Type");
  222.       }
  223.       if (headers != null && headers.get("Content-Length") != null) {
  224.         throw new IllegalArgumentException("Unexpected header: Content-Length");
  225.       }
  226.       return new Part(headers, body);
  227.     }
  228.     //创建key-value的Part，name其实就是key
  229.     public static Part createFormData(String name, String value) {
  230.       return createFormData(name, null, RequestBody.create(null, value));
  231.     }
  232.     //创建key-value的Part
  233.     public static Part createFormData(String name, @Nullable String filename, RequestBody body) {
  234.       if (name == null) {
  235.         throw new NullPointerException("name == null");
  236.       }
  237.       StringBuilder disposition = new StringBuilder("form-data; name=");
  238.       // disposition =  form-data; name=name;
  239.       appendQuotedString(disposition, name);//对name中的特殊符号转换
  240.  
  241.       if (filename != null) {
  242.         disposition.append("; filename=");
  243.         // disposition =  form-data; name=name; filename=filename;
  244.         appendQuotedString(disposition, filename);//对filename中的特殊符号转换
  245.       }
  246.      //创建Part 体，Headers（Content-Disposition- form-data; name=name; filename=filename）+body
  247.       return create(Headers.of("Content-Disposition", disposition.toString()), body);
  248.     }
  249.     //headers
  250.     final @Nullable Headers headers;
  251.     //body
  252.     final RequestBody body;
  253.  
  254.     private Part(@Nullable Headers headers, RequestBody body) {
  255.       this.headers = headers;
  256.       this.body = body;
  257.     }
  258.    //Part的headers
  259.     public @Nullable Headers headers() {
  260.       return headers;
  261.     }
  262.     //Part的body体
  263.     public RequestBody body() {
  264.       return body;
  265.     }
  266.   }
  267.  
  268.   public static final class Builder {
  269.     private final ByteString boundary;
  270.     private MediaType type = MIXED;
  271.     private final List<Part> parts = new ArrayList<>();
  272.  
  273.     public Builder() {
  274.       this(UUID.randomUUID().toString());
  275.     }
  276.  
  277.     public Builder(String boundary) {
  278.       this.boundary = ByteString.encodeUtf8(boundary);
  279.     }
  280.  
  281.     /**
  282.      * Set the MIME type. Expected values for {@code type} are {@link #MIXED} (the default), {@link
  283.      * #ALTERNATIVE}, {@link #DIGEST}, {@link #PARALLEL} and {@link #FORM}.
  284.      */
  285.     public Builder setType(MediaType type) {
  286.       if (type == null) {
  287.         throw new NullPointerException("type == null");
  288.       }
  289.       if (!type.type().equals("multipart")) {
  290.         throw new IllegalArgumentException("multipart != " + type);
  291.       }
  292.       this.type = type;
  293.       return this;
  294.     }
  295.  
  296.     /** Add a part to the body. */
  297.    //添加Part
  298.     public Builder addPart(RequestBody body) {
  299.       return addPart(Part.create(body));
  300.     }
  301.  
  302.     /** Add a part to the body. */
  303.     //添加Part
  304.     public Builder addPart(@Nullable Headers headers, RequestBody body) {
  305.       return addPart(Part.create(headers, body));
  306.     }
  307.  
  308.     /** Add a form data part to the body. */
  309.    //添加表单数据Part
  310.     public Builder addFormDataPart(String name, String value) {
  311.       return addPart(Part.createFormData(name, value));
  312.     }
  313.  
  314.     /** Add a form data part to the body. */
  315.     //添加表单数据Part
  316.     public Builder addFormDataPart(String name, @Nullable String filename, RequestBody body) {
  317.       return addPart(Part.createFormData(name, filename, body));
  318.     }
  319.  
  320.     /** Add a part to the body. */
  321.     public Builder addPart(Part part) {
  322.       if (part == null) throw new NullPointerException("part == null");
  323.       parts.add(part);
  324.       return this;
  325.     }
  326.  
  327.     /** Assemble the specified parts into a request body. */
  328.     public MultipartBody build() {
  329.       if (parts.isEmpty()) {
  330.         throw new IllegalStateException("Multipart body must have at least one part.");
  331.       }
  332.      //构建MultipartBody对象
  333.       return new MultipartBody(boundary, type, parts);
  334.     }
  335.   }
  336. }
  337.

总结一下MultipartBody：

  1. MultipartBody本质一个是一个RequestBody，具有自己的contentType+BufferedSink，是POST请求的最外层封装，需要添加多个Part
  2. Part对象组成：Headers+RequestBody。是MultipartBody的成员变量，需要写入MultipartBody的BufferedSink中。

HTTP真正的上传文件

  1. 最基本的上传文件：

重点：RequestBody create(MediaType contentType, final File file)构造文件请求体RequestBody ,并且添加到MultiPartBody中

  1. OkHttpClient client = new OkHttpClient();
  2.         // form 表单形式上传,MultipartBody的内容类型是表单格式，multipart/form-data
  3.         MultipartBody.Builder urlBuilder= new MultipartBody.Builder().setType(MultipartBody.FORM);
  4.       
  5.       //参数
  6.        HashMap<String,String> params = new HashMap<>();
  7.        if (params != null) {
  8.                 for (String key : params.keySet()) {
  9.                     if (params.get(key)!=null){
  10.                         urlBuilder.addFormDataPart(key, params.get(key));
  11.                     }
  12.                }
  13.             }
  14.         //需要上传的文件，需要携带上传的文件（小型文件 不建议超过500K）
  15.          HashMap<String,String> files= new HashMap<>();
  16.          if (files != null) {
  17.              for (String key : files.keySet()) {
  18.                 //重点：RequestBody create(MediaType contentType, final File file)构造文件请求体RequestBody 
  19.                  urlBuilder.addFormDataPart(key, files.get(key).getName(), RequestBody.create(MediaType.parse("multipart/form-data"), files.get(key)));
  20.                }
  21.              }
  22.            //构造请求request 
  23.             Request request = new Request.Builder()
  24.                             .headers(extraHeaders == null ? new Headers.Builder().build() : Headers.of(extraHeaders))
  25.                             .url(url)
  26.                             .post(urlBuilder.build())
  27.                             .build();
  28.          //异步执行请求
  29.           newCall(request).enqueue(new Callback() {
  30.             @Override
  31.             public void onFailure(Call call, IOException e) {
  32.                 Log.i("lfq" ,"onFailure");
  33.             }
  34.  
  35.             @Override
  36.             public void onResponse(Call call, Response response) throws IOException {
  37.                 //非主线程
  38.                 if (response.isSuccessful()) {
  39.                     String str = response.body().string();
  40.                     Log.i("tk", response.message() + " , body " + str);
  41.  
  42.                 } else {
  43.                     Log.i("tk" ,response.message() + " error : body " + response.body().string());
  44.                 }
  45.             }
  46.         });
  47.

2. 大文件分块异步上传
我们知道Post上传文件，简单的说就是将文件file封装成RequestBody体，然后添加到MultiPartBody的addPart中构造MultiPartBody所需要的Part对象(Headers+body),RequestBody是个抽象类，里面的所有create方法如下：

image.png

 

filebody.png


可以看出，基本都是重写了抽象类的RequestBody的三种方法，所以我们也可以继承实现自己的Body体：

image.png


EG：已上传相机图片（5M）为例，分块多线程异步同时上传，但是这种方法需要服务端接口才行。

 

  1. //文件路径
  2. String path = "xxx.jpg";

1,文件块对象

  1. public static final int FILE_BLOCK_SIZE = 500 * 1024;//500k
  2.  /*文件块描述*/
  3.     public static class FileBlock {
  4.         public long start;//起始字节位置
  5.         public long end;//结束字节位置
  6.         public int index;//文件分块索引
  7.     }

2,文件切块

  1.  //计算切块,存储在数组
  2.  final SparseArray<FileBlock> blockArray = splitFile(path, FILE_BLOCK_SIZE);
  3.  /**
  4.      * 文件分块
  5.      *
  6.      * @param filePath  文件路径
  7.      * @param blockSize 块大小
  8.      *
  9.      * @return 分块描述集合 文件不存在时返回空
  10.      */
  11.     public static SparseArray<FileBlock> splitFile(String filePath, long blockSize) {
  12.         File file = new File(filePath);
  13.         if (!file.exists()) {
  14.             return null;
  15.         }
  16.         SparseArray<FileBlock> blockArray = new SparseArray<>();
  17.         int i = 0;
  18.         int start = 0;
  19.         while (start < file.length()) {
  20.             i++;
  21.             FileBlock fileBlock = new FileBlock();
  22.             fileBlock.index = i;
  23.             fileBlock.start = start;
  24.             start += blockSize;
  25.             fileBlock.end = start;
  26.             blockArray.put(i, fileBlock);
  27.         }
  28.         blockArray.get(i).end = file.length();
  29.         return blockArray;
  30.     }
  31.

3,对文件块分块多线程异步上传
服务端的接口：

  1. url：domain/sync/img/upload
  2. method: POST
  3. //请求参数
  4. data = {
  5.         'img_md5': 'dddddsds',
  6.         'total': 10, #总的分片数
  7.         'index': 5, #该分片所在的位置, start by 1
  8.     }
  9. 请求返回值json:
  10.  {
  11.         'status': 206/205/400/409/500,
  12.         'msg': '分片上传成功/上传图片成功/参数错误/上传数据重复/上传失败'
  13.         'data': {  # 205时有此字段
  14.             'img_url': 'https://foo.jpg',
  15.         }
  16.     }

只需要图片的md5,总的分片数，该分片的位置，当一块传输成功时返回206，当全部块传完成是返回206，并返回该图片在服务器的url
服务端接口返回解析类：

  1. /**
  2.      * 分片上传部分的接口返回
  3.      *
  4.      * @link {http://10.16.69.11:5000/iSync/iSync%E6%9C%8D%E5%8A%A1%E7%AB%AFv4%E6%96%87%E6%A1%A3/index.html#4_1}
  5.      */
  6.     public static class ChuckUploadData  implements Serializable {
  7.         public ChuckUploadBean data;
  8.         public static class ChuckUploadBean implements Serializable{
  9.             public String img_url;
  10.         }
  11.         /** 此块是否上传成功 */
  12.         public boolean isPicSuccess() {
  13.             return status == 206 || status == 409;
  14.         }
  15.  
  16.         /** 全部原图是否上传成功 */
  17.         public boolean isAllPicSuccess() {
  18.             return status == 205;
  19.         }
  20.  
  21.         public boolean isRepitition(){
  22.             return status == 409;
  23.         }
  24.  
  25.     }
  26.    //上传图片的线程池
  27.    ExcutorService threadPool =  Executors.newCachedThreadPool();
  28.    //上传函数
  29.  /**
  30.      * 上传原图,异步上传
  31.      *
  32.      * @param httpCallback 回调接口
  33.      * @param md5         文件md5
  34.      * @param path         图片路径
  35.      * @param total        总块数
  36.      * @param index        分块索引
  37.      * @param start        分块开始位置
  38.      * @param end          分块结束位置
  39.      */
  40.     public static void uploadBigImage(String userId, final HttpListenerAdapter<ChuckUploadData> httpCallback, String md5, String path, int total, int index, long start, long end) {
  41.         HashMap<String, String> params = new HashMap<String, String>();
  42.         params.put("img_uuid", uuid);//完整文件的md5
  43.         params.put("total", String.valueOf(total));//总的分片数
  44.         params.put("index", String.valueOf(index));//当前分片位置，从1开始
  45.         //全局单例OKHttpClient
  46.         OkHttpClient httpClient = DataProvider.getInstance().inkApi.getLongWaitHttpClient();
  47.  
  48.         Runnable httpUploadRunnable = HttpRunnableFactory.newPostFileBlockRunnable(
  49.                 httpClient,
  50.                 upload_url,//上传url，自定义
  51.                 null,
  52.                 params,//上传参数
  53.                 "image",
  54.                 new File(path),//图片文件
  55.                 start,//index块开始的位置
  56.                 end,//index块结束的位置
  57.                 ChuckUploadData.class,
  58.                 httpCallback);//回调函数
  59.         threadManager.submit httpUploadRunnable );
  60.     }
  61.  /**
  62.      * 异步post请求 表单方式拆块上传大型文件用，构造Runnable 
  63.      *
  64.      * @param httpClient  okhttp客户端
  65.      * @param url         请求地址
  66.      * @param headers     额外添加的header（通用header由中断器统一添加）
  67.      * @param params      请求参数
  68.      * @param fileKey     文件的接收用key
  69.      * @param file        大型文件对象
  70.      * @param seekStart   起始字节
  71.      * @param seekEnd     结束字节
  72.      * @param cls         返回结果需要序列化的类型
  73.      * @param listener    异步回调
  74.      * @param <T>         返回结果需要序列化的类型声明
  75.      *
  76.      * @return 异步post请求用的默认Runnable
  77.      */
  78.     public static <T> Runnable newPostFileBlockRunnable(final OkHttpClient httpClient,  final String url, final Map<String, String> headers, final Map<String, String> params, final String fileKey, final File file, final long seekStart, final long seekEnd, final Class<T> cls, final HttpListenerAdapter<T> listener) {
  79.         return new Runnable () {
  80.             @Override
  81.             public void run() {
  82.                 Log.e("http", "---postfile---");
  83.                 Log.e("http", "url: " + url);
  84.                 Log.e("http", "extraHeaders: " + headers);
  85.                 Log.e("http", "params: " + params);
  86.                 Log.e("http", "filepath: " + file.getPath());
  87.                 Log.e("http", "seekStart: " + seekStart);
  88.                 Log.e("http", "seekEnd: " + seekEnd);
  89.  
  90.                 Call call = null;
  91.                 if (listener != null) {
  92.                     listener.onStart(call);
  93.                 }
  94.                 try {
  95.                     if (TextUtils.isEmpty(url)) {
  96.                         throw new InterruptedException("url is null exception");
  97.                     }
  98.                      //构造path文件的index块的seekStart到seekEnd的请求体requestBody ，添加到MultiPartBody中
  99.                     RequestBody requestBody = new RequestBody() {
  100.                         @Override
  101.                         public MediaType contentType() {
  102.                            //请求体的内容类型
  103.                             return MediaType.parse("multipart/form-data");
  104.                         }
  105.  
  106.                         @Override
  107.                         public void writeTo(BufferedSink sink) throws IOException {
  108.                             //切块上传
  109.                             long nowSeek = seekStart;
  110.                             long seekEndWrite = seekEnd;
  111.                             if (seekEndWrite == 0) {
  112.                                 seekEndWrite = file.length();
  113.                             }
  114.                             //跳到开始位置
  115.                             FileInputStream in = new FileInputStream(file);
  116.                             if (seekStart > 0) {
  117.                                 long amt = in.skip(seekStart);
  118.                                 if (amt == -1) {
  119.                                     nowSeek = 0;
  120.                                 }
  121.                             }
  122.                             //将该块的字节内容写入body的BufferedSink 中
  123.                             int len;
  124.                             byte[] buf = new byte[BUFFER_SIZE_DEFAULT];
  125.                             while ((len = in.read(buf)) >= 0 && nowSeek < seekEndWrite) {
  126.                                 sink.write(buf, 0, len);
  127.                                 nowSeek += len;
  128.                                 if (nowSeek + BUFFER_SIZE_DEFAULT > seekEndWrite) {
  129.                                     buf = new byte[Integer.valueOf((seekEndWrite - nowSeek) + "")];
  130.                                 }
  131.                             }
  132.                             closeStream(in);
  133.                         }
  134.  
  135.                     };
  136.                     //组装其它参数
  137.                     MultipartBody.Builder urlBuilder = new MultipartBody.Builder()
  138.                             .setType(MultipartBody.FORM);
  139.                     if (params != null) {
  140.                         for (String key : params.keySet()) {
  141.                             //urlBuilder.addFormDataPart(key, params.get(key));
  142.                             if (params.get(key)!=null){
  143.                                 urlBuilder.addFormDataPart(key, params.get(key));
  144.                             }
  145.                         }
  146.                     }
  147.                     //把文件块的请求体添加到MultiPartBody中
  148.                     urlBuilder.addFormDataPart(fileKey, file.getName(), requestBody);
  149.                     Request request = new Request.Builder()
  150.                             .headers(headers == null ? new Headers.Builder().build() : Headers.of(headers))
  151.                             .url(url)
  152.                             .post(urlBuilder.build())
  153.                             .build();
  154.  
  155.                     call = httpClient.newCall(request);
  156.                     //虽说是同步调用call.execute()，但是此Http请求过程是在线程池中的，相当于异步调用
  157.                     try (Response response = call.execute()) {
  158.                         if (!response.isSuccessful()){
  159.                             throw new IOException("Unexpected code " + response.code());
  160.                         }
  161.                          /*打印json串，json样式的*/
  162.                         String json = response.body().string();
  163.                         //解析返回的响应json
  164.                         T result = JsonUtils.getObjFromStr(cls, json);
  165.                         if (listener != null) {
  166.                             //防止回调内的业务逻辑引起二次onFailure回调
  167.                             try {
  168.                                 listener.onResponse(call, result);
  169.                             } catch (Exception e) {
  170.                                 e.printStackTrace();
  171.                             }
  172.                         }
  173.                     } finally {
  174.                        
  175.                     }
  176.                 } catch (Exception e) {
  177.                     if (listener != null) {
  178.                         //中途取消导致的中断
  179.                         if (call != null && call.isCanceled()) {
  180.                             listener.onCancel(call);
  181.                         } else {
  182.                             //其它意义上的请求失败
  183.                             listener.onFailure(call, e);
  184.                         }
  185.                     }
  186.                 } finally {
  187.                     if (listener != null) {
  188.                         listener.onEnd(call);
  189.                     }
  190.                 }
  191.             }
  192.         };
  193.     }
  1. //循环遍历所有的文章块，多线程上传
  2.  for (int i = 0; i < blockArray.size(); i++) {
  3.              //异步分块上传
  4.               final FileUtil.FileBlock block = blockArray.get(i + 1);
  5.               //提交线程池，异步上传单块
  6.             uploadBigImage(userId, new HttpListenerAdapter<ChuckUploadData>() {
  7.                          @Override
  8.                          public void onResponse(Call call, SyncBeans.ChuckUploadData bean) {
  9.                               try {
  10.                                    //单块上传
  11.                                     if (bean != null ) {
  12.                                           if (bean.isPicSuccess()) {
  13.                                                 //205,单块成功不做处理
  14.                                            } else if (bean.isAllPicSuccess()) {
  15.                                                //206,全部成功
  16.                                            }
  17.                                       }
  18.                                 }catch(Exception e){}
  19.                             },uuid, mediaBean.imageNativeUrl, blockArray.size(), block.index, block.start, block.end);
  20.      }           
  21.

5. OKHttp下载文件，并通知进度

下载文件的原理其实很简单，下载过程其实就是一个GET过程(上传文件是POST过程相对应)，下载文件需要在异步线程中执行（方法有二，1，使用okhttp的call.enquene()方法异步执行，2，使用call.excute()同步方法，但是在线程次中执行整个请求过程），在成功响应之后，获得网络文件输入流InputStream，然后循环读取输入流上的文件，写入文件输出流。

  1. /**
  2.      * @param url 下载连接
  3.      * @param saveDir 储存下载文件的SDCard目录
  4.      * @param params url携带参数
  5.      * @param extraHeaders 请求携带其他的要求的headers
  6.      * @param listener 下载监听
  7.      */
  8.     public void download(final String url, final String saveDir,HashMap<String,String> params, HashMap<String,String> extraHeaders，final OnDownloadListener listener) {
  9.        //构造请求Url
  10.        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
  11.            if (params != null) {
  12.                for (String key : params.keySet()) {
  13.                    if (params.get(key)!=null){
  14.                       urlBuilder.setQueryParameter(key, params.get(key));//非必须
  15.                      } 
  16.               }
  17.             }
  18.         //构造请求request
  19.          Request request = new Request.Builder()
  20.                             .url(urlBuilder.build())
  21.                             .headers(extraHeaders == null ? new Headers.Builder().build() : Headers.of(extraHeaders))//headers非必须
  22.                             .get()
  23.                             .build();
  24.        //异步执行请求
  25.         okHttpClient.newCall(request).enqueue(new Callback() {
  26.             @Override
  27.             public void onFailure(Call call, IOException e) {
  28.                 // 下载失败
  29.                 listener.onDownloadFailed();
  30.             }
  31.             @Override
  32.             public void onResponse(Call call, Response response) throws IOException {
  33.                //非主线程
  34.                 InputStream is = null;
  35.                 byte[] buf = new byte[2048];
  36.                 int len = 0;
  37.                 FileOutputStream fos = null;
  38.                 // 储存下载文件的目录
  39.                 String savePath = isExistDir(saveDir);
  40.                 try {
  41.                     //获取响应的字节流
  42.                     is = response.body().byteStream();
  43.                     //文件的总大小
  44.                     long total = response.body().contentLength();
  45.                     File file = new File(savePath);
  46.                     fos = new FileOutputStream(file);
  47.                     long sum = 0;
  48.                    //循环读取输入流
  49.                     while ((len = is.read(buf)) != -1) {
  50.                         fos.write(buf, 0, len);
  51.                         sum += len;
  52.                         int progress = (int) (sum * 1.0f / total * 100);
  53.                         // 下载中
  54.                         if(listener != null){
  55.                             listener.onDownloading(progress);
  56.                          }
  57.                        
  58.                     }
  59.                     fos.flush();
  60.                     // 下载完成
  61.                     if(listener != null){
  62.                           listener.onDownloadSuccess();
  63.                      }
  64.                 
  65.                 } catch (Exception e) {
  66.                      if(listener != null){
  67.                           listener.onDownloadFailed();
  68.                      }
  69.                    
  70.                 } finally {
  71.                     try {
  72.                         if (is != null)
  73.                             is.close();
  74.                     } catch (IOException e) {
  75.                     }
  76.                     try {
  77.                         if (fos != null)
  78.                             fos.close();
  79.                     } catch (IOException e) {
  80.                     }
  81.                 }
  82.             }
  83.         });
  84.     }

至此，OKHTTP3的基本网络请求访问，发送GET请求，发送POST请求，基本上传文件，切块多线程异步上传文件，下载文件就到这里了，其实下载文件还可以做成断点续传，获取每次的seek点

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/blog/article/detail/45631
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号