HttpURLConnection源码分析

• 本文概述

  从源码角度理解HttpURLConnection是怎么一步步封装底层socket调用的。

• HttpURLConnection使用回顾

  我们先来回顾一下它的用法：

  new Thread(() -> {
      HttpURLConnection connection = null;
      BufferedReader reader = null;
      try{
          URL url = new URL("https://www.baidu.com");//新建URL
          connection = (HttpURLConnection)url.openConnection();//发起网络请求
          connection.setRequestMethod("GET");//请求方式
          connection.setConnectTimeout(8000);//连接最大时间
          connection.setReadTimeout(8000);//读取最大时间
          InputStream in = connection.getInputStream();
          reader = new BufferedReader(new InputStreamReader(in));//写入reader
          StringBuilder response = new StringBuilder();
          String line;
          while((line = reader.readLine()) != null){
              response.append(line);
          }
          //更新ui
          showResponse(response.toString());
      }catch (Exception e){
          e.printStackTrace();
      }finally {
          if(reader != null){
              try{
                  reader.close();
              }catch (IOException e){
                  e.printStackTrace();
              }
          }
          if(connection != null){
              connection.disconnect();
          }
      }
  }).start();
  

  接下来从源码角度研究一下它的原理。

• 源码分析

  首先构造一个URL对象，然后调用它的openConnection()，进去发现调用的是handler.openConnection(URL url)，handler是怎么创建的呢？看一下URL对象的构造方法就会发现一些线索，构造方法最终会走到this(context, spec, null)：

  public URL(URL context, String spec, URLStreamHandler handler)
      throws MalformedURLException
  {
      String original = spec;
      int i, limit, c;
      int start = 0;
      String newProtocol = null;
      boolean aRef=false;
      boolean isRelative = false;
  
      // Check for permission to specify a handler
      if (handler != null) {
          SecurityManager sm = System.getSecurityManager();
          if (sm != null) {
              checkSpecifyHandler(sm);
          }
      }
  
      try {
          limit = spec.length();
          while ((limit > 0) && (spec.charAt(limit - 1) <= ' ')) {
              limit--;        //eliminate trailing whitespace
          }
          while ((start < limit) && (spec.charAt(start) <= ' ')) {
              start++;        // eliminate leading whitespace
          }
  
          if (spec.regionMatches(true, start, "url:", 0, 4)) {
              start += 4;
          }
          if (start < spec.length() && spec.charAt(start) == '#') {
              /* we're assuming this is a ref relative to the context URL.
               * This means protocols cannot start w/ '#', but we must parse
               * ref URL's like: "hello:there" w/ a ':' in them.
               */
              aRef=true;
          }
          for (i = start ; !aRef && (i < limit) &&
                   ((c = spec.charAt(i)) != '/') ; i++) {
              if (c == ':') {
  
                  String s = spec.substring(start, i).toLowerCase();
                  if (isValidProtocol(s)) {
                      newProtocol = s;
                      start = i + 1;
                  }
                  break;
              }
          }
  
          // Only use our context if the protocols match.
          protocol = newProtocol;
          if ((context != null) && ((newProtocol == null) ||
                          newProtocol.equalsIgnoreCase(context.protocol))) {
              // inherit the protocol handler from the context
              // if not specified to the constructor
              if (handler == null) {
                  handler = context.handler;
              }
  
              // If the context is a hierarchical URL scheme and the spec
              // contains a matching scheme then maintain backwards
              // compatibility and treat it as if the spec didn't contain
              // the scheme; see 5.2.3 of RFC2396
              if (context.path != null && context.path.startsWith("/"))
                  newProtocol = null;
  
              if (newProtocol == null) {
                  protocol = context.protocol;
                  authority = context.authority;
                  userInfo = context.userInfo;
                  host = context.host;
                  port = context.port;
                  file = context.file;
                  path = context.path;
                  isRelative = true;
              }
          }
  
          if (protocol == null) {
              throw new MalformedURLException("no protocol: "+original);
          }
  
          // Get the protocol handler if not specified or the protocol
          // of the context could not be used
          if (handler == null &&
              (handler = getURLStreamHandler(protocol)) == null) {
              throw new MalformedURLException("unknown protocol: "+protocol);
          }
  
          this.handler = handler;
  
          i = spec.indexOf('#', start);
          if (i >= 0) {
              ref = spec.substring(i + 1, limit);
              limit = i;
          }
  
          /*
           * Handle special case inheritance of query and fragment
           * implied by RFC2396 section 5.2.2.
           */
          if (isRelative && start == limit) {
              query = context.query;
              if (ref == null) {
                  ref = context.ref;
              }
          }
  
          handler.parseURL(this, spec, start, limit);
  
      } catch(MalformedURLException e) {
          throw e;
      } catch(Exception e) {
          MalformedURLException exception = new MalformedURLException(e.getMessage());
          exception.initCause(e);
          throw exception;
      }
  }
  

  这里面就是把url解析成对应的字段，然后把构造的handler和URL联系在一起，至于handler的创建，首先这里因为context（URL）是null，所以handler = context.handler不会执行，所以getURLStreamHandler(protocol)成为了关键：

  static URLStreamHandler getURLStreamHandler(String protocol) {
  		
    	//首先从一个叫handlers的Hashtable中以protocol为key去取
      URLStreamHandler handler = handlers.get(protocol);
      if (handler == null) {
  
          boolean checkedWithFactory = false;
  
        	//如果没取到则尝试用factory去构造一个，这里的factory没有赋值所以是null
          // Use the factory (if any)
          if (factory != null) {
              handler = factory.createURLStreamHandler(protocol);
              checkedWithFactory = true;
          }
  
          //此时handler还是没有创建
          // Try java protocol handler
          if (handler == null) {
              // Android-changed: Android doesn't need AccessController.
              // Remove unnecessary use of reflection for sun classes
              /*
              packagePrefixList
                  = java.security.AccessController.doPrivileged(
                  new sun.security.action.GetPropertyAction(
                      protocolPathProp,""));
              if (packagePrefixList != "") {
                  packagePrefixList += "|";
              }
  
              // REMIND: decide whether to allow the "null" class prefix
              // or not.
              packagePrefixList += "sun.net.www.protocol";
               */
            	//这里会以propotolPathProp（java.protocol.handler.pkgs）为key去取一个系统属性，看样子是一个包名前缀集合字符串的东西
              final String packagePrefixList = System.getProperty(protocolPathProp,"");
  
            	//构造一个分词器，以“|”分割
              StringTokenizer packagePrefixIter =
                  new StringTokenizer(packagePrefixList, "|");
              //如果找到这么一个类可以创建handler则跳出循环
              while (handler == null &&
                     packagePrefixIter.hasMoreTokens()) {
  
                  String packagePrefix =
                    packagePrefixIter.nextToken().trim();
                  try {
                      String clsName = packagePrefix + "." + protocol +
                        ".Handler";
                      Class<?> cls = null;
                      try {
                          ClassLoader cl = ClassLoader.getSystemClassLoader();
                          // BEGIN Android-changed: Fall back to thread's contextClassLoader.
                          // http://b/25897689
                          cls = Class.forName(clsName, true, cl);
                      } catch (ClassNotFoundException e) {
                          ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
                          if (contextLoader != null) {
                              cls = Class.forName(clsName, true, contextLoader);
                          }
                          // END Android-changed: Fall back to thread's contextClassLoader.
                      }
                      if (cls != null) {
                          handler  =
                            (URLStreamHandler)cls.newInstance();
                      }
                  } catch (ReflectiveOperationException ignored) {
                  }
              }
          }
  
          // BEGIN Android-added: Custom built-in URLStreamHandlers for http, https.
          // Fallback to built-in stream handler.
        	//如果此时handler还没创建，则调用createBuiltinHandler方法
          if (handler == null) {
              try {
                  handler = createBuiltinHandler(protocol);
              } catch (Exception e) {
                  throw new AssertionError(e);
              }
          }
          // END Android-added: Custom built-in URLStreamHandlers for http, https.
  				//注意最后再走一下前面的逻辑，如果在试图创建的过程中其他线程创建了handler或者设置了factory则优先使用这两种方式的handler
          synchronized (streamHandlerLock) {
  
              URLStreamHandler handler2 = null;
  
              // Check again with hashtable just in case another
              // thread created a handler since we last checked
              handler2 = handlers.get(protocol);
  
              if (handler2 != null) {
                  return handler2;
              }
  
              // Check with factory if another thread set a
              // factory since our last check
              if (!checkedWithFactory && factory != null) {
                  handler2 = factory.createURLStreamHandler(protocol);
              }
  
              if (handler2 != null) {
                  // The handler from the factory must be given more
                  // importance. Discard the default handler that
                  // this thread created.
                  handler = handler2;
              }
  
              // Insert this handler into the hashtable
              if (handler != null) {
                  handlers.put(protocol, handler);
              }
  
          }
      }
  
      return handler;
  
  }
  

  看一下createBuiltinHandler方法：

  private static URLStreamHandler createBuiltinHandler(String protocol)
          throws ClassNotFoundException, InstantiationException, IllegalAccessException {
      URLStreamHandler handler = null;
      if (protocol.equals("file")) {
          handler = new sun.net.www.protocol.file.Handler();
      } else if (protocol.equals("ftp")) {
          handler = new sun.net.www.protocol.ftp.Handler();
      } else if (protocol.equals("jar")) {
          handler = new sun.net.www.protocol.jar.Handler();
      } else if (protocol.equals("http")) {
          handler = (URLStreamHandler)Class.
                  forName("com.android.okhttp.HttpHandler").newInstance();
      } else if (protocol.equals("https")) {
          handler = (URLStreamHandler)Class.
                  forName("com.android.okhttp.HttpsHandler").newInstance();
      }
      return handler;
  }
  

  因为最终会返回一个URLStreamHandler类型的子类对象当作handler，所以以com.android.okhttp.HttpHandler为例来看看handler.openConnection()方法：

  public final class HttpHandler extends URLStreamHandler {
      @Override 
      protected URLConnection openConnection(URL url) throws IOException {
          // 调用了OKHttpClient()的方法
          return new OkHttpClient().open(url);
      }
  
  
      @Override
      protected URLConnection openConnection(URL url, Proxy proxy) throws IOException {
          if (url == null || proxy == null) {
              throw new IllegalArgumentException("url == null || proxy == null");
          }
          return new OkHttpClient().setProxy(proxy).open(url);
      }
  
  
      @Override 
      protected int getDefaultPort() {
          return 80;
      }
  }
  

  可见也是调用了调用了OKHttpClient()的open方法：

  public HttpURLConnection open(URL url) {
    return open(url, proxy);
  }
  
  HttpURLConnection open(URL url, Proxy proxy) {
    String protocol = url.getProtocol();
    OkHttpClient copy = copyWithDefaults();
    copy.proxy = proxy;
  
    if (protocol.equals("http")) return new HttpURLConnectionImpl(url, copy);
    if (protocol.equals("https")) return new HttpsURLConnectionImpl(url, copy);
    throw new IllegalArgumentException("Unexpected protocol: " + protocol);
  }
  

  以Http为例则返回了HttpURLConnectionImpl对象。

  所以openConnection()并没有开始去请求网络，它做的工作只是封装好请求。

  回到调用流程，接着是调用connect：

  @Override public final void connect() throws IOException {
    initHttpEngine();
    boolean success;
    do {
      success = execute(false);
    } while (!success);
  }
  

  这里的do-while循环相当于失败重连，因为这只是连接，所以execute方法的参数是false，表示不读取response。

  接下来都是给HttpURLConnectionImpl对象继续设置参数，然后调用它的getInputStream()方法，此时才是通过网络获取真正的数据：

  @Override public final InputStream getInputStream() throws IOException {
    if (!doInput) {
      throw new ProtocolException("This protocol does not support input");
    }
  
    HttpEngine response = getResponse();
  
    // if the requested file does not exist, throw an exception formerly the
    // Error page from the server was returned if the requested file was
    // text/html this has changed to return FileNotFoundException for all
    // file types
    if (getResponseCode() >= HTTP_BAD_REQUEST) {
      throw new FileNotFoundException(url.toString());
    }
  
    InputStream result = response.getResponseBodyBytes();
    if (result == null) {
      throw new ProtocolException("No response body exists; responseCode=" + getResponseCode());
    }
    return result;
  }
  

  可以看出getResponse()方法之后的代码都是读取请求返回值了，所以这个getResonse方法就是调用请求的地方：

  private HttpEngine getResponse() throws IOException {
    initHttpEngine();
  
    if (httpEngine.hasResponse()) {
      return httpEngine;
    }
  
    while (true) {
      if (!execute(true)) {
        continue;
      }
  
      Retry retry = processResponseHeaders();
      if (retry == Retry.NONE) {
        httpEngine.releaseConnection();
        return httpEngine;
      }
  
      // The first request was insufficient. Prepare for another...
      String retryMethod = method;
      Sink requestBody = httpEngine.getRequestBody();
  
      // Although RFC 2616 10.3.2 specifies that a HTTP_MOVED_PERM
      // redirect should keep the same method, Chrome, Firefox and the
      // RI all issue GETs when following any redirect.
      int responseCode = httpEngine.getResponse().code();
      if (responseCode == HTTP_MULT_CHOICE
          || responseCode == HTTP_MOVED_PERM
          || responseCode == HTTP_MOVED_TEMP
          || responseCode == HTTP_SEE_OTHER) {
        retryMethod = "GET";
        requestHeaders.removeAll("Content-Length");
        requestBody = null;
      }
  
      if (requestBody != null && !(requestBody instanceof RetryableSink)) {
        throw new HttpRetryException("Cannot retry streamed HTTP body", responseCode);
      }
  
      if (retry == Retry.DIFFERENT_CONNECTION) {
        httpEngine.releaseConnection();
      }
  
      Connection connection = httpEngine.close();
      httpEngine = newHttpEngine(retryMethod, connection, (RetryableSink) requestBody);
    }
  }
  

  先看一下initHttpEngine:

  private void initHttpEngine() throws IOException {
    if (httpEngineFailure != null) {
      throw httpEngineFailure;
    } else if (httpEngine != null) {
      return;
    }
  
    connected = true;
    try {
      if (doOutput) {
        if (method.equals("GET")) {
          // they are requesting a stream to write to. This implies a POST method
          method = "POST";
        } else if (!HttpMethod.hasRequestBody(method)) {
          // If the request method is neither POST nor PUT nor PATCH, then you're not writing
          throw new ProtocolException(method + " does not support writing");
        }
      }
      httpEngine = newHttpEngine(method, null, null);
    } catch (IOException e) {
      httpEngineFailure = e;
      throw e;
    }
  }
  

  这里把connected设置成true也可以看出来是要进行请求了，因为没有设置doOutput（如果是GET方法设置了doOutput为true则在这里改为POST方法，其他的则判断此请求方法是否允许携带requestBody，不支持会抛出异常），所以默认false，最后走到newHttpEngine方法里：

  private HttpEngine newHttpEngine(String method, Connection connection,
      RetryableSink requestBody) {
    Request.Builder builder = new Request.Builder()
        .url(getURL())
        .method(method, null /* No body; that's passed separately. */);
    Headers headers = requestHeaders.build();
    for (int i = 0; i < headers.size(); i++) {
      builder.addHeader(headers.name(i), headers.value(i));
    }
  
    boolean bufferRequestBody = false;
    if (HttpMethod.hasRequestBody(method)) {
      if (fixedContentLength != -1) {
        builder.header("Content-Length", Long.toString(fixedContentLength));
      } else if (chunkLength > 0) {
        builder.header("Transfer-Encoding", "chunked");
      } else {
        bufferRequestBody = true;
      }
    }
  
    Request request = builder.build();
  
    // If we're currently not using caches, make sure the engine's client doesn't have one.
    OkHttpClient engineClient = client;
    if (engineClient.getOkResponseCache() != null && !getUseCaches()) {
      engineClient = client.clone().setOkResponseCache(null);
    }
  
    return new HttpEngine(engineClient, request, bufferRequestBody, connection, null, requestBody);
  }
  

  再回到getResponse方法，while(true)里面首先有一个execute的判断：

  private boolean execute(boolean readResponse) throws IOException {
    try {
      httpEngine.sendRequest();
      route = httpEngine.getRoute();
      handshake = httpEngine.getConnection() != null
          ? httpEngine.getConnection().getHandshake()
          : null;
      if (readResponse) {
        httpEngine.readResponse();
      }
  
      return true;
    } catch (IOException e) {
      HttpEngine retryEngine = httpEngine.recover(e);
      if (retryEngine != null) {
        httpEngine = retryEngine;
        return false;
      }
  
      // Give up; recovery is not possible.
      httpEngineFailure = e;
      throw e;
    }
  }
  

  我们看到在失败产生异常的时候会被捕获，recover就是根据之前的httpEngine的属性重新创建HttpEngine对象，返回false就会重走while循环，又会执行到execute，又会sendRequest，所以这部分就是失败重新请求操作。看一下sendRequest操作：

  public final void sendRequest() throws IOException {
    if (responseSource != null) return; // Already sent.
    if (transport != null) throw new IllegalStateException();
  	//设置header信息
    prepareRawRequestHeaders();
    //看一下有没有缓存Response
    OkResponseCache responseCache = client.getOkResponseCache();
  
    Response cacheResponse = responseCache != null
        ? responseCache.get(request)
        : null;
    long now = System.currentTimeMillis();
    //追溯get方法最终会从getCandidate()中返回一个CacheStrategy对象，它的source是ResponseSource.NETWORK
    CacheStrategy cacheStrategy = new CacheStrategy.Factory(now, request, cacheResponse).get();
    responseSource = cacheStrategy.source;
    request = cacheStrategy.request;
  
    if (responseCache != null) {
      responseCache.trackResponse(responseSource);
    }
  
    if (responseSource != ResponseSource.NETWORK) {
      validatingResponse = cacheStrategy.response;
    }
  
    if (cacheResponse != null && !responseSource.usesCache()) {
      closeQuietly(cacheResponse.body()); // We don't need this cached response. Close it.
    }
  	//responseSource.requiresConnection()会判断source是否是ResponseSource.CONDITIONAL_CACHE或者是ResponseSource.NETWORK
    if (responseSource.requiresConnection()) {
      // Open a connection unless we inherited one from a redirect.
      if (connection == null) {
        //关键代码，进行连接请求
        connect();
      }
  
      // Blow up if we aren't the current owner of the connection.
      if (connection.getOwner() != this && !connection.isSpdy()) throw new AssertionError();
  
      transport = (Transport) connection.newTransport(this);
  
      // Create a request body if we don't have one already. We'll already have
      // one if we're retrying a failed POST.
      if (hasRequestBody() && requestBodyOut == null) {
        requestBodyOut = transport.createRequestBody(request);
      }
  
    } else {
      // We're using a cached response. Recycle a connection we may have inherited from a redirect.
      if (connection != null) {
        client.getConnectionPool().recycle(connection);
        connection = null;
      }
  
      // No need for the network! Promote the cached response immediately.
      this.response = validatingResponse;
      if (validatingResponse.body() != null) {
        initContentStream(validatingResponse.body().source());
      }
    }
  }
  

  执行到connect进行请求连接：

  private void connect() throws IOException {
    if (connection != null) throw new IllegalStateException();
  
    if (routeSelector == null) {
      //主机地址
      String uriHost = request.url().getHost();
      if (uriHost == null || uriHost.length() == 0) {
        throw new UnknownHostException(request.url().toString());
      }
      //Https的安全验证信息
      SSLSocketFactory sslSocketFactory = null;
      HostnameVerifier hostnameVerifier = null;
      if (request.isHttps()) {
        sslSocketFactory = client.getSslSocketFactory();
        hostnameVerifier = client.getHostnameVerifier();
      }
      //封装Address信息
      Address address = new Address(uriHost, getEffectivePort(request.url()), sslSocketFactory,
          hostnameVerifier, client.getAuthenticator(), client.getProxy(), client.getProtocols());
      //封装RouterSelector信息
      routeSelector = new RouteSelector(address, request.uri(), client.getProxySelector(),
          client.getConnectionPool(), Dns.DEFAULT, client.getRoutesDatabase());
    }
  	//next方法构造一个Connection对象
    connection = routeSelector.next(request.method());
    connection.setOwner(this);
  
    if (!connection.isConnected()) {
      //连接
      connection.connect(client.getConnectTimeout(), client.getReadTimeout(), getTunnelConfig());
      if (connection.isSpdy()) client.getConnectionPool().share(connection);
      client.getRoutesDatabase().connected(connection.getRoute());
    } else if (!connection.isSpdy()) {
      connection.updateReadTimeout(client.getReadTimeout());
    }
  
    route = connection.getRoute();
  }
  

  connection.connect方法如下:

  public void connect(int connectTimeout, int readTimeout, TunnelRequest tunnelRequest)
      throws IOException {
    if (connected) throw new IllegalStateException("already connected");
  
    socket = (route.proxy.type() != Proxy.Type.HTTP) ? new Socket(route.proxy) : new Socket();
    Platform.get().connectSocket(socket, route.inetSocketAddress, connectTimeout);
    socket.setSoTimeout(readTimeout);
    in = socket.getInputStream();
    out = socket.getOutputStream();
  
    if (route.address.sslSocketFactory != null) {
      upgradeToTls(tunnelRequest);
    } else {
      initSourceAndSink();
      httpConnection = new HttpConnection(pool, this, source, sink);
    }
    connected = true;
  }
  

  终于看到socket了，这是java级别的网络请求了，Platform.get().connectSocket(socket, route.inetSocketAddress, connectTimeout)进行socket连接：

  public void connectSocket(Socket socket, InetSocketAddress address,
      int connectTimeout) throws IOException {
    socket.connect(address, connectTimeout);
  }
  

  到了这里就是HttpURLConnection和socket联系起来了，至于socket的部分会再起一篇文章总结。