Android基于DNS拦截的Webview代理

背景

App的开发过程中，通常需要切换环境来进行调试。虽然我们可以通过切换App内部域名的方式来达到切换环境的目的。但是对于M页来说，并不能影响到M页请求地址。
通常的处理方案，是手机的wifi连上电脑的代理，然后电脑配置对应的host，然后才能进行调试或者测试。
因此这里做一个可以在app内部进行代理切换的功能。

配置域名

配置你需要的域名，这里给出实例代码，实际中可以通过读取自己页面的配置来实现。

public class ProxyList {
    private static HashMap mMap;
    public static HashMap getList() {
        if (mMap == null) {
            synchronized (ProxyList.class) {
                if (mMap == null) {
                    mMap = new HashMap();
                    // 可以从实际的配置中取，这是只是演示
                    mMap.put("host.com", "testhost.com");
                    mMap.put("ip.com", "192.168.1.1");
                }
            }
        }
        return mMap;
    }
}

上述代码存在两个问题
1、数据未put进去的时候，但是mMap已经创建的时候，这时get方法得到的未空。
2、极小的概率会造成mMap为空。说明请看这篇文章http://blog.csdn.net/glory1234work2115/article/details/50814419吧。
最后这里还是把整个方法改成synchronized来解决了。最简单的解决方式了。

okhttp的DNS拦截（可选）

因为本人搬砖的项目用的是okttp，因此这里给下okhttp拦截方法。将okhttp的Dns参数替换成自定义的MyDns，这样连okhttp都会使用我们配置的dns。这个对webview是没有影响的，因此可不配置。

public class MyDns implements Dns {
    @Override
    public List lookup(String hostname) throws UnknownHostException {
        if (hostname == null) throw new UnknownHostException("hostname == null");
        if (BuildConfig.RELEASE) {
            return Dns.SYSTEM.lookup(hostname);
        }

        String ip = ProxyList.getList().get(hostname);
        ZLog.d("DNS LOG: start intercept:" + hostname);
        if (StringUtils.isNotEmpty(ip)){
            ZLog.d("DNS LOG:" + hostname + " is replaced by ip " + ip);
            return Arrays.asList(InetAddress.getAllByName(ip));
        } else {
            ZLog.d("DNS LOG:" + hostname + " is not replaced");
            return Arrays.asList(InetAddress.getAllByName(hostname));
        }
    }
}

webview资源拦截

使用WebviewClient的拦截资源请求的方法来实现。

//WebviewClient 中重写这两个方法，拦截资源
        @Override
        public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
            if (BuildConfig.RELEASE) {
                return super.shouldInterceptRequest(view, request);
            } else {
                return WebviewDnsInterceptUtil.getDnsInterceptRequest(view, request);
            }
        }

        @Override
        public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
            if (BuildConfig.RELEASE) {
                return super.shouldInterceptRequest(view, url);
            } else {
                return WebviewDnsInterceptUtil.getDnsInterceptUrl(view, url);
            }
        }

然后就是拦截资源了
1、查看是否需要替换域名
2、建立urlconnection获取资源返回资源，不同担心，这里是子线程。
拦截资源代码如下：

public class WebviewDnsInterceptUtil {

    @SuppressLint("NewApi")
    public static WebResourceResponse getDnsInterceptRequest(WebView view, WebResourceRequest request) {
        if (request != null && request.getUrl() != null && request.getMethod().equalsIgnoreCase("get")) {
            return getWebResourceFromUrl(request.getUrl().toString());
        }
        return null;
    }

    public static WebResourceResponse getDnsInterceptUrl(WebView view, String url) {
        if (!TextUtils.isEmpty(url) && Uri.parse(url).getScheme() != null) {
            return getWebResourceFromUrl(url);
        }
        return null;
    }

//核心拦截方法
    private static WebResourceResponse getWebResourceFromUrl(String url) {

        String scheme = Uri.parse(url).getScheme().trim();

        ZLog.d("web log 请求 url: " + url);

        String ips = ProxyList.getList().get(Uri.parse(url).getHost());
        if (StringUtils.isEmpty(ips)) {
            ZLog.d("web log 不拦截：" + url);
            return null;
        }

        // HttpDns解析css文件的网络请求及图片请求
        if ((scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https"))) {
            try {
                URL oldUrl = new URL(url);
                URLConnection connection = oldUrl.openConnection();
                // 获取HttpDns域名解析结果 // 通过HTTPDNS获取IP成功，进行URL替换和HOST头设置
                ZLog.d("HttpDns ips are: " + ips + " for host: " + oldUrl.getHost());
                String ip;
                if (ips.contains(";")) {
                    ip = ips.substring(0, ips.indexOf(";"));
                } else {
                    ip = ips;
                }
                String newUrl = url.replaceFirst(oldUrl.getHost(), ip);
                ZLog.d("newUrl a is: " + newUrl);
                connection =  new URL(newUrl).openConnection(); // 设置HTTP请求头Host域
                connection.setRequestProperty("Host", oldUrl.getHost());
                ZLog.d("ContentType a: " + connection.getContentType());
//有可能是text/html; charset=utf-8的形式，只需要第一个
                String[] strings = connection.getContentType().split(";");
                return new WebResourceResponse(strings[0], "UTF-8", connection.getInputStream());
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

然后测试，发现拦截成功了，域名会变成我们改的域名或者ip。

(补充)解决https证书错误等问题

测试环境下没有真正的https证书，因此会产生异常。
这里的解决方案就是忽略证书错误。
修改后的代码：

        // HttpDns解析css文件的网络请求及图片请求
        if ((scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https"))) {
            HttpsURLConnection connection = null;
            try {
                URL oldUrl = new URL(url);
                // 获取HttpDns域名解析结果 // 通过HTTPDNS获取IP成功，进行URL替换和HOST头设置
                ZLog.d("HttpDns ips are: " + ips + " for host: " + oldUrl.getHost());
                String ip;
                if (ips.contains(";")) {
                    ip = ips.substring(0, ips.indexOf(";"));
                } else {
                    ip = ips;
                }
                String newUrl = url.replaceFirst(oldUrl.getHost(), ip);
                ZLog.d("newUrl a is: " + newUrl);
                connection = (HttpsURLConnection) new URL(newUrl).openConnection(); // 设置HTTP请求头Host域
                connection.setHostnameVerifier(getNullHostNameVerifier());
                connection.setSSLSocketFactory(getIgnoreSSLContext().getSocketFactory());
                connection.setRequestProperty("Host", oldUrl.getHost());
                ZLog.d("ContentType a: " + connection.getContentType());

                String encode = connection.getContentEncoding();
                if (encode == null) {
                    encode = "UTF-8";
                }
                if (connection.getContentType() != null) {
                    String[] strings = connection.getContentType().split(";");
                    return new WebResourceResponse(strings[0], encode, connection.getInputStream());
                } else {
                    return new WebResourceResponse("document", encode, connection.getInputStream());
                }
            } catch (Exception e) {
                ZLog.d(e.toString());
                return new WebResourceResponse("document", "UTF-8", null);
            } finally {
                if (connection != null) {
                    connection.disconnect();
                }
            }
        }
        return null;

两个get方法：

    private static volatile SSLContext mIgnoreSSLContext;
    private static volatile HostnameVerifier mNullHostNameVerifier;

    public static SSLContext getIgnoreSSLContext () {
       if (mIgnoreSSLContext == null) {
           synchronized (WebviewDnsInterceptUtil.class) {
               if (mIgnoreSSLContext == null) {
                   try {
                       mIgnoreSSLContext = SSLContext.getInstance("TLS");
                       TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager(){
                           public X509Certificate[] getAcceptedIssuers(){return null;}
                           public void checkClientTrusted(X509Certificate[] certs, String authType){}
                           public void checkServerTrusted(X509Certificate[] certs, String authType){}
                       }};
                       mIgnoreSSLContext.init(null, trustAllCerts, new SecureRandom());
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           }
       }
       return mIgnoreSSLContext;
    }

    public static HostnameVerifier getNullHostNameVerifier() {
        if (mNullHostNameVerifier == null) {
            synchronized (WebviewDnsInterceptUtil.class) {
                mNullHostNameVerifier = new NullHostNameVerifier();
            }
        }
        return mNullHostNameVerifier;
    }

NullHostNameVerifier：

public class NullHostNameVerifier implements HostnameVerifier {

    @Override
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }
}

总结

实现这个功能还是不难的，关键是要去想实现这个功能，多查查资料我们总能找到办法去解决。当然，这里只是把功能的实现列出来，要实际用起来，还需要写一些配置页面，开关的拦截等。要做成完整的功能，还需要大家自己去实现了。

感悟

要肯想解决问题，才会去解决问题。