什么是HttpDns？

DNS服务用于在网络请求时，将域名转为IP地址。传统的基于UDP协议的公共DNS服务极易发生DNS劫持，从而造成安全问题。HttpDns服务则是基于HTTP协议自建DNS服务，或者选择更加可靠的DNS服务提供商来完成DNS服务，以降低发生安全问题的风险。HttpDns还可以为精准调度提供支持。因而在当前网络环境中得到了越来越多的应用。

HttpDns的协议则因具体实现而异。通常是客户端将当前设备的一些信息，比如区域、运营商、网络的连接方式（WiFi还是移动网络）以及要解析的域名等传给HttpDns服务器，服务器为客户端返回对应的IP地址列表及这些IP地址的有效期等。

新浪的微博团队有开源自己的HttpDns方案出来，OSC的码云上项目地址，iOS版，项目的GitHub地址。腾讯有开放自己的HttpDns服务。阿里云 和 DNSPod 还推出了商业化的产品。目前各家建议的HttpDns接入方式大同小异，最初我们建议的 HttpDns 服务接入方式也参考了其他家的方式，但实际接入时却遇到了一些问题。

HttpDns的基本接入手法及其问题

在移动端，我们通常不会关心Http请求的详细执行过程，一般是将URL传给网络库，比如OkHttp、Volley、HttpClient或HttpUrlConnection等，简单的设置一些必要的request header，发起请求，并在请求执行结束之后获取响应。我们通过HttpDns获得的只是一些IP地址列表，那要如何将这些IP地址应用到网络请求中呢？

将由HttpDns获得的IP地址应用到我们的网络请求中最简单的办法，就是在原有URL的基础上，将域名替换为IP，然后用新的URL发起HTTP请求。然而，标准的HTTP协议中服务端会将HTTP请求头中HOST字段的值作为请求的域名，在我们没有主动设置HOST字段的值时，网络库也会自动地从URL中提取域名，并为请求做设置。但使用HttpDns后，URL中的域名信息丢失，会导致默认情况下请求的HOST 头部字段无法被正确设置，进而导致服务端的异常。为了解决这个问题，需要主动地为请求设置HOST字段值，如：

        String originalUrl = "http://www.163.com/";
        URL url = new URL(originalURL);
        String originalHost = url.getHost();
        // 同步接口获取IP
        String ip = httpdns.getIpByHost(originalHost);
        HttpURLConnection conn;
        if (ip != null) {
            // 通过HTTPDNS获取IP成功，进行URL替换和HOST头设置
            url = new URL(originalUrl.replaceFirst(originalHost, ip));
            conn = (HttpURLConnection) url.openConnection();
            // 设置请求HOST字段
            conn.setRequestProperty("Host", originHost);
        } else {
            conn = (HttpURLConnection) url.openConnection();
        }

这样是可以满足服务器获取客户端请求的域名的需要。然而，URL中的域名不只是服务器会用到。在客户端的网络库中，至少还有如下几个地方同样需要用到（具体可以参考 OkHttp3的连接池及连接建立过程分析 和 OkHttp3中的代理与路由 ）：

• COOKIE的存取。支持COOKIE存取的网络库，在存取COOKIE时，从URL中提取的域名通常是key的重要部分。
• 连接管理。连接的 Keep-Alive参数，可以让执行HTTP请求的TCP连接在请求结束后不会被立即关闭，而是先保持一段时间。为新发起的请求查找可用连接时，主要的依据也是URL中的域名。针对相同域名同时执行的HTTP请求的最大个数 6 个的限制，也需要借助于URL中的域名来完成。
• HTTPS的SNI及证书验证。SSL/TLS的SNI扩展用于支持虚拟主机托管。在SSL/TLS握手期间，客户端通过该扩展将要请求的域名发送给服务器，以便可以取到适当的证书。SNI信息也来源于URL中的域名。

阿里云建议 在使用 HttpDns 时关闭COOKIE。直接替换原URL中的域名发起请求，会使得对单域名的最大并发连接数限制退化为了对服务器IP地址的最大并发连接数限制；在发起HTTPS请求时，无法正确设置SNI信息只能拿到默认的证书，在域名验证时，会将IP地址作为验证的域名而导致验证失败。

HTTPS 域名证书验证问题 (不含SNI) 的基本解法

许多服务并不是多服务（域名）共用一个物理IP的，因而丢失SNI信息并不是特别的要紧。对于这种场景，解决掉域名证书的验证问题即可。针对 HttpsURLConnection 接口，方法如下：

        try {
            String url = "https://140.225.164.59/?sprefer=sypc00";
            final String originHostname = "www.wolfcstech.com";
            HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
            connection.setRequestProperty("Host", originHostname);
            connection.setHostnameVerifier(new HostnameVerifier() {
                /*
                 * 关于这个接口的说明，官方有文档描述：
                 * This is an extended verification option that implementers can provide.
                 * It is to be used during a handshake if the URL's hostname does not match the
                 * peer's identification hostname.
                 *
                 * 使用HTTPDNS后URL里设置的hostname不是远程的主机名(如:m.taobao.com)，与证书颁发的域不匹配，
                 * Android HttpsURLConnection提供了回调接口让用户来处理这种定制化场景。
                 * 在确认HTTPDNS返回的源站IP与Session携带的IP信息一致后，您可以在回调方法中将待验证域名替换为原来的真实域名进行验证。
                 *
                 */
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return HttpsURLConnection.getDefaultHostnameVerifier().verify(originHostname, session);
                }
            });
            connection.connect();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }

主要思路即是自定义证书验证的逻辑。HostnameVerifier 的 verify() 传回来的域名是url中的ip地址，但我们可以在定制的域名证书验证逻辑中，使用原始的真实的域名与服务器返回的证书一起做验证。这种解法还算可以。

SNI问题基本解法一

对于多个域名部署在相同IP地址的主机上的场景，除了要处理域名证书验证外，SNI的设置也是必须的。阿里云给出的解决方案是，自定义SSLSocketFactory，控制SSLSocket的创建过程。在SSLSocket被创建成功之后，立即设置SNI信息进去。

定制的SSLSocketFactory实现如下：

public class TlsSniSocketFactory extends SSLSocketFactory {
    private final String TAG = TlsSniSocketFactory.class.getSimpleName();
    HostnameVerifier hostnameVerifier = HttpsURLConnection.getDefaultHostnameVerifier();
    private HttpsURLConnection conn;
    public TlsSniSocketFactory(HttpsURLConnection conn) {
        this.conn = conn;
    }
    @Override
    public Socket createSocket() throws IOException {
        return null;
    }
    @Override
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return null;
    }

    @Override
    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
        return null;
    }

    @Override
    public Socket createSocket(InetAddress host, int port) throws IOException {
        return null;
    }
    @Override
    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
        return null;
    }
    // TLS layer
    @Override
    public String[] getDefaultCipherSuites() {
        return new String[0];
    }
    @Override
    public String[] getSupportedCipherSuites() {
        return new String[0];
    }
    @Override
    public Socket createSocket(Socket plainSocket, String host, int port, boolean autoClose) throws IOException {
        String peerHost = this.conn.getRequestProperty("Host");
        if (peerHost == null)
            peerHost = host;
        Log.i(TAG, "customized createSocket. host: " + peerHost);
        InetAddress address = plainSocket.getInetAddress();
        if (autoClose) {
            // we don't need the plainSocket
            plainSocket.close();
        }
        // create and connect SSL socket, but don't do hostname/certificate verification yet
        SSLCertificateSocketFactory sslSocketFactory = (SSLCertificateSocketFactory) SSLCertificateSocketFactory.getDefault(0);
        SSLSocket ssl = (SSLSocket) sslSocketFactory.createSocket(address, port);
        // enable TLSv1.1/1.2 if available
        ssl.setEnabledProtocols(ssl.getSupportedProtocols());
        // set up SNI before the handshake
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            Log.i(TAG, "Setting SNI hostname");
            sslSocketFactory.setHostname(ssl, peerHost);
        } else {
            Log.d(TAG, "No documented SNI support on Android <4.2, trying with reflection");
            try {
     java.lang.reflect.Method setHostnameMethod = ssl.getClass().getMethod("setHostname", String.class);
                setHostnameMethod.invoke(ssl, peerHost);
            } catch (Exception e) {
                Log.w(TAG, "SNI not useable", e);
            }
        }
        // verify hostname and certificate
        SSLSession session = ssl.getSession();
        if (!hostnameVerifier.verify(peerHost, session))
            throw new SSLPeerUnverifiedException("Cannot verify hostname: " + peerHost);
        Log.i(TAG, "Established " + session.getProtocol() + " connection with " + session.getPeerHost() +
                " using " + session.getCipherSuite());
        return ssl;
    }
}

   

HTTPS请求发起过程如下：

    public void recursiveRequest(String path, String reffer) {
        URL url = null;
        try {
            url = new URL(path);
            conn = (HttpsURLConnection) url.openConnection();
            // 同步接口获取IP
            String ip = httpdns.getIpByHostAsync(url.getHost());
            if (ip != null) {
                // 通过HTTPDNS获取IP成功，进行URL替换和HOST头设置
                Log.d(TAG, "Get IP: " + ip + " for host: " + url.getHost() + " from HTTPDNS successfully!");
                String newUrl = path.replaceFirst(url.getHost(), ip);
                conn = (HttpsURLConnection) new URL(newUrl).openConnection();
                // 设置HTTP请求头Host域
                conn.setRequestProperty("Host", url.getHost());
            }
            conn.setConnectTimeout(30000);
            conn.setReadTimeout(30000);
            conn.setInstanceFollowRedirects(false);
            TlsSniSocketFactory sslSocketFactory = new TlsSniSocketFactory(conn);
            conn.setSSLSocketFactory(sslSocketFactory);
            conn.setHostnameVerifier(new HostnameVerifier() {
                /*
                 * 关于这个接口的说明，官方有文档描述：
                 * This is an extended verification option that implementers can provide.
                 * It is to be used during a handshake if the URL's hostname does not match the
                 * peer's identification hostname.
                 *
                 * 使用HTTPDNS后URL里设置的hostname不是远程的主机名(如:m.taobao.com)，与证书颁发的域不匹配，
                 * Android HttpsURLConnection提供了回调接口让用户来处理这种定制化场景。
                 * 在确认HTTPDNS返回的源站IP与Session携带的IP信息一致后，您可以在回调方法中将待验证域名替换为原来的真实域名进行验证。
                 *
                 */
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    String host = conn.getRequestProperty("Host");
                    if (null == host) {
                        host = conn.getURL().getHost();
                    }
                    return HttpsURLConnection.getDefaultHostnameVerifier().verify(host, session);
                }
            });
            int code = conn.getResponseCode();// Network block
            if (needRedirect(code)) {
                //临时重定向和永久重定向location的大小写有区分
                String location = conn.getHeaderField("Location");
                if (location == null) {
                    location = conn.getHeaderField("location");
                }
                if (!(location.startsWith("http://") || location
                        .startsWith("https://"))) {
                    //某些时候会省略host，只返回后面的path，所以需要补全url
                    URL originalUrl = new URL(path);
                    location = originalUrl.getProtocol() + "://"
                            + originalUrl.getHost() + location;
                }
                recursiveRequest(location, path);
            } else {
                // redirect finish.
                DataInputStream dis = new DataInputStream(conn.getInputStream());
                int len;
                byte[] buff = new byte[4096];
                StringBuilder response = new StringBuilder();
                while ((len = dis.read(buff)) != -1) {
                    response.append(new String(buff, 0, len));
                }
                Log.d(TAG, "Response: " + response.toString());
            }
        } catch (MalformedURLException e) {
            Log.w(TAG, "recursiveRequest MalformedURLException");
        } catch (IOException e) {
            Log.w(TAG, "recursiveRequest IOException");
        } catch (Exception e) {
            Log.w(TAG, "unknow exception");
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }
    private boolean needRedirect(int code) {
        return code >= 300 && code < 400;
    }

但这种解法是否真的可行呢？OkHttp被集成进AOSP并作为Android Java层的HTTP stack已经有一段时间了，我们通过 OkHttp 的实现代码来看一下这种方法是否真的可行。

相关阅读：

Android端打开HttpDns的正确姿势（下篇）

网易云新用户大礼包：https://www.163yun.com/gift

本文来自网易实践者社区，经作者韩鹏飞授权发布。