request类详解

先来个图文结合：
在这里插入图片描述

public final class Request {
    
    
  private final HttpUrl url;
  private final String method;
  private final Headers headers;
  private final RequestBody body;
  private final Object tag;

  private volatile URI javaNetUri; // Lazily initialized.
  private volatile CacheControl cacheControl; // Lazily initialized.
  }

1.HttpUrl

HttpUrl主要用来规范普通的url连接，并且解析url的组成部分
现通过下面的例子来示例httpUrl的使用

https://www.google.com/search?q=maplejaw
①使用parse解析url字符串：

HttpUrl url = HttpUrl.parse("https://www.google.com/search?q=maplejaw");
②通过构造者模式来常见:

1 HttpUrl url = new HttpUrl.Builder()
2         .scheme("https")
3         .host("www.google.com")
4         .addPathSegment("search")
5         .addQueryParameter("q", "maplejaw")
6         .build();

我们通常设置一个请求的url如下所示：

Request request = new Request.Builder().url("https://www.google.com/search?q=maplejaw").build();

Request类提供了三个设置url方法，其原理都是调用HttpUrl.parse(）来解析url字符串，感兴趣的小伙伴可以自己去看一下HttpUrl源码。

2.Headers

Headers用于配置请求头，对于请求头配置大家一定不陌生吧，比如Content-Type,User-Agent和Cache-Control等等。
(1)of()创建：传入的数组必须是偶数对，否则会抛出异常。

Headers.of("name1","value1","name2","value2",.....);

还可以使用它的重载方法of(Map<String,String> map)方法来创建

(2)构建者模式创建：

Headers mHeaders=new Headers.Builder()
            .set("name1","value1")//set表示name1是唯一的，会覆盖掉已经存在的
            .add("name2","value2")//add不会覆盖已经存在的头，可以存在多个
            .build();

我们来看一下Header的内部，源码就不粘贴了很简单，Headers内部是通过一个数组来保存header private final String[] namesAndValues;大家可能会有这样的疑问，为什么不用Map而用数组呢？因为Map的Key是唯一的，而header要求不唯一

另外，数组方便取数据吗？很方便，我们来看着三个方法

最后通过toString方法转变成String，方便写入请求头，

复制代码
1

扫描二维码关注公众号，回复： 12620167 查看本文章

 @Override 
 2 public String toString() {
    
    
 3     StringBuilder result = new StringBuilder();
 4     for (int i = 0, size = size(); i < size; i++) {
    
    
 5       result.append(name(i)).append(": ").append(value(i)).append("\n");
 6     }
 7     return result.toString();
 8 }
 9 
10 /** Returns the field at {@code position} or null if that is out of range. */
11 public String name(int index) {
    
    
12     int nameIndex = index * 2;
13     if (nameIndex < 0 || nameIndex >= namesAndValues.length) {
    
    
14       return null;
15     }
16     return namesAndValues[nameIndex];
17 }
18  
19 /** Returns the value at {@code index} or null if that is out of range. */
20 public String value(int index) {
    
    
21     int valueIndex = index * 2 + 1;
22     if (valueIndex < 0 || valueIndex >= namesAndValues.length) {
    
    
23       return null;
24     }
25     return namesAndValues[valueIndex];
26   }

3.RequestBody

requestBody也就是请求实体内容，我们先来看一下如何来构建一个RequestBody

(1)Request.create()方法创建
在这里插入图片描述

 1 public static final MediaType TEXT = MediaType.parse("text/plain; charset=utf-8");
 2 public static final MediaType STREAM = MediaType.parse("application/octet-stream");
 3 public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
 4 
 5 //构建字符串请求体
 6 RequestBody body1 = RequestBody.create(TEXT, string);
 7 //构建字节请求体
 8 RequestBody body2 = RequestBody.create(STREAM, byte);
 9 //构建文件请求体
10 RequestBody body3 = RequestBody.create(STREAM, file);
11 //post上传json
12 RequestBody body4 = RequestBody.create(JSON, json);//json为String类型的
13 
14 //将请求体设置给请求方法内
15 Request request = new Request.Builder()
16 .url(url)
17 .post(xx)// xx表示body1，body2，body3，body4中的某一个
18 .build();

(2)构建表单请求体,提交键值对(OkHttp3没有FormEncodingBuilder这个类，替代它的是功能更加强大的FormBody：)

 //构建表单RequestBody
RequestBody formBody=new FormBody.Builder()
                 .add("name","maplejaw")
                 .add("age","18")
                  ...     
                 .build();

(3)构建分块表单请求体:(OkHttp3取消了MultipartBuilder,取而代之的是MultipartBody.Builder()
既可以添加表单,又可以也可以添加文件等二进制数据)

 1 public static final MediaType STREAM = MediaType.parse("application/octet-stream");
 2  //构建表单RequestBody
 3 RequestBody multipartBody=new MultipartBody.Builder()
 4                 .setType(MultipartBody.FORM)//指明为 multipart/form-data 类型
 5                 .addFormDataPart("age","20") //添加表单数据
 6                 .addFormDataPart("avatar","111.jpg",RequestBody.create(STREAM,file)) //添加文件,其中avatar为表单名，111.jpg为文件名。
 7                 .addPart(..)//该方法用于添加RequestBody,Headers和添加自定义Part，一般来说以上已经够用
 8                 .build();

3.1 MultipartBody

我们重点来分析一下MultipartBody：

public final class MultipartBody extends RequestBody {
    
    

  public static final MediaType MIXED = MediaType.parse("multipart/mixed");
  
  public static final MediaType ALTERNATIVE = MediaType.parse("multipart/alternative");

  public static final MediaType DIGEST = MediaType.parse("multipart/digest");

  public static final MediaType PARALLEL = MediaType.parse("multipart/parallel");

  public static final MediaType FORM = MediaType.parse("multipart/form-data");
  
}

MultipartBody 定义了五种MediaType类型，我们主要用到multipart/mixed 和 multipart/form-data 这两种类型，事实上只要会用这两个类型就能应用于绝大部分场景了。那么这两种类型有什么区别呢？
multipart/mixed 和 multipart/form-date 都是多文件上传的格式。区别在于：multipart/form-data 是一种特殊的表单上传，其中普通字段的内容还是按照一般的请求体构建，文件字段的内容按照 multipart 请求体构建，后端在处理 multipart/form-data 请求的时候，会在服务器上建立临时的文件夹存放文件内容，而 multipart/mixed 请求会将每个字段的内容，不管是普通字段还是文件字段，都变成 Stream 流的方式去上传，因此后端在处理 multipart/mixed 的内容时，必须从 Stream 流中读取。如下所示：

Part signPart = request.getPart(Constants.SIGN_KEY);
Part appidPart = request.getPart(Constants.APPID_KEY);
Part noncestrPart = request.getPart(Constants.NONCESTR_KEY);
paramMap.put(signPart.getName(), new String[]{
    
    stream2Str(signPart.getInputStream())});
paramMap.put(appidPart.getName(), new String[]{
    
    stream2Str(appidPart.getInputStream())});
paramMap.put(noncestrPart.getName(), new String[]{
    
    stream2Str(noncestrPart.getInputStream())});

其实按照我的理解，MultipartBody就是多个RequestBody的集合体吧，就好比我们可以即上传表单，也可以上传文件，而不是分别创建一个表单类型（application/x-www-form-urlencoded）的RequestBody和文件类型（比如图片image/jpeg），事实上在multipartBody中方法里，无论是addFormDataPart( ) 还是 addpart( )，最终都是调用 addPart(Part part)这个方法，口说无凭，我们跟着来看一下源码：
public final class MultipartBody extends RequestBody {

先来看看内部类part

 public static final class Part {
    
    
    public static Part create(RequestBody body) {
    
    
      return create(null, body);
    }

    public static Part create(Headers headers, RequestBody body) {
    
    
      return new Part(headers, body);
    }

    public static Part createFormData(String name, String value) {
    
    
      return createFormData(name, null, RequestBody.create(null, value));
    }

    public static Part createFormData(String name, String filename, RequestBody body) {
    
    
      StringBuilder disposition = new StringBuilder("form-data; name=");
      appendQuotedString(disposition, name);
      if (filename != null) {
    
    
        disposition.append("; filename=");
        appendQuotedString(disposition, filename);
      }
      return create(Headers.of("Content-Disposition", disposition.toString()), body);
    }

    private final Headers headers;
    private final RequestBody body;

    private Part(Headers headers, RequestBody body) {
    
    
      this.headers = headers;
      this.body = body;
    }
  }
}

从part类的源码上看，最终都会调用Part类的构造方法 Part(Headers headers, RequestBody body)，最终给私有变量Headers 和 RequestBody 赋值。那么这个内部类Part有什么用呢?其实MultipartBody 的原理就是把一个个RequestBody作为参数封装进Part这个内部类中，最终通过createFormData( ) 和 addPart( ) 方法将这些part存入parts这个集合中，最终通过build( ) 这个方法（ new MultipartBody(boundary, type, parts)）封装成RequsetBody作为Post请求方式的参数发出Http请求。源码如下：

public Class MultipartBody{
    
    

......
 private final List<Part> parts;

public Builder addPart(Headers headers, RequestBody body) {
    
    
  return addPart(Part.create(headers, body));
}

/** Add a form data part to the body. */
public Builder addFormDataPart(String name, String value) {
    
    
  return addPart(Part.createFormData(name, value));
}

/** Add a form data part to the body. */
public Builder addFormDataPart(String name, String filename, RequestBody body) {
    
    
  return addPart(Part.createFormData(name, filename, body));
}

public Builder addPart(Part part) {
    
    
      if (part == null) throw new NullPointerException("part == null");
      parts.add(part);
      return this;
    }

.....
}

如上，最终都是调用Part内部类中的方法生成part对象，并且作为Parts集合的元素储存前来，最终通过build( ) 方法封装成RequestBody。

3.2 FormBody

相比MultipartBody，FormBody就比较简单，先来看看FormBody的基本使用：

1  RequestBody formBody=new FormBody.Builder()
2                  .add("name","zhangsan")
3                  .add("age","10")
4                   ...     
5                  .build();

public final class FormBody extends RequestBody {
    
    
  private static final MediaType CONTENT_TYPE =
      MediaType.parse("application/x-www-form-urlencoded");

  private final List<String> encodedNames;
  private final List<String> encodedValues;

  private FormBody(List<String> encodedNames, List<String> encodedValues) {
    
    
    this.encodedNames = Util.immutableList(encodedNames);
    this.encodedValues = Util.immutableList(encodedValues);
  }
.......

  public static final class Builder {
    
    
    private final List<String> names = new ArrayList<>();
    private final List<String> values = new ArrayList<>();

    public Builder add(String name, String value) {
    
    
      names.add(HttpUrl.canonicalize(name, FORM_ENCODE_SET, false, false, true, true));
      values.add(HttpUrl.canonicalize(value, FORM_ENCODE_SET, false, false, true, true));
      return this;
    }

    public Builder addEncoded(String name, String value) {
    
    
      names.add(HttpUrl.canonicalize(name, FORM_ENCODE_SET, true, false, true, true));
      values.add(HttpUrl.canonicalize(value, FORM_ENCODE_SET, true, false, true, true));
      return this;
    }

    public FormBody build() {
    
    
      return new FormBody(names, values);
    }
  }
....


}

创建两个集合分别为encodedNames（存储表单键值对里的键），encodedValues（存储键值对里的值），再来看add( ),通过HttpUrl标准化后作为集合的元素存储起来，最终通过build调用FormBody的构造器对两个集合进行赋值并且返回RequestBody类型。

4.CacheControl

4.1 Cache-Control：

Cache-Control指定请求和响应遵循的缓存机制。在请求消息或响应消息中设置Cache-Control并不会修改另一个消息处理过程中的缓存处理过程。请求时的缓存指令有下几种：

Public：所有内容都将被缓存(客户端和代理服务器都可缓存)。
Private：内容只缓存到私有缓存中(仅客户端可以缓存，代理服务器不可缓存)
no-cache：请求或者响应消息不能缓存
no-store：不使用缓存，也不存储缓存
max-age：缓存的内容将在指定时间(秒)后失效, 这个选项只在HTTP 1.1可用, 并如果和Last-Modified一起使用时,优先级较高
在 xxx 秒后，浏览器重新发送请求到服务器，指定时间(秒)内,客户端会直接返回cache而不会发起网络请求，若过期会自动发起网络请求
min-fresh：指示客户端可以接收响应时间小于当前时间加上指定时间的响应。
max-stale：指示客户端可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。

4.2 CacheControl类

①常用的函数

复制代码

 final CacheControl.Builder builder = new CacheControl.Builder();
            builder.noCache();//不使用缓存，全部走网络
            builder.noStore();//不使用缓存，也不存储缓存
            builder.onlyIfCached();//只使用缓存
            builder.noTransform();//禁止转码
            builder.maxAge(10, TimeUnit.MILLISECONDS);//指示客户机可以接收生存期不大于指定时间的响应。
            builder.maxStale(10, TimeUnit.SECONDS);//指示客户机可以接收超出超时期间的响应消息
            builder.minFresh(10, TimeUnit.SECONDS);//指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
            CacheControl cache = builder.build();//cacheControl

复制代码
②CacheControl的两个常量：

 public static final CacheControl FORCE_NETWORK = new Builder().noCache().build();//不使用缓存
  public static final CacheControl FORCE_CACHE = new Builder()
      .onlyIfCached()
      .maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS)
      .build();//只使用缓存

③请求时如何使用:

final CacheControl.Builder builder = new CacheControl.Builder();
            builder.maxAge(10, TimeUnit.MILLISECONDS);
            CacheControl cache = builder.build();
            final Request request = new Request.Builder().cacheControl(cache).url(requestUrl).build();
            final Call call = mOkHttpClient.newCall(request);//
            call.enqueue(new Callback() {
    
    
                @Override
                public void onFailure(Call call, IOException e) {
    
    
                    failedCallBack("访问失败", callBack);
                    Log.e(TAG, e.toString());
                }
 
                @Override
                public void onResponse(Call call, Response response) throws IOException {
    
    
                    if (response.isSuccessful()) {
    
    
                        String string = response.body().string();
                        Log.e(TAG, "response ----->" + string);
                        successCallBack((T) string, callBack);
                    } else {
    
    
                        failedCallBack("服务器错误", callBack);
                    }
                }
            });
            return call;
        } catch (Exception e) {
    
    
            Log.e(TAG, e.toString());
        }

以上如果Cache没有过期会直接返回cache而不会去发起网络请求，若过期自动发起网络请求，注意：如果您使用FORCE_CACHE和网络的响应需求，OkHttp则会返回一个504提示，告诉你不可满足请求响应，所以我们加一个判断在没有网络的情况下使用

//判断网络是否连接

   boolean connected = NetworkUtil.isConnected(context);
     if (!connected) {
    
    
         request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
      }