有兴不虚昧
有兴不虚昧

Okhttp源码学习三（重试和重定向，桥接，缓存拦截器的内部原理）

OkHttp 内置了 5 个拦截器，在每一个拦截器里，分别对请求信息和响应值做了处理，每一层只做当前相关的操作，这五个拦截器分别是：

RetryAndFollowUpInterceptor，BridgeInterceptor，CacheInterceptor，ConnectInterceptor，CallServerInterceptor.

他们的作用分别如下：

  1. RetryAndFollowUpInterceptor：取消、失败重试、重定向
  2. BridgeInterceptor：把用户请求转换为 HTTP 请求；把 HTTP 响应转换为用户友好的响应
  3. CacheInterceptor：读写缓存、根据策略决定是否使用
  4. ConnectInterceptor：和服务器建立连接
  5. CallServerInterceptor：实现读写数据

RetryAndFollowUpInterceptor

通过前面对OkHttp拦截器拦截过程的学习，我们知道，在请求的时候，RetryAndFollowUpInterceptor是第一个会被调用的内置拦截器,拦截器的核心逻辑就在拦截方法：

@Override
public Response intercept(Chain chain) throws IOException {
  Request request = chain.request();
  RealInterceptorChain realChain = (RealInterceptorChain) chain;
  Call call = realChain.call();
  EventListener eventListener = realChain.eventListener();
  //注意：新创建了一个流分配管理类对象，这个类很重要
  StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
    createAddress(request.url()), call, eventListener, callStackTrace);
  this.streamAllocation = streamAllocation;

  int followUpCount = 0;    //重定向次数
  Response priorResponse = null;
  while (true) {            //while循环
    if (canceled) {        //检查当前请求是否被取消，如果这时请求被取消了，则会通StreamAllocation释放连接
      streamAllocation.release();
      throw new IOException("Canceled");
    }

    Response response;
    boolean releaseConnection = true;  
    try {
      response = realChain.proceed(request, streamAllocation, null, null);
      releaseConnection = false;  //请求过程中，只要发生未处理的异常，releaseConnection 就会  为true，一旦变为true，就会将StreamAllocation释放掉
    } catch (RouteException e) {
      // The attempt to connect via a route failed. The request will not have been sent.
    if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {
      throw e.getLastConnectException();
    }
      releaseConnection = false;
      continue;        //发生异常就继续循环
    } catch (IOException e) {
      // An attempt to communicate with a server failed. The request may have been sent.
      boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
      if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;
      releaseConnection = false;
      continue;      //继续循环
    } finally {
    // We're throwing an unchecked exception. Release any resources.
      if (releaseConnection) {      //releaseConnection一旦为true，就释放连接
        streamAllocation.streamFailed(null);
        streamAllocation.release();
      }
    }

  // Attach the prior response if it exists. Such responses never have a body.
    if (priorResponse != null) {   
      response = response.newBuilder()
          .priorResponse(priorResponse.newBuilder()
                .body(null)
                .build())
        .build();
    }
   //根据 code 和 method 判断是否需要重定向请求
    Request followUp = followUpRequest(response, streamAllocation.route());

    if (followUp == null) {    //不需要重定向时直接返回结果
      if (!forWebSocket) {
        streamAllocation.release();
      }
      return response;
    }

    closeQuietly(response.body());
    //重定向次数先+1,然后判断是否大于重定向次数的最大值20
    if (++followUpCount > MAX_FOLLOW_UPS) {
      streamAllocation.release();
      throw new ProtocolException("Too many follow-up requests: " + followUpCount);
    }

    if (followUp.body() instanceof UnrepeatableRequestBody) {
      streamAllocation.release();
      throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
    }
    //是否可以复用当前连接，如果不能，则释放当前连接，重新建立连接
    if (!sameConnection(response, followUp.url())) {
      streamAllocation.release();
      streamAllocation = new StreamAllocation(client.connectionPool(),
        createAddress(followUp.url()), call, eventListener, callStackTrace);
      this.streamAllocation = streamAllocation;
    } else if (streamAllocation.codec() != null) {
      throw new IllegalStateException("Closing the body of " + response
          + " didn't close its backing stream. Bad interceptor?");
    }

    request = followUp;
    priorResponse = response;
 }
}

可以看到RetryAndFollowUpInterceptor的拦截操作:

  1. 新建了一个流引用分配管理类 StreamAllocation对象，也就是说，每一次请求都会新建一个StreamAllocation，因为RetryAndFollowUpInterceptor是第一个拦截器
  2. 然后在一个 while 循环中调用拦截器链的 proceed() 方法，执行下一个拦截器
  3. 拿到响应的过程中如果出现路由异常、IO 异常，就 continue 请求（即失败重试）
  4. 根据拿到的响应结果， 在followUpRequest()方法中判断是否需要重定向，如果不需要直接返回响应结果
  5. 如果需要重定向，先判断重定向次数是否超过最大值，在判断重定向请求是否可以复用当前连接，如果不可以，则要释放当前连接并新建
  6. 重新设置request，并将当前响应赋值给priorResponse ，继续while循环

那么okhttp是怎么判断需要重定向的呢，看下followUpRequest()

private Request followUpRequest(Response userResponse, Route route) throws IOException {
  if (userResponse == null) throw new IllegalStateException();
  //响应状态码
  int responseCode = userResponse.code();
  //请求method
  final String method = userResponse.request().method();
  switch (responseCode) {
  case HTTP_PROXY_AUTH:        //407代理服务器验证
    Proxy selectedProxy = route != null
        ? route.proxy()
        : client.proxy();
    if (selectedProxy.type() != Proxy.Type.HTTP) {
      throw new ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy");
    }
    return client.proxyAuthenticator().authenticate(route, userResponse);

  case HTTP_UNAUTHORIZED:    //401，未验证
    return client.authenticator().authenticate(route, userResponse);

  case HTTP_PERM_REDIRECT:    //308
  case HTTP_TEMP_REDIRECT:    //307
    // "If the 307 or 308 status code is received in response to a request other than GET
    // or HEAD, the user agent MUST NOT automatically redirect the request"
    if (!method.equals("GET") && !method.equals("HEAD")) {
      return null;
    }
    // fall-through
  case HTTP_MULT_CHOICE:       //300
  case HTTP_MOVED_PERM:        //301
  case HTTP_MOVED_TEMP:        //302
  case HTTP_SEE_OTHER:         //303
    // Does the client allow redirects?
    //okHttpClient不允许重定向，返回null
    if (!client.followRedirects()) return null;

    String location = userResponse.header("Location");
    if (location == null) return null;
    //根据location拿到要重定向的url
    HttpUrl url = userResponse.request().url().resolve(location);

    // Don't follow redirects to unsupported protocols.
    if (url == null) return null;

    // If configured, don't follow redirects between SSL and non-SSL.
    boolean sameScheme = url.scheme().equals(userResponse.request().url().scheme());
    //如果url不同，并且不允许ssl重定向，返回null
    if (!sameScheme && !client.followSslRedirects()) return null;

    // Most redirects don't include a request body.
    Request.Builder requestBuilder = userResponse.request().newBuilder();
    if (HttpMethod.permitsRequestBody(method)) {
      final boolean maintainBody = HttpMethod.redirectsWithBody(method);
      if (HttpMethod.redirectsToGet(method)) {
        requestBuilder.method("GET", null);
      } else {
        RequestBody requestBody = maintainBody ? userResponse.request().body() : null;
        requestBuilder.method(method, requestBody);
      }
      if (!maintainBody) {
        requestBuilder.removeHeader("Transfer-Encoding");
        requestBuilder.removeHeader("Content-Length");
        requestBuilder.removeHeader("Content-Type");
      }
    }

    // When redirecting across hosts, drop all authentication headers. This
    // is potentially annoying to the application layer since they have no
    // way to retain them.
    if (!sameConnection(userResponse, url)) {
      requestBuilder.removeHeader("Authorization");
    }

    return requestBuilder.url(url).build();

  case HTTP_CLIENT_TIMEOUT:      //408
    // 408's are rare in practice, but some servers like HAProxy use this response code. The
    // spec says that we may repeat the request without modifications. Modern browsers also
    // repeat the request (even non-idempotent ones.)
    if (!client.retryOnConnectionFailure()) {
      // The application layer has directed us not to retry the request.
      return null;
    }

    if (userResponse.request().body() instanceof UnrepeatableRequestBody) {
      return null;
    }
    //前一次响应也超时，就放弃重定向，返回null
    if (userResponse.priorResponse() != null
        && userResponse.priorResponse().code() == HTTP_CLIENT_TIMEOUT) {
      // We attempted to retry and got another timeout. Give up.
      return null;
    }

    if (retryAfter(userResponse, 0) > 0) {
      return null;
    }

    return userResponse.request();

  case HTTP_UNAVAILABLE:      //503
    //上一次响应状态也是503，返回null
    if (userResponse.priorResponse() != null
        && userResponse.priorResponse().code() == HTTP_UNAVAILABLE) {
      // We attempted to retry and got another timeout. Give up.
      return null;
    }
    //如果响应头Retry-After要求立即重试，就重新请求
    if (retryAfter(userResponse, Integer.MAX_VALUE) == 0) {
      // specifically received an instruction to retry without delay
      return userResponse.request();
    }

    return null;

  default:
    return null;
}

}

可以看到重定向的判断依据就是是状态码和请求方法，总结一下这里的判断逻辑

  1. 状态码是407,先判断代理服务器的类型，如果不是HTTP代理就抛异常。如果是,会调用我们构造 OkHttpClient 时传入的 Authenticator，做鉴权处理操作，返回处理后的结果
  2. 状态码是401，和407一样，做认证操作，然后返回结果
  3. 状态码是308或者307重定向，且方法不是 GET 也不是 HEAD，就返回 null
  4. 状态码 是 300、301、302、303，且构造 OkHttpClient 时设置允许重定向，就从当前响应头中取出 Location 即新地址，然后构造一个新的 Request 再请求一次
  5. 状态码 是 408 超时，且上一次没有超时，就再请求一次
  6. 状态码 是 503 服务不可用，且上一次不是 503，响应头也要求立即重试，就重新请求一次

所以followUpRequest()的返回值不为null，就表示需要重定向，为null，表示不需要.

BridgeInterceptor

BridgeInterceptor主要负责对Request和Response报文进行加工，将用户构造的请求转换为发送到服务器的请求、把服务器返回的响应转换为用户友好的响应，直接看它的拦截方法：

@Override
public Response intercept(Chain chain) throws IOException {
  Request userRequest = chain.request();
  Request.Builder requestBuilder = userRequest.newBuilder();

  RequestBody body = userRequest.body();
  //以下是根据请求体，补全请求头
  if (body != null) {
    MediaType contentType = body.contentType();
    if (contentType != null) {
      requestBuilder.header("Content-Type", contentType.toString());
    }

    long contentLength = body.contentLength();
    if (contentLength != -1) {
      requestBuilder.header("Content-Length", Long.toString(contentLength));
      requestBuilder.removeHeader("Transfer-Encoding");
    } else {
      requestBuilder.header("Transfer-Encoding", "chunked");
      requestBuilder.removeHeader("Content-Length");
    }
  }

  if (userRequest.header("Host") == null) {
    requestBuilder.header("Host", hostHeader(userRequest.url(), false));
  }

  if (userRequest.header("Connection") == null) {
    requestBuilder.header("Connection", "Keep-Alive");
  }

// If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
// the transfer stream.
  boolean transparentGzip = false;
  if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
    transparentGzip = true;
    requestBuilder.header("Accept-Encoding", "gzip");
  }
  //加载cookie,cookieJar是在创建okhttpClient配置的，不配置就用默认的
  List cookies = cookieJar.loadForRequest(userRequest.url());
  if (!cookies.isEmpty()) {
    //将本地的cookie拼接成字符串，并设置给Cookie头
    requestBuilder.header("Cookie", cookieHeader(cookies));
  }

  if (userRequest.header("User-Agent") == null) {
    requestBuilder.header("User-Agent", Version.userAgent());
  }

  Response networkResponse = chain.proceed(requestBuilder.build());
   //以下是对响应头的处理
  //解析并保存服务器返回的cookie，如果没有自定义cookie，不会解析
  HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

  Response.Builder responseBuilder = networkResponse.newBuilder()
      .request(userRequest);
  //如果响应内容是以gzip压缩过，就解压
  if (transparentGzip
      && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
      && HttpHeaders.hasBody(networkResponse)) {
    GzipSource responseBody = new GzipSource(networkResponse.body().source());
    //移除响应头Content-Encoding和Content-Length
    Headers strippedHeaders = networkResponse.headers().newBuilder()
        .removeAll("Content-Encoding")
        .removeAll("Content-Length")
        .build();
    //构建一个新的响应
    responseBuilder.headers(strippedHeaders);
    String contentType = networkResponse.header("Content-Type");
    responseBuilder.body(new RealResponseBody(contentType, -1L,   Okio.buffer(responseBody)));
  }
  //将新的响应返回
  return responseBuilder.build();
}

BridgeInterceptor做的主要工作是：

  1. 在发送请求前，根据body补全请求头，补全的请求头：Content-Type、Content-Length、Transfer-Encoding、Host、Connection、Cookie、Accept-Encoding、User-Agent
  2. 创建新的请求，执行下一个拦截器
  3. 如果响应内容以gzip压缩过，先解压，移除响应头Content-Encoding和Content-Length，再构建一个新的response返回
  4. 没有压缩过，直接返回response

CacheInterceptor

CacheInterceptor是根据HTTP协议的缓存机制来做缓存处理的，所以有必要先了解一下HTTP协议的缓存机制.

HTTP协议中缓存相关
缓存分类
 http请求有服务端和客户端之分。因此缓存也可以分为两个类型服务端侧和客户端侧。
服务端侧缓存
常见的服务端有Ngix和Apache。服务端缓存又分为代理服务器缓存和反向代理服务器缓存。常见  
的CDN就是服务器缓存。这个好理解，当浏览器重复访问一张图片地址时，CDN会判断这个请求 
有没有缓存，如果有的话就直接返回这个缓存的请求回复，而不再需要让请求到达真正的服务地 
址，这么做的目的是减轻服务端的运算压力。
客户端侧缓存
客户端主要指浏览器（如IE、Chrome等），当然包括我们的OKHTTPClient.客户端第一次请求网    
络时，服务器返回回复信息。如果数据正常的话，客户端缓存在本地的缓存目录。当客户端再次 
访问同一个地址时，客户端会检测本地有没有缓存，如果有缓存的话，数据是有没有过期，如果 
没有过期的话则直接运用缓存内容。
HTTP 缓存策略

在 HTTP 协议中，定义了一些与缓存相关的Header：

Cache-Control
Etag, If-None_match
LastModified, If-Modified-Since
Expired

Cache-Control

Cache-control 是HTTP协议中一个用来控制缓存的头部字段，既可以在请求头中使用，也可以在响应头中使用。它有不同的值，不同的值代表不同的缓存策略

Cache-control在请求头中使用的值有：

no-cache： 不使用缓存的数据，直接从服务器去取
only-if-cached： 表示直接获取缓存数据，若没有数据返回，则返回504（Gateway Timeout）
max-age： 表示可接受过期多久的缓存数据
max-stale：已过期的缓存在多少时间内仍可以继续使用（类似保质期），可以接受过去的对象，但是过期时间必须小于 max-stale 值
min-fresh：表示指定时间内的缓存数据仍有效，与缓存是否过期无关。如min-fresh: 60, 表示60s内的缓存数据都有效，60s之后的缓存数据将无效。

Cache-control在响应头中使用的值有：

public：可向任一方提供缓存数据
private：只向指定用户提供缓存数据
no-cache：缓存服务器不能对资源进行缓存
no-store：不缓存请求或响应的任何内容
max-age: 表示缓存的最大时间，在此时间范围内，访问该资源时，直接返回缓存数据。不需要对资源的有效性进行确认；

Etag/If-None-Match
Etag:服务器响应请求时，告诉客户端当前资源在服务器的唯一标识(生成规则由服务器决定)

If-None-Match: 如果浏览器在Cache-Control:max-age=60设置的时间超时后，发现消息头中还设 
置了Etag值。然后，浏览器会再次向服务器请求数据并添加If-None-Match消息头，它的值就是之 
前Etag值。再次请求服务器时，客户端通过此字段通知服务器客户端缓存数据的唯一标识。服务    
器收到请求后发现有头部If-None-Match，则与被请求的资源的唯一标识进行对比，不同则说明源  
被改过，则响应整个内容，返回状态码是200，相同则说明资源没有被改动过，则响应状态码 
304，告知客户端可以使用缓存
LastModified, If-Modified-Since
Last-Modified：标示这个响应资源的最后修改时间。web服务器在响应请求时，告诉浏览器资源的 
最后修改时间。
If-Modified-Since：当资源过期时（使用Cache-Control标识的max-age），发现资源具有Last- 
Modified声明，则再次向web服务器请求时带上头 If-Modified-Since，表示请求时间。web服务器 
收到请求后发现有头If-Modified-Since 则与被请求资源的最后修改时间进行比对。若最后修改时间 
较新，说明资源又被改动过，则响应整片资源内容（写在响应消息包体内），HTTP 200；若最后 
修改时间较旧，说明资源无需修改，则响应HTTP 304 (无需包体，节省浏览)，告知浏览器继续使 
用所保存的cache。
Expired
expires的效果等同于Cache-Control，不过它是Http 1.0的内容，它的作用是告诉浏览器缓存的过      
期时间，在此时间内浏览器不需要直接访问服务器地址直接用缓存内容就好了。 
expires最大的问题在于如果服务器时间和本地浏览器相差过大的问题。那样误差就很大。所以基 
本上用Cache-Control:max-age=多少秒的形式代替。

用一张图来表示HTTP的缓存机制就是：


Okhttp源码学习三（重试和重定向，桥接，缓存拦截器的内部原理）_第1张图片
HTTP缓存机制.png

概括起来就是：

  1. 首先根据 CacheControl 来判断是否使用缓存，如果使用缓存，就去判断当前缓存是否过期
  2. 如果缓存信息里有 Etag，就向服务器发送带 If-None-Match 的请求，服务器进行决策
  3. 如果没有 Etag 就看有没有 Last-Modified，有的话向服务器发送带 If-Modified-Since 的请求， 由服务器进行决策
  4. 服务器验证缓存有效性后，如果缓存仍可以使用，就返回 304；如果 code 不是 304，客户端就需要从响应里拿数据，同时更新缓存。

OkHttp的缓存拦截器实现

public final class CacheInterceptor implements Interceptor {
final InternalCache cache;

public CacheInterceptor(InternalCache cache) {
  this.cache = cache;
}

@Override
public Response intercept(Chain chain) throws IOException {
  //如果有缓存，取出缓存，cache是在OkHttpClient中设置的，如果不设置就为null
  Response cacheCandidate = cache != null
      ? cache.get(chain.request())
      : null;

  long now = System.currentTimeMillis();
  //获取缓存策略对象
  CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(),   cacheCandidate).get();
  //从缓存策略中拿到networkRequest ，networkRequest 不为null，表示要请求网络
  Request networkRequest = strategy.networkRequest;
 //缓存策略中拿到cacheResponse ，cacheResponse 不为null，表示缓存可用
  Response cacheResponse = strategy.cacheResponse;
  ....
}

首先是判断cache是否为null，如果不为null，就调用cache.get(chain.request())取出缓存响应,看一下这个cache:

public interface InternalCache {
  Response get(Request request) throws IOException;

  CacheRequest put(Response response) throws IOException;

  void remove(Request request) throws IOException;

  void update(Response cached, Response network);

  void trackConditionalCacheHit();

  void trackResponse(CacheStrategy cacheStrategy);
}

cache是InternalCache类型的接口，它唯一的实现在Cache类：

public final class Cache implements Closeable, Flushable {
  private static final int VERSION = 201105;
  private static final int ENTRY_METADATA = 0;
  private static final int ENTRY_BODY = 1;
  private static final int ENTRY_COUNT = 2;

//创建一个InternalCache 成员
 final InternalCache internalCache = new InternalCache() {
  @Override public Response get(Request request) throws IOException {
      //InternalCache的get方法其实调用的是Cache的get方法
      return Cache.this.get(request);
  }

  .......
 };

final DiskLruCache cache;

...........

public Cache(File directory, long maxSize) {
  this(directory, maxSize, FileSystem.SYSTEM);
}

Cache(File directory, long maxSize, FileSystem fileSystem) {
  this.cache = DiskLruCache.create(fileSystem, directory, VERSION, ENTRY_COUNT, maxSize);
}

public static String key(HttpUrl url) {  //缓存的key值就是对url进行utf-8转码，并取md5
 return ByteString.encodeUtf8(url.toString()).md5().hex();
}

@Nullable Response get(Request request) {
  String key = key(request.url());
  DiskLruCache.Snapshot snapshot;
  Entry entry;
  try {
    snapshot = cache.get(key);
    if (snapshot == null) {
      return null;
    }
  } catch (IOException e) {
    // Give up because the cache cannot be read.
    return null;
  }

  try {
    entry = new Entry(snapshot.getSource(ENTRY_METADATA));
  } catch (IOException e) {
    Util.closeQuietly(snapshot);
    return null;
  }

  Response response = entry.response(snapshot);

  if (!entry.matches(request, response)) {
    Util.closeQuietly(response.body());
    return null;
  }

  return response;
}
 ..........
}

从Cache类可以看到OkHttp的缓存是用DiskLruCache 来存储的，存储的key就是请求的url的md5值.

继续回到CacheInterceptor的拦截方法，在拦截方法中：

//构建一个缓存策略对象
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(),     
cacheCandidate).get();
  //从缓存策略对象中拿到networkRequest 
Request networkRequest = strategy.networkRequest;
 //缓存策略对象中拿到cacheResponse 
Response cacheResponse = strategy.cacheResponse;

调用了CacheStrategy的Factory()和get()：

public final class CacheStrategy {

  public final @Nullable Request networkRequest;
  public final @Nullable Response cacheResponse;

  CacheStrategy(Request networkRequest, Response cacheResponse) {
    this.networkRequest = networkRequest;
    this.cacheResponse = cacheResponse;
  }

  .......
  public static class Factory {
    public Factory(long nowMillis, Request request, Response cacheResponse) {
        this.nowMillis = nowMillis;
        this.request = request;
        this.cacheResponse = cacheResponse;

      if (cacheResponse != null) {
        this.sentRequestMillis = cacheResponse.sentRequestAtMillis();
        this.receivedResponseMillis = cacheResponse.receivedResponseAtMillis();
        Headers headers = cacheResponse.headers();
        //获取缓存响应的header值
        for (int i = 0, size = headers.size(); i < size; i++) {
        String fieldName = headers.name(i);
        String value = headers.value(i);
        if ("Date".equalsIgnoreCase(fieldName)) {
           servedDate = HttpDate.parse(value);
           servedDateString = value;
        } else if ("Expires".equalsIgnoreCase(fieldName)) {
          expires = HttpDate.parse(value);
        } else if ("Last-Modified".equalsIgnoreCase(fieldName)) {
          lastModified = HttpDate.parse(value);
          lastModifiedString = value;
        } else if ("ETag".equalsIgnoreCase(fieldName)) {
          etag = value;
        } else if ("Age".equalsIgnoreCase(fieldName)) {
          ageSeconds = HttpHeaders.parseSeconds(value, -1);
        }
      }
    }
  }

  public CacheStrategy get() {
    //获取当前的缓存策略
    CacheStrategy candidate = getCandidate();
    //如果是网络请求不为null并且请求里面的cacheControl是只用缓存
    if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {
      // We're forbidden from using the network and the cache is insufficient.
      return new CacheStrategy(null, null);
    }

    return candidate;
  }

  /** Returns a strategy to use assuming the request can use the network. */
  private CacheStrategy getCandidate() {
    // No cached response.
    if (cacheResponse == null) {   //如果没有缓存响应，返回一个没有响应的策略
        return new CacheStrategy(request, null);
    }

  // Drop the cached response if it's missing a required handshake.
    if (request.isHttps() && cacheResponse.handshake() == null) {  //如果是https请求，并且握手丢失
        return new CacheStrategy(request, null);
    }

    // If this response shouldn't have been stored, it should never be used
    // as a response source. This check should be redundant as long as the
    // persistence store is well-behaved and the rules are constant.
    if (!isCacheable(cacheResponse, request)) {  //如果响应不能缓存（根据响应状态码，请求或响应头的Cache-control字段判断）
      return new CacheStrategy(request, null);
    }

    CacheControl requestCaching = request.cacheControl();
    //请求cacheControl设置为不缓存，或者请求头里面有If-Modified-Since或If-None-Match头部字段
    if (requestCaching.noCache() || hasConditions(request)) {  
        return new CacheStrategy(request, null);
    }

    CacheControl responseCaching = cacheResponse.cacheControl();
    //如果cache-Control的值是immutable
    if (responseCaching.immutable()) {
      return new CacheStrategy(null, cacheResponse);
    }
     //获取缓存响应的年龄
    long ageMillis = cacheResponseAge();
    //获取缓存响应的过期时间
    long freshMillis = computeFreshnessLifetime();
    //如果请求cache-control里面有过期时间max-age，则比较请求和响应的过期时间，取最小值
    if (requestCaching.maxAgeSeconds() != -1) {  
      freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));
    }

    long minFreshMillis = 0;
    if (requestCaching.minFreshSeconds() != -1) {
      minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());
    }

    long maxStaleMillis = 0;
    if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {
      maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());
    }

    if (!responseCaching.noCache() && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
       Response.Builder builder = cacheResponse.newBuilder();
    if (ageMillis + minFreshMillis >= freshMillis) {
      builder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"");
    }
    long oneDayMillis = 24 * 60 * 60 * 1000L;
    if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
      builder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
    }
      return new CacheStrategy(null, builder.build());
    }

  // Find a condition to add to the request. If the condition is satisfied, the response body
  // will not be transmitted.
    String conditionName;
    String conditionValue;
    if (etag != null) {
      conditionName = "If-None-Match";
      conditionValue = etag;
    } else if (lastModified != null) {
      conditionName = "If-Modified-Since";
      conditionValue = lastModifiedString;
    } else if (servedDate != null) {
      conditionName = "If-Modified-Since";
      conditionValue = servedDateString;
    } else {
      return new CacheStrategy(request, null); // No condition! Make a regular request.
    }

    Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
    Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);

    Request conditionalRequest = request.newBuilder()
        .headers(conditionalRequestHeaders.build())
        .build();
    return new CacheStrategy(conditionalRequest, cacheResponse);
  }
  .......
}

可以看到CacheStrategy内部的networkRequest和cacheResponse是通过HTTP协议缓存机制，也就是根据用户对当前请求设置的 CacheControl 的值，缓存响应的时间、ETag 、 LastModified 或者 ServedDate 等 Header的值 进行不断的判断得出来的.拿到两个值之后，缓存拦截器CacheInterceptor 就根据这两个值的情况决定是请求网络还是直接返回缓存数据

@Override
 public Response intercept(Chain chain) throws IOException {
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();

    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(),cacheCandidate).get();
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;
    //缓存是否不为null(okhttpClient.builder可以设置，不设置默认就为null)
    if (cache != null) {
      cache.trackResponse(strategy);
    }
   //有缓存，但是缓存不可用，
    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
    }

    //networkRequest和cacheResponse都为null，表示禁止使用网络请求，但是缓存又不可用，返回504错误
    // If we're forbidden from using the network and the cache is insufficient, fail.
    if (networkRequest == null && cacheResponse == null) {
      return new Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(Util.EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();
    }

    //networkRequest为null，cacheResponse不为null，表示不使用网络请求，并且缓存有效，直接返回缓存
    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }

    Response networkResponse = null;
    try {
      //networkRequest 不为null,就走到这里（networkRequest 不为null，表示需要请求网络）
      networkResponse = chain.proceed(networkRequest);
     } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
     }

    // If we have a cache response too, then we're doing a conditional get.
    //networkRequest不为null，cacheResponse也不为null
    if (cacheResponse != null) {
      //如果请求网络响应码为304(缓存还可以用)
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();

        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        cache.trackConditionalCacheHit();
        //更新缓存
        cache.update(cacheResponse, response);
        return response;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }
    //networkRequest不为null，cacheResponse为null，
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    //有设置缓存目录
    if (cache != null) {
       //有响应体，并且能够缓存
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response,     networkRequest)) {
        // Offer this request to the cache.
        //将从网络请求到的响应存到本地缓存目录
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }
      //判断缓存是否可用（只有 GET 请求的响应能被缓存，否则就移除缓存）
      if (HttpMethod.invalidatesCache(networkRequest.method())) {
      try {
        cache.remove(networkRequest);
      } catch (IOException ignored) {
        // The cache cannot be written.
      }
    }
  }

  return response;
}

CacheInterceptor的工作原理总结：

  1. 查看本地是否有缓存，本地缓存是通过DiskLruCache 来存储的，存储的目录是在OkHttpClient的builder.cache(Cache)中设置的，存储的key为请求URL的MD5值
  2. 根据HTTP的缓存机制，也就是根据之前缓存的结果与当前将要发送Request的header值，得出是进行请求还是使用缓存，并用networkRequest和cacheResponse标识，同时根据这个两个值创建缓存策略对象CacheStrategy
  3. 根据缓存策略对象CacheStrategy的networkRequest和cacheResponse标识，判断是请求还是使用缓存响应
  4. 如果当前请求是请求网络数据，并且没有缓存，在请求到数据后，存到本地缓存目录

所以如果要使用OkHttp自带的缓存，就需要后端人员配合，或者是自己使用网络拦截器在请求到数据后，自己添加跟缓存相关的响应Header。

你可能感兴趣的:(Okhttp源码学习三（重试和重定向，桥接，缓存拦截器的内部原理）)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他