HarmonyOS鸿蒙Next中应用如何将特定的网络请求接口绑定特定的网络来进行网络请求

你希望在同一个 App 中实现接口级别的网络绑定—— 让 HTTP 请求 A 走 WiFi、请求 B 走蜂窝数据，而非官方提供的整个 App 级别的网络绑定，同时解决 WiFi 连接时无法使用蜂窝数据请求的问题。

这个需求无法通过常规的 HTTP 框架（如 Retrofit、OkHttp）直接实现，核心是要在发起具体请求前，为该请求指定专属的网络接口（WiFi 或蜂窝数据），再基于该网络接口构建请求连接。下面分 Android 和 iOS 两个主流移动端平台，分别提供可落地的实现方案（这两个平台的底层网络 API 都支持接口级别的网络绑定）。

一、核心原理说明

无论 Android 还是 iOS，实现该需求的核心逻辑一致：

1. 先获取设备当前已连接的所有网络接口（区分 WiFi 接口、蜂窝数据接口）；
2. 发起具体 HTTP 请求前，为该请求绑定指定的网络接口；
3. 使用支持绑定网络的底层 Socket / 网络客户端构建 HTTP 请求，避免使用系统默认的网络路由。

注意：该功能需要设备同时开启并连接 WiFi 和蜂窝数据（部分安卓机型需要手动开启「双网同时在线」，iOS 一般默认支持），且需要申请对应的权限。

二、Android 平台实现方案

Android 提供了 Network 类（Android 5.0+ API 21），可以实现单个请求绑定指定网络，推荐结合 OkHttp（主流 HTTP 框架）实现。

步骤 1：申请必要权限

在 AndroidManifest.xml 中添加权限，适配 Android 6.0+ 动态权限：

<!-- 网络状态查询权限 -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!-- 网络访问权限 -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- Android 10+ 绑定指定网络需要的权限 -->
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_NETWORK" />

步骤 2：获取指定类型的 Network（WiFi / 蜂窝数据）

通过 ConnectivityManager 获取 WiFi 或蜂窝数据对应的 Network 实例：

import android.content.Context
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.os.Build

object NetworkSelector {
    /**
     * 获取指定类型的网络（WiFi 或 蜂窝数据）
     * @param context 上下文
     * @param isWiFi 是否需要 WiFi 网络（false 为蜂窝数据）
     * @return 对应的 Network 实例（无可用网络返回 null）
     */
    fun getTargetNetwork(context: Context, isWiFi: Boolean): Network? {
        val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        
        // Android 10+ 推荐使用 getAllNetworks() + getNetworkCapabilities()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            val allNetworks = connectivityManager.allNetworks
            for (network in allNetworks) {
                val networkCapabilities = connectivityManager.getNetworkCapabilities(network) ?: continue
                // 匹配 WiFi 或 蜂窝数据
                val isTargetNetwork = if (isWiFi) {
                    networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
                } else {
                    networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
                }
                // 确保网络已连接且可用
                if (isTargetNetwork && networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
                    return network
                }
            }
        } else {
            // 兼容 Android 5.0-9.0
            @Suppress("DEPRECATION")
            val allNetworks = connectivityManager.allNetworks
            for (network in allNetworks) {
                @Suppress("DEPRECATION")
                val networkInfo = connectivityManager.getNetworkInfo(network) ?: continue
                val isTargetNetwork = if (isWiFi) {
                    networkInfo.type == ConnectivityManager.TYPE_WIFI
                } else {
                    networkInfo.type == ConnectivityManager.TYPE_MOBILE
                }
                if (isTargetNetwork && networkInfo.isConnected) {
                    return network
                }
            }
        }
        return null
    }
}

步骤 3：为 OkHttp 请求绑定指定 Network

OkHttp 支持通过 socketFactory 和 sslSocketFactory 绑定 Network，构建专属的 OkHttpClient 实例：

import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.IOException
import java.net.Socket
import java.net.SocketException
import javax.net.ssl.SSLSocketFactory

/**
 * 构建绑定指定网络的 OkHttpClient
 * @param targetNetwork 目标 Network 实例
 * @return 绑定后的 OkHttpClient
 */
fun buildBoundOkHttpClient(targetNetwork: Network): OkHttpClient {
    return OkHttpClient.Builder()
        .socketFactory(object : SocketFactory() {
            override fun createSocket(): Socket {
                // 关键：使用 Network 创建 Socket，绑定该网络
                return targetNetwork.socketFactory.createSocket()
            }

            override fun createSocket(host: String?, port: Int): Socket {
                return targetNetwork.socketFactory.createSocket(host, port)
            }

            override fun createSocket(
                host: String?,
                port: Int,
                localHost: InetAddress?,
                localPort: Int
            ): Socket {
                return targetNetwork.socketFactory.createSocket(host, port, localHost, localPort)
            }

            override fun createSocket(host: InetAddress?, port: Int): Socket {
                return targetNetwork.socketFactory.createSocket(host, port)
            }

            override fun createSocket(
                address: InetAddress?,
                port: Int,
                localAddress: InetAddress?,
                localPort: Int
            ): Socket {
                return targetNetwork.socketFactory.createSocket(address, port, localAddress, localPort)
            }
        })
        .sslSocketFactory(object : SSLSocketFactory() {
            private val delegate = targetNetwork.sslSocketFactory

            override fun createSocket(s: Socket, host: String, port: Int, autoClose: Boolean): Socket {
                return delegate.createSocket(s, host, port, autoClose)
            }

            override fun getDefaultCipherSuites(): Array<String> {
                return delegate.defaultCipherSuites
            }

            override fun getSupportedCipherSuites(): Array<String> {
                return delegate.supportedCipherSuites
            }

            override fun createSocket(host: String, port: Int): Socket {
                return delegate.createSocket(host, port)
            }

            override fun createSocket(
                host: String,
                port: Int,
                localHost: InetAddress,
                localPort: Int
            ): Socket {
                return delegate.createSocket(host, port, localHost, localPort)
            }

            override fun createSocket(host: InetAddress, port: Int): Socket {
                return delegate.createSocket(host, port)
            }

            override fun createSocket(
                address: InetAddress,
                port: Int,
                localAddress: InetAddress,
                localPort: Int
            ): Socket {
                return delegate.createSocket(address, port, localAddress, localPort)
            }
        })
        .build()
}

// 实际使用示例
suspend fun sendRequestWithSpecifiedNetwork(context: Context, url: String, isWiFi: Boolean) {
    // 1. 获取目标网络
    val targetNetwork = NetworkSelector.getTargetNetwork(context, isWiFi) ?: run {
        throw IOException("无可用的 ${if (isWiFi) "WiFi" else "蜂窝数据"} 网络")
    }
    
    // 2. 构建绑定该网络的 OkHttpClient
    val boundOkHttpClient = buildBoundOkHttpClient(targetNetwork)
    
    // 3. 发起 HTTP 请求（该请求会强制走指定网络）
    val request = Request.Builder().url(url).build()
    val response = boundOkHttpClient.newCall(request).execute()
    
    // 4. 处理响应结果
    if (response.isSuccessful) {
        val responseBody = response.body?.string()
        println("请求成功，响应内容：$responseBody")
    } else {
        throw IOException("请求失败，状态码：${response.code}")
    }
}

步骤 4：接口级别的请求分发

调用时只需指定是否走 WiFi，即可实现请求 A 走 WiFi、请求 B 走蜂窝数据：

// 请求 A：走 WiFi
sendRequestWithSpecifiedNetwork(context, "https://api.example.com/requestA", isWiFi = true)

// 请求 B：走蜂窝数据
sendRequestWithSpecifiedNetwork(context, "https://api.example.com/requestB", isWiFi = false)

三、iOS 平台实现方案

iOS 提供了 NWPath、NWConnection（Network 框架）和 URLSessionConfiguration 的 allowsCellularAccess/interfaceIdentifier 属性，实现接口级别的网络绑定，推荐使用 URLSession（系统原生 HTTP 框架）。

步骤 1：导入必要框架 & 申请权限

无需额外申请网络权限（默认支持），导入 Network 框架用于获取网络接口：

import Foundation
import Network

步骤 2：获取指定类型的网络接口标识（WiFi / 蜂窝数据）

通过 NWPathMonitor 获取 WiFi 或蜂窝数据对应的接口标识（interfaceIdentifier）：

class NetworkSelector {
    /// 获取指定类型的网络接口标识
    /// - Parameter isWiFi: 是否需要 WiFi 网络（false 为蜂窝数据）
    /// - Completion: 接口标识（无可用网络返回 nil）
    static func getTargetInterfaceIdentifier(isWiFi: Bool, completion: @escaping (String?) -> Void) {
        let monitor = NWPathMonitor()
        let queue = DispatchQueue(label: "com.example.NetworkMonitor")
        
        monitor.pathUpdateHandler = { path in
            // 遍历所有可用网络接口
            for interface in path.availableInterfaces {
                let isTargetInterface = if (isWiFi) {
                    interface.type == .wifi
                } else {
                    interface.type == .cellular
                }
                
                if isTargetInterface {
                    completion(interface.interfaceIdentifier)
                    monitor.cancel()
                    return
                }
            }
            // 无可用目标网络
            completion(nil)
            monitor.cancel()
        }
        
        monitor.start(queue: queue)
    }
}

步骤 3：为 URLSession 请求绑定指定网络接口

通过 URLSessionConfiguration 的 interfaceIdentifier 绑定网络接口，构建专属的 URLSession 实例：

/// 构建绑定指定网络接口的 URLSession
/// - Parameter interfaceIdentifier: 网络接口标识
/// - Returns: 绑定后的 URLSession
func buildBoundURLSession(interfaceIdentifier: String) -> URLSession {
    let configuration = URLSessionConfiguration.ephemeral // 临时配置，不缓存、不持久化
    // 关键：绑定指定网络接口标识
    configuration.interfaceIdentifier = interfaceIdentifier
    // 禁用自动切换网络（确保请求只走绑定的接口）
    configuration.allowsExpensiveNetworkAccess = true
    configuration.allowsConstrainedNetworkAccess = true
    
    return URLSession(configuration: configuration)
}

// 实际使用示例
func sendRequestWithSpecifiedNetwork(urlString: String, isWiFi: Bool, completion: @escaping (Result<String, Error>) -> Void) {
    // 1. 获取目标网络接口标识
    NetworkSelector.getTargetInterfaceIdentifier(isWiFi: isWiFi) { interfaceId in
        guard let interfaceId = interfaceId else {
            completion(.failure(NSError(domain: "NetworkError", code: -1, userInfo: [NSLocalizedDescriptionKey: "无可用的 \(isWiFi ? "WiFi" : "蜂窝数据") 网络"])))
            return
        }
        
        // 2. 构建绑定该网络的 URLSession
        let boundURLSession = buildBoundURLSession(interfaceIdentifier: interfaceId)
        
        // 3. 发起 HTTP 请求
        guard let url = URL(string: urlString) else {
            completion(.failure(NSError(domain: "URLError", code: -2, userInfo: [NSLocalizedDescriptionKey: "无效的 URL"])))
            return
        }
        
        let task = boundURLSession.dataTask(with: url) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let data = data, let responseString = String(data: data, encoding: .utf8) else {
                completion(.failure(NSError(domain: "DataError", code: -3, userInfo: [NSLocalizedDescriptionKey: "响应数据为空"])))
                return
            }
            
            completion(.success(responseString))
        }
        task.resume()
    }
}

步骤 4：接口级别的请求分发

调用时指定网络类型，实现请求 A 走 WiFi、请求 B 走蜂窝数据：

// 请求 A：走 WiFi
sendRequestWithSpecifiedNetwork(urlString: "https://api.example.com/requestA", isWiFi: true) { result in
    switch result {
    case .success(let content):
        print("请求 A 成功：\(content)")
    case .failure(let error):
        print("请求 A 失败：\(error.localizedDescription)")
    }
}

// 请求 B：走蜂窝数据
sendRequestWithSpecifiedNetwork(urlString: "https://api.example.com/requestB", isWiFi: false) { result in
    switch result {
    case .success(let content):
        print("请求 B 成功：\(content)")
    case .failure(let error):
        print("请求 B 失败：\(error.localizedDescription)")
    }
}

四、注意事项 & 常见问题

1. 设备兼容性：
   • Android：需 API 21+（5.0），部分国产机型可能限制「双网同时在线」，需要用户手动开启。
   • iOS：需 iOS 12+，interfaceIdentifier 属性在 iOS 12 及以上支持，且无需用户手动开启双网。
2. 网络可用性检测：发起请求前必须检测目标网络是否可用，避免绑定无效网络导致请求失败。
3. 请求隔离：不同网络的请求必须使用独立的网络客户端实例（OkHttpClient/URLSession），不可共用，否则会出现网络路由混乱。
4. 耗电 & 性能：双网同时请求会增加设备耗电，且网络切换（若有）可能导致请求延迟，建议仅在必要场景使用。
5. HTTPS 兼容性：绑定网络后不影响 HTTPS 证书验证，Android 需确保 SSLSocketFactory 正确委托，iOS 由系统自动处理。

总结

1. 核心实现逻辑是先获取目标网络接口，再为单个请求绑定该接口，而非 App 全局绑定。
2. Android 基于 Network 类 + OkHttp 自定义 SocketFactory 实现，iOS 基于 NWPathMonitor + URLSessionConfiguration.interfaceIdentifier 实现。
3. 关键注意点：保证双网同时在线、使用独立网络客户端实例、提前检测网络可用性。