Java HttpHeaders类代码示例

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
/**
 * Creates an OkHttp Response.Body containing the supplied information.
 */
private static ResponseBody createOkBody(final Headers okHeaders,
    final CacheResponse cacheResponse) throws IOException {
  final BufferedSource body = Okio.buffer(Okio.source(cacheResponse.getBody()));
  return new ResponseBody() {
    @Override
    public MediaType contentType() {
      String contentTypeHeader = okHeaders.get("Content-Type");
      return contentTypeHeader == null ? null : MediaType.parse(contentTypeHeader);
    }

    @Override
    public long contentLength() {
      return HttpHeaders.contentLength(okHeaders);
    }

    @Override public BufferedSource source() {
      return body;
    }
  };
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
private Source getTransferStream(Response response) throws IOException {
  if (!HttpHeaders.hasBody(response)) {
    return newFixedLengthSource(0);
  }

  if ("chunked".equalsIgnoreCase(response.header("Transfer-Encoding"))) {
    return newChunkedSource(response.request().url());
  }

  long contentLength = HttpHeaders.contentLength(response);
  if (contentLength != -1) {
    return newFixedLengthSource(contentLength);
  }

  // Wrap the input stream from the connection (rather than just returning
  // "socketIn" directly here), so that we can control its use after the
  // reference escapes.
  return newUnknownLengthSource();
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
private void readChunkSize() throws IOException {
  // Read the suffix of the previous chunk.
  if (bytesRemainingInChunk != NO_CHUNK_YET) {
    source.readUtf8LineStrict();
  }
  try {
    bytesRemainingInChunk = source.readHexadecimalUnsignedLong();
    String extensions = source.readUtf8LineStrict().trim();
    if (bytesRemainingInChunk < 0 || (!extensions.isEmpty() && !extensions.startsWith(";"))) {
      throw new ProtocolException("expected chunk size and optional extensions but was \""
          + bytesRemainingInChunk + extensions + "\"");
    }
  } catch (NumberFormatException e) {
    throw new ProtocolException(e.getMessage());
  }
  if (bytesRemainingInChunk == 0L) {
    hasMoreChunks = false;
    HttpHeaders.receiveHeaders(client.cookieJar(), url, readHeaders());
    endOfInput(true);
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
private void readChunkSize() throws IOException {
  // Read the suffix of the previous chunk.
  if (bytesRemainingInChunk != NO_CHUNK_YET) {
    source.readUtf8LineStrict();
  }
  try {
    bytesRemainingInChunk = source.readHexadecimalUnsignedLong();
    String extensions = source.readUtf8LineStrict().trim();
    if (bytesRemainingInChunk < 0 || (!extensions.isEmpty() && !extensions.startsWith(";"))) {
      throw new ProtocolException("expected chunk size and optional extensions but was \""
          + bytesRemainingInChunk + extensions + "\"");
    }
  } catch (NumberFormatException e) {
    throw new ProtocolException(e.getMessage());
  }
  if (bytesRemainingInChunk == 0L) {
    hasMoreChunks = false;
    HttpHeaders.receiveHeaders(client.cookieJar(), url, readHeaders());
    endOfInput(true, null);
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
protected Response execute(Request request) throws IOException {
    if (Http.sCache != null) {
        if (HttpMethod.invalidatesCache(request.method())) {
            try {
                Http.sCache.remove(getUrl());
            } catch (IOException ignore) {
            }
        }
        if (!"GET".equals(request.method())) {
            setShouldCache(false);
        }
    }
    OkHttpClient client = getClient();
    Call call = client.newCall(request);
    long start = System.currentTimeMillis();
    Response response = call.execute();
    if (LOG.isLoggable(Log.INFO))
        LOG.i("Took " + (System.currentTimeMillis() - start) + "ms to execute request (" + getLogKey() + ")");
    if (Http.sCache != null && HttpHeaders.hasVaryAll(response)) {
        setShouldCache(false);
    }
    return response;
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
static void parseResponse(Response response) throws IOException {
  if (!HttpHeaders.hasBody(response)) {
    if (response.isSuccessful()) {
      return;
    } else {
      throw new IllegalStateException("response failed: " + response);
    }
  }
  try (ResponseBody responseBody = response.body()) {
    BufferedSource content = responseBody.source();
    if ("gzip".equalsIgnoreCase(response.header("Content-Encoding"))) {
      content = Okio.buffer(new GzipSource(responseBody.source()));
    }
    if (!response.isSuccessful()) {
      throw new IllegalStateException(
          "response for " + response.request().tag() + " failed: " + content.readUtf8());
    }
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
private static Headers varyHeaders(URLConnection urlConnection, Headers responseHeaders) {
  if (HttpHeaders.hasVaryAll(responseHeaders)) {
    // "*" means that this will be treated as uncacheable anyway.
    return null;
  }
  Set<String> varyFields = HttpHeaders.varyFields(responseHeaders);
  if (varyFields.isEmpty()) {
    return new Headers.Builder().build();
  }

  // This probably indicates another HTTP stack is trying to use the shared ResponseCache.
  // We cannot guarantee this case will work properly because we cannot reliably extract *all*
  // the request header values, and we can't get multiple Vary request header values.
  // We also can't be sure about the Accept-Encoding behavior of other stacks.
  if (!(urlConnection instanceof CacheHttpURLConnection
      || urlConnection instanceof CacheHttpsURLConnection)) {
    return null;
  }

  // This is the case we expect: The URLConnection is from a call to
  // JavaApiConverter.createJavaUrlConnection() and we have access to the user's request headers.
  Map<String, List<String>> requestProperties = urlConnection.getRequestProperties();
  Headers.Builder result = new Headers.Builder();
  for (String fieldName : varyFields) {
    List<String> fieldValues = requestProperties.get(fieldName);
    if (fieldValues == null) {
      if (fieldName.equals("Accept-Encoding")) {
        // Accept-Encoding is special. If OkHttp sees Accept-Encoding is unset it will add
        // "gzip". We don't have access to the request that was actually made so we must do the
        // same.
        result.add("Accept-Encoding", "gzip");
      }
    } else {
      for (String fieldValue : fieldValues) {
        Internal.instance.addLenient(result, fieldName, fieldValue);
      }
    }
  }
  return result.build();
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
CacheRequest put(Response response) {
  String requestMethod = response.request().method();

  if (HttpMethod.invalidatesCache(response.request().method())) {
    try {
      remove(response.request());
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
    return null;
  }
  if (!requestMethod.equals("GET")) {
    // Don't cache non-GET responses. We're technically allowed to cache
    // HEAD requests and some POST requests, but the complexity of doing
    // so is high and the benefit is low.
    return null;
  }

  if (HttpHeaders.hasVaryAll(response)) {
    return null;
  }

  Entry entry = new Entry(response);
  DiskLruCache.Editor editor = null;
  try {
    editor = cache.edit(key(response.request().url()));
    if (editor == null) {
      return null;
    }
    entry.writeTo(editor);
    return new CacheRequestImpl(editor);
  } catch (IOException e) {
    abortQuietly(editor);
    return null;
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
public Entry(Response response) {
  this.url = response.request().url().toString();
  this.varyHeaders = HttpHeaders.varyHeaders(response);
  this.requestMethod = response.request().method();
  this.protocol = response.protocol();
  this.code = response.code();
  this.message = response.message();
  this.responseHeaders = response.headers();
  this.handshake = response.handshake();
  this.sentRequestMillis = response.sentRequestAtMillis();
  this.receivedResponseMillis = response.receivedResponseAtMillis();
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
/**
 * Returns the authorization challenges appropriate for this response's code. If the response code
 * is 401 unauthorized, this returns the "WWW-Authenticate" challenges. If the response code is
 * 407 proxy unauthorized, this returns the "Proxy-Authenticate" challenges. Otherwise this
 * returns an empty list of challenges.
 */
public List<Challenge> challenges() {
  String responseField;
  if (code == HTTP_UNAUTHORIZED) {
    responseField = "WWW-Authenticate";
  } else if (code == HTTP_PROXY_AUTH) {
    responseField = "Proxy-Authenticate";
  } else {
    return Collections.emptyList();
  }
  return HttpHeaders.parseChallenges(headers(), responseField);
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
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();
    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);
      }
    }
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
/**
 * Returns an input stream from the server in the case of error such as the requested file (txt,
 * htm, html) is not found on the remote server.
 */
@Override public InputStream getErrorStream() {
  try {
    Response response = getResponse(true);
    if (HttpHeaders.hasBody(response) && response.code() >= HTTP_BAD_REQUEST) {
      return response.body().byteStream();
    }
    return null;
  } catch (IOException e) {
    return null;
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
@Nullable CacheRequest put(Response response) {
  String requestMethod = response.request().method();

  if (HttpMethod.invalidatesCache(response.request().method())) {
    try {
      remove(response.request());
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
    return null;
  }
  if (!requestMethod.equals("GET")) {
    // Don't cache non-GET responses. We're technically allowed to cache
    // HEAD requests and some POST requests, but the complexity of doing
    // so is high and the benefit is low.
    return null;
  }

  if (HttpHeaders.hasVaryAll(response)) {
    return null;
  }

  Entry entry = new Entry(response);
  DiskLruCache.Editor editor = null;
  try {
    editor = cache.edit(key(response.request().url()));
    if (editor == null) {
      return null;
    }
    entry.writeTo(editor);
    return new CacheRequestImpl(editor);
  } catch (IOException e) {
    abortQuietly(editor);
    return null;
  }
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
Entry(Response response) {
  this.url = response.request().url().toString();
  this.varyHeaders = HttpHeaders.varyHeaders(response);
  this.requestMethod = response.request().method();
  this.protocol = response.protocol();
  this.code = response.code();
  this.message = response.message();
  this.responseHeaders = response.headers();
  this.handshake = response.handshake();
  this.sentRequestMillis = response.sentRequestAtMillis();
  this.receivedResponseMillis = response.receivedResponseAtMillis();
}
 

import okhttp3.internal.http.HttpHeaders; //导入依赖的package包/类
@Override public ResponseBody openResponseBody(Response response) throws IOException {
  streamAllocation.eventListener.responseBodyStart(streamAllocation.call);
  String contentType = response.header("Content-Type");
  long contentLength = HttpHeaders.contentLength(response);
  Source source = new StreamFinishingSource(stream.getSource());
  return new RealResponseBody(contentType, contentLength, Okio.buffer(source));
}