java - value - org apache http httpresponse example




Como posso obter um corpo de resposta http como uma string em Java? (8)

Eu sei que costumava haver uma maneira de obtê-lo com o apache commons como documentado aqui: http://hc.apache.org/httpclient-legacy/apidocs/org/apache/commons/httpclient/HttpMethod.html e um exemplo aqui:

http://www.kodejava.org/examples/416.html

mas eu acredito que isso é obsoleto. Existe alguma outra maneira de fazer um pedido HTTP get em java e obter o corpo da resposta como uma string e não um fluxo?


A resposta de McDowell está correta. No entanto, se você tentar outra sugestão em alguns dos posts acima.

HttpEntity responseEntity = httpResponse.getEntity();
if(responseEntity!=null) {
   response = EntityUtils.toString(responseEntity);
   S.O.P (response);
}

Em seguida, ele fornecerá ilegalStateException informando que o conteúdo já está sendo consumido.


A seguir, o snippet de código que mostra uma maneira melhor de manipular o corpo da resposta como String, seja uma resposta válida ou uma resposta de erro para a solicitação HTTP POST:

BufferedReader reader = null;
OutputStream os = null;
String payload = "";
try {
    URL url1 = new URL("YOUR_URL");
    HttpURLConnection postConnection = (HttpURLConnection) url1.openConnection();
    postConnection.setRequestMethod("POST");
    postConnection.setRequestProperty("Content-Type", "application/json");
    postConnection.setDoOutput(true);
    os = postConnection.getOutputStream();
    os.write(eventContext.getMessage().getPayloadAsString().getBytes());
    os.flush();

    String line;
    try{
        reader = new BufferedReader(new InputStreamReader(postConnection.getInputStream()));
    }
    catch(IOException e){
        if(reader == null)
            reader = new BufferedReader(new InputStreamReader(postConnection.getErrorStream()));
    }
    while ((line = reader.readLine()) != null)
        payload += line.toString();
}       
catch (Exception ex) {
            log.error("Post request Failed with message: " + ex.getMessage(), ex);
} finally {
    try {
        reader.close();
        os.close();
    } catch (IOException e) {
        log.error(e.getMessage(), e);
        return null;
    }
}

Aqui está um exemplo de outro projeto simples no qual eu estava trabalhando usando a biblioteca httpclient do Apache:

String response = new String();
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(1);
nameValuePairs.add(new BasicNameValuePair("j", request));
HttpEntity requestEntity = new UrlEncodedFormEntity(nameValuePairs);

HttpPost httpPost = new HttpPost(mURI);
httpPost.setEntity(requestEntity);
HttpResponse httpResponse = mHttpClient.execute(httpPost);
HttpEntity responseEntity = httpResponse.getEntity();
if(responseEntity!=null) {
    response = EntityUtils.toString(responseEntity);
}

basta usar EntityUtils para pegar o corpo da resposta como uma String. muito simples.


Aqui está uma maneira leve de fazer isso:

String responseString = "";
for (int i = 0; i < response.getEntity().getContentLength(); i++) { 
    responseString +=
    Character.toString((char)response.getEntity().getContent().read()); 
}

Com o curso responseString contendo resposta e resposta do website sendo tipo de HttpResponse , retornado por HttpClient.execute(request)


Isso é relativamente simples no caso específico, mas bastante complicado no caso geral.

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet("http://.com/");
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
System.out.println(EntityUtils.getContentMimeType(entity));
System.out.println(EntityUtils.getContentCharSet(entity));

A resposta depende do cabeçalho de resposta HTTP Content-Type .

Esse cabeçalho contém informações sobre a carga útil e pode definir a codificação de dados textuais. Mesmo se você assumir tipos de texto , talvez seja necessário inspecionar o próprio conteúdo para determinar a codificação de caracteres correta. Por exemplo, consulte a especificação do HTML 4 para obter detalhes sobre como fazer isso para esse formato específico.

Uma vez que a codificação é conhecida, um InputStreamReader pode ser usado para decodificar os dados.

Essa resposta depende do servidor fazer a coisa certa - se você quiser lidar com casos em que os cabeçalhos de resposta não correspondem ao documento, ou se as declarações do documento não corresponderem à codificação usada, isso é outro tipo de peixe.


Podemos usar o código abaixo também para obter a resposta HTML em java

import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.HttpResponse;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import org.apache.log4j.Logger;

public static void main(String[] args) throws Exception {
    HttpClient client = new DefaultHttpClient();
    //  args[0] :-  http://hostname:8080/abc/xyz/CheckResponse
    HttpGet request1 = new HttpGet(args[0]);
    HttpResponse response1 = client.execute(request1);
    int code = response1.getStatusLine().getStatusCode();

    try (BufferedReader br = new BufferedReader(new InputStreamReader((response1.getEntity().getContent())));) {
        // Read in all of the post results into a String.
        String output = "";
        Boolean keepGoing = true;
        while (keepGoing) {
            String currentLine = br.readLine();

            if (currentLine == null) {
                keepGoing = false;
            } else {
                output += currentLine;
            }
        }

        System.out.println("Response-->" + output);
    } catch (Exception e) {
        System.out.println("Exception" + e);

    }
}

Você pode usar uma biblioteca de terceiros que envia a solicitação HTTP e manipula a resposta. Um dos produtos conhecidos seria o Apache commons. HTTPClient: HttpClient javadoc , artefato do HttpClient Maven . Há muito menos conhecido, mas muito mais simples, o HTTPClient (parte de uma biblioteca MgntUtils de código aberto escrita por mim): MgntUtils HttpClient javadoc , artefato MgntUtils maven , MgntUtils Github . Usando qualquer uma dessas bibliotecas, você pode enviar sua solicitação REST e receber uma resposta independente do Spring como parte de sua lógica de negócios.


Toda biblioteca em que posso pensar retorna um fluxo. Você pode usar IOUtils.toString() do IO do Apache Commons para ler um InputStream em uma String em uma chamada de método. Por exemplo:

URL url = new URL("http://www.example.com/");
URLConnection con = url.openConnection();
InputStream in = con.getInputStream();
String encoding = con.getContentEncoding();
encoding = encoding == null ? "UTF-8" : encoding;
String body = IOUtils.toString(in, encoding);
System.out.println(body);

Atualização: alterei o exemplo acima para usar a codificação de conteúdo da resposta, se disponível. Caso contrário, o padrão será UTF-8 como melhor palpite, em vez de usar o padrão do sistema local.





apache-commons