Java 如何区分没有internet连接时引发的异常与没有可用服务器/或错误url时引发的异常？

我有这个

when（kotlin）

/

switch case（java）

，它为我的请求获取

java.net

异常。问题在于，在两种情况下，它抛出了

UnknownHostException

：

当我没有联系的时候

当我插入一个断开的url时（这相当于服务器完全不可用）

如果这两种情况抛出相同的异常，我如何区分它们？我应该在每次请求之前检查用户的连接吗

何时/尝试接球

            is SocketTimeoutException -> {
                 //Server takes too long to respond
            }
            is UnknownHostException -> {
                 //No connection and broken url / no server at all
            }
            is HttpException -> {
                 //server error response
            }
            else -> {
                 //Any other case
            }

---

在谷歌搜索和浏览了一些文章后，我认为最好的方法是检查客户是否已经连接到互联网

方法1

方法2

方法3

我还没有测试过它们，但它们都是有意义的，坦率地说，我会从第三名到第一名。越简单越好

---

希望它会成功

您需要在OkHttpClient中创建一个类似拦截器的异常：
在OkHttpClient中： .addInterceptor（连接Interceptor（上下文））

你用在什么时候

---

我认为最好的做法是在执行请求之前检查是否存在连接，这将完全消除这种可能性。我知道我可以在发出请求之前调用这种函数来检查连接。我想为这种错误获取一个例外。

public static boolean isNetworkAvailable (Context context) {  
    if (connectedToTheNetwork(context)) {
        try {
            HttpURLConnection urlc = (HttpURLConnection) 
                (new URL("http://clients3.google.com/generate_204")
                .openConnection());
            urlc.setRequestProperty("User-Agent", "Android");
            urlc.setRequestProperty("Connection", "close");
            urlc.setConnectTimeout(1500); 
            urlc.connect();
            return (urlc.getResponseCode() == 204 &&
                        urlc.getContentLength() == 0);
        } catch (IOException e) {
            Log.e(TAG, "Error checking internet connection", e);
        }
    } else {
        Log.d(TAG, "No network available!");
    }
    return false;
}

 fun verifyAvailableNetwork(activity:AppCompatActivity):Boolean{
      val connectivityManager=activity.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
      val networkInfo=connectivityManager.activeNetworkInfo
      return  networkInfo!=null && networkInfo.isConnected
}

val Context.isConnected: Boolean
    get() {
        return (getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager)
           .activeNetworkInfo?.isConnected == true
    }

class ConnectivityInterceptor(private val mContext: Context) : Interceptor {
    @Throws(IOException::class)
    override fun intercept(chain: Chain): Response {
        if (!NetworkUtil.isOnline(mContext)) {
            throw NoInternet()
        }
        val builder = chain.request().newBuilder()
        return chain.proceed(builder.build())
    }

}


class NoInternet : IOException() {

    override val message: String?
        get() {
            return "No connectivity exception"
        }

}

class NetworkUtil {
    companion object {
        fun isOnline(context: Context): Boolean {
            var result = false
            val connectivityManager =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                val networkCapabilities = connectivityManager.activeNetwork ?: return false
                val actNw =
                    connectivityManager.getNetworkCapabilities(networkCapabilities) ?: return false
                result = when {
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
                    actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> true
                    else -> false
                }
            } else {
                connectivityManager.run {
                    connectivityManager.activeNetworkInfo?.run {
                        result = when (type) {
                            ConnectivityManager.TYPE_WIFI -> true
                            ConnectivityManager.TYPE_MOBILE -> true
                            ConnectivityManager.TYPE_ETHERNET -> true
                            else -> false
                        }
                    }
                }
            }
            return result
        }
    }
}

       is NoInternet -> {
}