Android P 要求网络请求必须为Https，Http请求会抛异常。

这里我通过访问http://www.hao123.cn这个地址，测试了下面三种场景，以及给出相应的结果：

我们知道，Volley底层使用HttpUrlConnection实现，而HttpUrlConnection底层实质是OkHttp。

到这里，只能简单推导出：
Android 9.0对于Http网络请求的限制，源于应用框架层，且一定和OkHttp源码有关。

源码分析

目的：通过分析源码，研究Http网络请求限制的原理、以及如何打开限制开关。

通过全局查找CLEARTEXT communication to www.hao123.cn not permitted by network security policy报错日志，发现这个异常是在OkHttp执行connect()方法时抛出的：

RealConnection

  public void connect(int connectTimeout, int readTimeout, int writeTimeout,
      boolean connectionRetryEnabled, Call call, EventListener eventListener) {
      ...
    if (route.address().sslSocketFactory() == null) {
      if (!connectionSpecs.contains(ConnectionSpec.CLEARTEXT)) {
        throw new RouteException(new UnknownServiceException(
            "CLEARTEXT communication not enabled for client"));
      }
      String host = route.address().url().host();
      if (!Platform.get().isCleartextTrafficPermitted(host)) {
        throw new RouteException(new UnknownServiceException(
            "CLEARTEXT communication to " + host + " not permitted by network security policy"));
      }
    }
    ...

route.address()会返回一个Address对象，这里可以看下Address构造函数截取的部分代码：

    this.url = new HttpUrl.Builder()
        .scheme(sslSocketFactory != null ? "https" : "http")
        .host(uriHost)
        .port(uriPort)
        .build();

从源码可以看出，只有scheme为http，才会进入下面的条件判断。

Android 9.0不允许Http请求，可见Platform.get().isCleartextTrafficPermitted(host)在9.0系统上返回了false，该方法意为是否可以明文传输。
Platform的真正实现类是AndroidPlatform，所以实际源码如下：

AndroidPlatform

  @Override public boolean isCleartextTrafficPermitted(String hostname) {
    try {
      Class<?> networkPolicyClass = Class.forName("android.security.NetworkSecurityPolicy");
      Method getInstanceMethod = networkPolicyClass.getMethod("getInstance");
      Object networkSecurityPolicy = getInstanceMethod.invoke(null);
      return api24IsCleartextTrafficPermitted(hostname, networkPolicyClass, networkSecurityPolicy);
    } catch (ClassNotFoundException | NoSuchMethodException e) {
      return super.isCleartextTrafficPermitted(hostname);
    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
      throw assertionError("unable to determine cleartext support", e);
    }
  }

通过反射，获取到android.security.NetworkSecurityPolicy对象，并执行了api24IsCleartextTrafficPermitted方法：

AndroidPlatform

  private boolean api24IsCleartextTrafficPermitted(String hostname, Class<?> networkPolicyClass,
      Object networkSecurityPolicy) throws InvocationTargetException, IllegalAccessException {
    try {
      Method isCleartextTrafficPermittedMethod = networkPolicyClass
          .getMethod("isCleartextTrafficPermitted", String.class);
      return (boolean) isCleartextTrafficPermittedMethod.invoke(networkSecurityPolicy, hostname);
    } catch (NoSuchMethodException e) {
      return api23IsCleartextTrafficPermitted(hostname, networkPolicyClass, networkSecurityPolicy);
    }
  }

这里仍然通过反射，最终执行了android.security.NetworkSecurityPolicy的isCleartextTrafficPermitted方法：

android.security.NetworkSecurityPolicy

    public boolean isCleartextTrafficPermitted(String hostname) {
        return libcore.net.NetworkSecurityPolicy.getInstance()
                .isCleartextTrafficPermitted(hostname);
    }

libcore是Android的Java核心库。

libcore.net.NetworkSecurityPolicy是个抽象类，它的实现类是android.security.net.config.ConfigNetworkSecurityPolicy，它的源码如下：

ConfigNetworkSecurityPolicy

public class ConfigNetworkSecurityPolicy extends libcore.net.NetworkSecurityPolicy {
    private final ApplicationConfig mConfig;

    public ConfigNetworkSecurityPolicy(ApplicationConfig config) {
        mConfig = config;
    }

    @Override
    public boolean isCleartextTrafficPermitted() {
        return mConfig.isCleartextTrafficPermitted();
    }

    @Override
    public boolean isCleartextTrafficPermitted(String hostname) {
        return mConfig.isCleartextTrafficPermitted(hostname);
    }

    @Override
    public boolean isCertificateTransparencyVerificationRequired(String hostname) {
        return false;
    }
}

ConfigNetworkSecurityPolicy又是通过调用ApplicationConfig的isCleartextTrafficPermitted来返回是否可以明文传输的，接着往下找。

ApplicationConfig

    public boolean isCleartextTrafficPermitted(String hostname) {
        return getConfigForHostname(hostname).isCleartextTrafficPermitted();
   }

getConfigForHostname()源码很长，这里我们不关注细节，只需要知道假如我们没有单独做配置，getConfigForHostname()会默认返回NetworkSecurityConfig，它在内部维护了一个布尔值变量，它决定是否允许Http明文传输。

现在只需要找到这个布尔值何时被赋值，就可以明白Http明文传输的条件。
这里从NetworkSecurityConfig的初始化开始找：

private void ensureInitialized() {
        synchronized(mLock) {
            ...
            mConfigs = mConfigSource.getPerDomainConfigs();
            mDefaultConfig = mConfigSource.getDefaultConfig();
            ...
        }
    }

可以看到，NetworkSecurityConfig来源于ConfigSource，而ConfigSource是个接口，真正的实现类是ManifestConfigSource，而它则提供了获取其它ConfigSource实现类的方法：

ManifestConfigSource

    private ConfigSource getConfigSource() {
        synchronized (mLock) {
            if (mConfigSource != null) {
                return mConfigSource;
            }
            int configResource = mApplicationInfo.networkSecurityConfigRes;
            ConfigSource source;
            if (configResource != 0) {
                boolean debugBuild =
                        (mApplicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
                if (DBG) {
                    Log.d(LOG_TAG, "Using Network Security Config from resource "
                            + mContext.getResources()
                                .getResourceEntryName(configResource)
                            + " debugBuild: " + debugBuild);
                }
                source = new XmlConfigSource(mContext, configResource, mApplicationInfo);
            } else {
                if (DBG) {
                    Log.d(LOG_TAG, "No Network Security Config specified, using platform default");
                }
                // the legacy FLAG_USES_CLEARTEXT_TRAFFIC is not supported for Ephemeral apps, they
                // should use the network security config.
                boolean usesCleartextTraffic =
                        (mApplicationInfo.flags & ApplicationInfo.FLAG_USES_CLEARTEXT_TRAFFIC) != 0
                        && mApplicationInfo.targetSandboxVersion < 2;
                source = new DefaultConfigSource(usesCleartextTraffic, mApplicationInfo);
            }
            mConfigSource = source;
            return mConfigSource;
        }
    }

这里我们暂时不关心XmlConfigSource这个ConfigSource，只关心DefaultConfigSource，它的源码如下：

DefaultConfigSource

    private static final class DefaultConfigSource implements ConfigSource {

        private final NetworkSecurityConfig mDefaultConfig;

        DefaultConfigSource(boolean usesCleartextTraffic, ApplicationInfo info) {
            mDefaultConfig = NetworkSecurityConfig.getDefaultBuilder(info)
                    .setCleartextTrafficPermitted(usesCleartextTraffic)
                    .build();
        }

        @Override
        public NetworkSecurityConfig getDefaultConfig() {
            return mDefaultConfig;
        }

        @Override
        public Set<Pair<Domain, NetworkSecurityConfig>> getPerDomainConfigs() {
            return null;
        }
    }

这里可以看到关键方法：setCleartextTrafficPermitted(usesCleartextTraffic)，这个方法中的usesCleartextTraffic就是前文所说的布尔值变量，它决定了是否支持Http明文传输。
而usesCleartextTraffic来源于上一步getConfigSource中的代码：

boolean usesCleartextTraffic = (mApplicationInfo.flags & ApplicationInfo.FLAG_USES_CLEARTEXT_TRAFFIC) != 0 && mApplicationInfo.targetSandboxVersion < 2;

其中：

public static final int FLAG_USES_CLEARTEXT_TRAFFIC = 1<<27;

关于ApplicationInfo.flags各位可以百度另行了解，这里这段代码的意义为：

API版本为>27，则返回 usesCleartextTraffic = false。

整个系统调用流程如下：

流程图.png

但是到此为止，我们的问题--【如何打破网络限制】还没有得到解决。

上述代码里，ManifestConfigSource会优先调用XmlConfigSource。

所以我们可以初步得出：通过在AndroidManifest中配置xml文件，就能打破限制。那么如何配置呢？

我们先来看一下ManifestConfigSource的构造函数：

public ManifestConfigSource(Context context) {
        mContext = context;
        ApplicationInfo info = context.getApplicationInfo(); //1
        mApplicationInfoFlags = info.flags;
        mTargetSdkVersion = info.targetSdkVersion; 
        mConfigResourceId = info.networkSecurityConfigRes; //2
        mTargetSandboxVesrsion = info.targetSandboxVersion;
    }

这里，我们可以知道俩个信息：

1. 注释2处，会去获取networkSecurityConfigRes网络安全配置；
2. 注释1处可以看出，该网络安全配置信息来自application;

于是我在AndroidManifest-application尝试输入net...，果然as的代码提示就展示出了我要的配置：

application.png

networkSecurityConfig需要的是个xml文件，那么这个xml文件该如何配置才能绕过网络限制呢？

回到刚才的XmlConfigSource源码，这里我们需要关注俩个地方：

源码1：

    private List<Pair<NetworkSecurityConfig.Builder, Set<Domain>>> parseConfigEntry(
            XmlResourceParser parser, Set<String> seenDomains,
            NetworkSecurityConfig.Builder parentBuilder, int configType)
            throws IOException, XmlPullParserException, ParserException {
        ...
        for (int i = 0; i < parser.getAttributeCount(); i++) {
            String name = parser.getAttributeName(i);
            if ("hstsEnforced".equals(name)) {
                builder.setHstsEnforced(
                        parser.getAttributeBooleanValue(i,
                                NetworkSecurityConfig.DEFAULT_HSTS_ENFORCED));
            } else if ("cleartextTrafficPermitted".equals(name)) {
                builder.setCleartextTrafficPermitted(
                        parser.getAttributeBooleanValue(i,
                                NetworkSecurityConfig.DEFAULT_CLEARTEXT_TRAFFIC_PERMITTED));
            }
        }
        ...

parseConfigEntry解析并设置了是否允许明文传输，看来他就是关键。这里可以得出我们要配置的属性名为cleartextTrafficPermitted，它的值是boolean类型。

不要问我怎么找到cleartextTrafficPermitted这个属性的...明文传输就这一个关键字，全局搜索你就会发现只有这儿一处被调用。

源码2：

    private static final String getConfigString(int configType) {
        switch (configType) {
            case CONFIG_BASE:
                return "base-config";
            case CONFIG_DOMAIN:
                return "domain-config";
            case CONFIG_DEBUG:
                return "debug-overrides";
            default:
                throw new IllegalArgumentException("Unknown config type: " + configType);
        }
    }

上述源码可得：config的Type仅能为三者之一。这里我们不需要遍历源码去分析，从字段名就可以基本推断出是第一个。

所以这个xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<自定义你的名字>
    <base-config cleartextTrafficPermitted="true" />
</自定义你的名字>

将xml配置在上述networkSecurityConfig即可。

结论

OkHttp通过调用Android API中的isCleartextTrafficPermitted(host)，在9.0系统上限制了Http明文请求。

所以可以有俩种方式绕过Http明文限制：
1.通过上述源码分析中的XmlConfigSource打开开关限制。
2.自己通过Socket写Http请求，或使用底层非OkHttp、且没有进行过Http明文判断的第三方网络框架。

通过配置XML绕过HTTP限制

下面就上述结论中的第一个方案给出完整的解决步骤：

首先在res文件夹下创建xml目录，新建network_security_config.xml文件，生成如下代码：

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="true" />
</network-security-config>

然后在AndroidManifest.xml的Application中做如下配置：

android:networkSecurityConfig="@xml/network_security_config"

通过上述解析，应该可以大致理解这样配置的原理。

另外使用Volley还需要在application里配置如下代码：

 <uses-library android:name="org.apache.http.legacy" android:required="false" />

最后还是要说一句：

Android9.0选择了禁用Http明文请求，无论是从安全还是从其它方面考虑，我们都应该尽量遵守Android规定，共同维护Android环境，而不是想办法绕过限制。