Leggi il corpo della risposta all'errore in Java

In Java, questo codice genera un'eccezione quando il risultato HTTP è l'intervallo 404:

URL url = new URL("http://stackoverflow.com/asdf404notfound");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.getInputStream(); // throws!

Nel mio caso, so che il contenuto è 404, ma mi piacerebbe comunque leggere il corpo della risposta.

(Nel mio caso reale il codice di risposta è 403, ma il corpo della risposta spiega il motivo del rifiuto e vorrei mostrarlo all'utente.)

Come posso accedere al corpo della risposta?

Ecco il bug report (chiudere, non risolverà, non un bug).

Il loro consiglio è di codificare in questo modo:

HttpURLConnection httpConn = (HttpURLConnection)_urlConnection;
InputStream _is;
if (httpConn.getResponseCode() < HttpURLConnection.HTTP_BAD_REQUEST) {
    _is = httpConn.getInputStream();
} else {
     /* error from server */
    _is = httpConn.getErrorStream();
}

È lo stesso problema che stavo avendo: HttpUrlConnectionrestituisce FileNotFoundExceptionse provi a leggere il getInputStream()dalla connessione.
Dovresti invece usarlo getErrorStream()quando il codice di stato è maggiore di 400.

Inoltre, fai attenzione poiché non è solo 200 ad essere il codice dello stato di successo, anche 201, 204, ecc. Sono spesso usati come stati di successo.

Ecco un esempio di come sono andato a gestirlo

... connection code code code ...

// Get the response code 
int statusCode = connection.getResponseCode();

InputStream is = null;

if (statusCode >= 200 && statusCode < 400) {
   // Create an InputStream in order to extract the response object
   is = connection.getInputStream();
}
else {
   is = connection.getErrorStream();
}

... callback/response to your handler....

In questo modo, sarai in grado di ottenere la risposta necessaria sia nei casi di successo che in quelli di errore.

Spero che questo ti aiuti!

In .Net hai la proprietà Response della WebException che dà accesso allo stream su un'eccezione. Quindi immagino che questo sia un buon modo per Java, ...

private InputStream dispatch(HttpURLConnection http) throws Exception {
    try {
        return http.getInputStream();
    } catch(Exception ex) {
        return http.getErrorStream();
    }
}

O un'implementazione che ho usato. (Potrebbe essere necessario apportare modifiche per la codifica o altre cose. Funziona nell'ambiente corrente.)

private String dispatch(HttpURLConnection http) throws Exception {
    try {
        return readStream(http.getInputStream());
    } catch(Exception ex) {
        readAndThrowError(http);
        return null; // <- never gets here, previous statement throws an error
    }
}

private void readAndThrowError(HttpURLConnection http) throws Exception {
    if (http.getContentLengthLong() > 0 && http.getContentType().contains("application/json")) {
        String json = this.readStream(http.getErrorStream());
        Object oson = this.mapper.readValue(json, Object.class);
        json = this.mapper.writer().withDefaultPrettyPrinter().writeValueAsString(oson);
        throw new IllegalStateException(http.getResponseCode() + " " + http.getResponseMessage() + "\n" + json);
    } else {
        throw new IllegalStateException(http.getResponseCode() + " " + http.getResponseMessage());
    }
}

private String readStream(InputStream stream) throws Exception {
    StringBuilder builder = new StringBuilder();
    try (BufferedReader in = new BufferedReader(new InputStreamReader(stream))) {
        String line;
        while ((line = in.readLine()) != null) {
            builder.append(line); // + "\r\n"(no need, json has no line breaks!)
        }
        in.close();
    }
    System.out.println("JSON: " + builder.toString());
    return builder.toString();
}

So che questo non risponde direttamente alla domanda, ma invece di utilizzare la libreria di connessione HTTP fornita da Sun, potresti voler dare un'occhiata a Commons HttpClient , che (a mio parere) ha un'API molto più semplice con cui lavorare.

Prima controlla il codice di risposta e poi usa HttpURLConnection.getErrorStream()

InputStream is = null;
if (httpConn.getResponseCode() !=200) {
    is = httpConn.getErrorStream();
} else {
     /* error from server */
    is = httpConn.getInputStream();
}

Il mio codice in esecuzione.

  HttpURLConnection httpConn = (HttpURLConnection) urlConn;    
 if (httpConn.getResponseCode() < HttpURLConnection.HTTP_BAD_REQUEST) {
                        in = new InputStreamReader(urlConn.getInputStream());
                        BufferedReader bufferedReader = new BufferedReader(in);
                        if (bufferedReader != null) {
                            int cp;
                            while ((cp = bufferedReader.read()) != -1) {
                                sb.append((char) cp);
                            }
                            bufferedReader.close();
                        }
                            in.close();

                    } else {
                        /* error from server */
                        in = new InputStreamReader(httpConn.getErrorStream());
                    BufferedReader bufferedReader = new BufferedReader(in);
                    if (bufferedReader != null) {
                        int cp;
                        while ((cp = bufferedReader.read()) != -1) {
                            sb.append((char) cp);
                        }
                        bufferedReader.close();
                    }    
                    in.close();
                    }
                    System.out.println("sb="+sb);

Come leggere il corpo della risposta 404 in java:

Usa la libreria Apache - https://hc.apache.org/httpcomponents-client-4.5.x/httpclient/apidocs/

o Java 11 - https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpClient.html

Lo snippet fornito di seguito utilizza Apache:

import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;

CloseableHttpClient client = HttpClients.createDefault();
CloseableHttpResponse resp = client.execute(new HttpGet(domainName + "/blablablabla.html"));
String response = EntityUtils.toString(resp.getEntity());