Android okhttp实现请求步骤；okhttp设计模式，拦截器

用到的设计模式：责任链设计模式、构造者模式、观察者、工厂模式、单例模式、策略模式

• 责任链

5个拦截器；

它把实际的网络请求、缓存、透明压缩等功能都统一了起来，每一个功能都只是一个 Interceptor，它们再连接成一个 Interceptor.Chain，环环相扣，最终圆满完成一次网络请求。

• 观察者：

源码中的EventListener对请求/响应过程中的每一个Event通过方法回调的方式通知前方用户，用户需要自己实现EventListener中的所需要的方法：

public abstract class EventListener {
  ...
  public void requestHeadersStart(Call call) {}
  public void requestHeadersEnd(Call call, Request request) {}
  public void requestBodyStart(Call call) {}
  public void requestBodyEnd(Call call, long byteCount) {}
  public void responseHeadersStart(Call call) {}
  public void responseHeadersEnd(Call call, Response response) {}
  public void responseBodyStart(Call call) {}
  public void responseBodyEnd(Call call, long byteCount) {}
  ...
}

 

使用了abstract抽象类，而不是接口，这样用户可以选择实现需要的方法。

• 工厂模式：

public interface Call extends Cloneable {
  
  Request request();
  Response execute() throws IOException; 
  void enqueue(Callback responseCallback);
  void cancel();  
  boolean isExecuted();  
  boolean isCanceled(); 
  Call clone();
  //创建Call实现对象的工厂
  interface Factory {
    //创建新的Call，里面包含了Request对象。
    Call newCall(Request request);
  }
}
​
public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
  @Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false /* for web socket */);
  }
}
​
final class RealCall implements Call {
  ......
}

在Call接口中，有一个内部工厂Factory接口。这样只要像下面这样就可以了：

• 实现Call接口，现实相应的功能，RealCall；

• 使用某个类（OkHttpClient）实现Call.Factory接口，在newCall中返回RealCall对象，就可以了。

• 策略模式

在CacheInterceptor中，在响应数据的选择中使用了策略模式，选择缓存数据还是选择网络访问。

CacheInterceptor根据一个缓存策略，来决定选择缓存数据，还是网络请求数据：

1、 请求头包含 “If-Modified-Since” 或 “If-None-Match” 暂时不走缓存
2、 客户端通过 cacheControl 指定了无缓存，不走缓存
3、客户端通过 cacheControl 指定了缓存，则看缓存过期时间，符合要求走缓存。

4、 如果走了网络请求，响应状态码为 304（只有客户端请求头包含 “If-Modified-Since” 或 “If-None-Match” ，服务器数据没变化的话会返回304状态码，不会返回响应内容）， 表示客户端继续用缓存。
 

    private static String testOkhttp(String url, HashMap<String, String> headers, HashMap<String, String> params){

        OkHttpClient client = new OkHttpClient();

        OkHttpClient.Builder builder = client.newBuilder();
        builder.connectTimeout(10, TimeUnit.SECONDS);
        builder.readTimeout(30,TimeUnit.SECONDS);
        builder.writeTimeout(30,TimeUnit.SECONDS);
        builder.hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true;
            }
        });

        builder.build();

        Request.Builder requestBuilder = new Request.Builder();

        requestBuilder.addHeader("Content-Type", "application/json; charset=utf-8");

        if (headers!=null){
            for (String s : headers.keySet()) {
                requestBuilder.addHeader(s,headers.get(s));
            }
        }
        if (params!=null){
            FormBody.Builder forbody=new FormBody.Builder();
            for (String s : params.keySet()) {
                forbody.add(s,params.get(s));
            }
            requestBuilder.post(forbody.build());
        }
        requestBuilder.url(url);

        Request request = requestBuilder.build();

        try {
            Response response = client.newCall(request).execute();
            if (response != null && response.code() == 200) {
                return response.body().string();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        return "";
    }

单例模式

首先，创建OkHttpClient对象的时候，就推荐使用单例模式，防止创建多个OkHttpClient对象，损耗资源；

然后，代码中的单例模式：

public class Platform {
  private static final Platform PLATFORM = findPlatform();
  ...
  public static Platform get() {  
    return PLATFORM;  
  }
  ...
}

1.RetryAndFollowUpInterceptor：失败重试、重定向拦截器。它的主要作用是负责失败重连。OkHttp中的重定向功能是默认开启的。

2.BridgeInterceptor桥拦截器：主要是添加和删除一些header
3.CacheInterceptor缓存拦截器：根据缓存策略，如果缓存可用，直接返回缓存数据。
4.ConnectInterceptor连接池拦截器：连接池会缓存http链接，连接池的好处是复用连接，少了3次握手，所以请求会更快
5.CallServerInterceptor真正访问网络的拦截器：内部使用okio去发请求；请求服务器拦截器将 http 请求写进 IO 流当中，并且从 IO 流中读取响应 Response