Atualmente, existem dois métodos principais em Java para implementar requisições HTTP:

Um deles utiliza o framework de código aberto HttpClient. Esta biblioteca oferece uma boa abstração do protocolo HTTP, atendendo à maioria das necessidades de desenvolvimento. A versão 3.1 do HttpClient, localizada em org.apache.commons.httpclient, é uma ferramenta para manipular URLs remotas, embora não receba mais atualizações. Muitos projetos ainda utilizam código baseado nesta versão. Por outro lado, a versão 4.5, encontrada em org.apache.http.client, é a mais recente e recomendada para novos projetos.

O outro método utiliza HttpURLConnection, uma classe padrão da plataforma Java, representando uma implementação nativa mais básica.

Primeiro método: HttpURLConnection nativo do Java

package com.requisicoes.http;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

public class RequisitorHttp {
    public static String executarGet(String enderecoHttp) {
        conexaoHttp conexao = null;
        fluxoEntrada entrada = null;
        leitorBufferizado leitor = null;
        String resultado = null;
        
        try {
            // Criar objeto de URL remota
            URL url = new URL(enderecoHttp);
            // Abrir conexão e converter para HttpURLConnection
            conexao = (HttpURLConnection) url.openConnection();
            // Definir método de requisição como GET
            conexao.setRequestMethod("GET");
            // Configurar timeout de conexão: 15000ms
            conexao.setConnectTimeout(15000);
            // Configurar timeout de leitura: 60000ms
            conexao.setReadTimeout(60000);
            // Enviar requisição
            conexao.connect();
            // Obter fluxo de entrada através da conexão
            if (conexao.getResponseCode() == 200) {
                entrada = conexao.getInputStream();
                // Empacotar fluxo de entrada com codificação UTF-8
                leitor = new BufferedReader(new InputStreamReader(entrada, "UTF-8"));
                // Armazenar dados
                StringBuilder acumulador = new StringBuilder();
                String linha = null;
                while ((linha = leitor.readLine()) != null) {
                    acumulador.append(linha);
                    acumulador.append("\r\n");
                }
                resultado = acumulador.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != leitor) {
                try {
                    leitor.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (null != entrada) {
                try {
                    entrada.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            conexao.disconnect();
        }

        return resultado;
    }

    public static String executarPost(String enderecoHttp, String parametros) {
        conexaoHttp conexao = null;
        fluxoEntrada entrada = null;
        fluxoSaida saida = null;
        leitorBufferizado leitor = null;
        String resultado = null;
        
        try {
            URL url = new URL(enderecoHttp);
            // Abrir conexão com URL remota
            conexao = (HttpURLConnection) url.openConnection();
            // Definir método de requisição como POST
            conexao.setRequestMethod("POST");
            // Configurar timeout de conexão: 15000ms
            conexao.setConnectTimeout(15000);
            // Configurar timeout de leitura: 60000ms
            conexao.setReadTimeout(60000);

            // Habilitar envio de dados (padrão: false)
            conexao.setDoOutput(true);
            // Habilitar recebimento de dados (padrão: true)
            conexao.setDoInput(true);
            // Definir formato dos parâmetros enviados
            conexao.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // Configurar informações de autenticação
            conexao.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // Obter fluxo de saída através da conexão
            saida = conexao.getOutputStream();
            // Escrever parâmetros via fluxo de saída
            saida.write(parametros.getBytes());
            // Obter fluxo de entrada para resposta remota
            if (conexao.getResponseCode() == 200) {
                entrada = conexao.getInputStream();
                // Empacotar fluxo de entrada com codificação UTF-8
                leitor = new BufferedReader(new InputStreamReader(entrada, "UTF-8"));

                StringBuilder acumulador = new StringBuilder();
                String linha = null;
                // Ler dados linha por linha
                while ((linha = leitor.readLine()) != null) {
                    acumulador.append(linha);
                    acumulador.append("\r\n");
                }
                resultado = acumulador.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != leitor) {
                try {
                    leitor.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != saida) {
                try {
                    saida.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != entrada) {
                try {
                    entrada.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // Desconectar da URL remota
            conexao.disconnect();
        }
        return resultado;
    }
}

Segundo método: Apache HttpClient 3.1 (obsoleto)

package com.requisicoes.http;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;

public class RequisitorHttpClient3 {

    public static String executarGet(String url) {
        // Fluxo de entrada
        InputStream entrada = null;
        BufferedReader leitor = null;
        String resultado = null;
        // Criar instância do httpClient
        HttpClient httpClient = new HttpClient();
        // Configurar timeout de conexão: 15000ms
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
        // Criar instância do método Get
        GetMethod metodoGet = new GetMethod(url);
        // Configurar timeout da requisição GET: 60000ms
        metodoGet.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
        // Configurar mecanismo de retry (padrão: 3 tentativas)
        metodoGet.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(3, true));
        try {
            // Executar método Get
            int statusResposta = httpClient.executeMethod(metodoGet);
            // Verificar código de status
            if (statusResposta != HttpStatus.SC_OK) {
                // Se o status não for OK, falhou
                System.err.println("Método falhou: " + metodoGet.getStatusLine());
            } else {
                // Obter fluxo de resposta
                entrada = metodoGet.getResponseBodyAsStream();
                // Empacotar fluxo de entrada
                leitor = new BufferedReader(new InputStreamReader(entrada, "UTF-8"));

                StringBuilder acumulador = new StringBuilder();
                // Ler dados do fluxo empacotado
                String linha = null;
                while ((linha = leitor.readLine()) != null) {
                    acumulador.append(linha).append("\r\n");
                }

                resultado = acumulador.toString();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != leitor) {
                try {
                    leitor.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != entrada) {
                try {
                    entrada.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // Liberar conexão
            metodoGet.releaseConnection();
        }
        return resultado;
    }

    public static String executarPost(String url, Map<String, Object> mapaParametros) {
        // Obter fluxo de entrada
        InputStream entrada = null;
        BufferedReader leitor = null;
        String resultado = null;
        // Criar instância do httpClient
        HttpClient httpClient = new HttpClient();
        // Configurar timeout de conexão: 15000ms
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
        // Criar instância do método POST
        PostMethod metodoPost = new PostMethod(url);
        // Configurar timeout da requisição POST
        metodoPost.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);

        NameValuePair[] paresNomeValor = null;
        // Verificar se o mapa de parâmetros está vazio
        if (null != mapaParametros && mapaParametros.size() > 0) {
            // Criar array de pares nome-valor
            paresNomeValor = new NameValuePair[mapaParametros.size()];
            // Iterar sobre o mapa de parâmetros
            Set<Entry<String, Object>> conjuntoEntradas = mapaParametros.entrySet();
            Iterator<Entry<String, Object>> iterador = conjuntoEntradas.iterator();

            int indice = 0;
            while (iterador.hasNext()) {
                Entry<String, Object> entradaMapa = iterador.next();
                // Criar pares nome-valor e adicionar ao array
                try {
                    paresNomeValor[indice] = new NameValuePair(entradaMapa.getKey(),
                            new String(entradaMapa.getValue().toString().getBytes("UTF-8"), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                indice++;
            }
        }
        // Verificar se o array de pares não é nulo
        if (null != paresNomeValor && paresNomeValor.length > 0) {
            // Adicionar parâmetros ao corpo da requisição
            metodoPost.setRequestBody(paresNomeValor);
        }
        // Executar método POST
        try {
            int statusResposta = httpClient.executeMethod(metodoPost);
            // Verificar se foi bem-sucedido
            if (statusResposta != HttpStatus.SC_OK) {
                System.err.println("Método falhou: " + metodoPost.getStatusLine());
            }
            // Obter dados da resposta remota
            entrada = metodoPost.getResponseBodyAsStream();
            // Empacotar fluxo de entrada
            leitor = new BufferedReader(new InputStreamReader(entrada, "UTF-8"));

            StringBuilder acumulador = new StringBuilder();
            String linha = null;
            while ((linha = leitor.readLine()) != null) {
                acumulador.append(linha).append("\r\n");
            }

            resultado = acumulador.toString();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != leitor) {
                try {
                    leitor.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != entrada) {
                try {
                    entrada.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // Liberar conexão
            metodoPost.releaseConnection();
        }
        return resultado;
    }
}

Terceiro método: Apache HttpClient 4.5

package com.requisicoes.http;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class RequisitorHttpClient4 {

    public static String executarGet(String url) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse resposta = null;
        String resultado = "";
        try {
            // Criar instância httpClient com configuração padrão
            httpClient = HttpClients.createDefault();
            // Criar instância de conexão HTTP GET
            HttpGet httpGet = new HttpGet(url);
            // Configurar cabeçalhos de requisição, incluindo autenticação
            httpGet.setHeader("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // Configurar parâmetros da requisição
            RequestConfig configuracaoRequisicao = RequestConfig.custom()
                    .setConnectTimeout(35000) // Timeout de conexão
                    .setConnectionRequestTimeout(35000) // Timeout de requisição
                    .setSocketTimeout(60000) // Timeout de leitura
                    .build();
            // Aplicar configuração ao método GET
            httpGet.setConfig(configuracaoRequisicao);
            // Executar requisição GET e obter resposta
            resposta = httpClient.execute(httpGet);
            // Obter dados da resposta
            HttpEntity entidade = resposta.getEntity();
            // Converter resultado para string
            resultado = EntityUtils.toString(entidade);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != resposta) {
                try {
                    resposta.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return resultado;
    }

    public static String executarPost(String url, Map<String, Object> mapaParametros) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse respostaHttp = null;
        String resultado = "";
        // Criar instância httpClient
        httpClient = HttpClients.createDefault();
        // Criar instância de conexão HTTP POST
        HttpPost httpPost = new HttpPost(url);
        // Configurar parâmetros da requisição
        RequestConfig configuracaoRequisicao = RequestConfig.custom()
                .setConnectTimeout(35000) // Timeout de conexão
                .setConnectionRequestTimeout(35000) // Timeout de requisição
                .setSocketTimeout(60000) // Timeout de leitura
                .build();
        // Aplicar configuração ao método POST
        httpPost.setConfig(configuracaoRequisicao);
        // Configurar cabeçalhos
        httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
        // Empacotar parâmetros da requisição POST
        if (null != mapaParametros && mapaParametros.size() > 0) {
            List<NameValuePair> paresNomeValor = new ArrayList<NameValuePair>();
            // Iterar sobre o mapa de parâmetros
            Set<Entry<String, Object>> conjuntoEntradas = mapaParametros.entrySet();
            Iterator<Entry<String, Object>> iterador = conjuntoEntradas.iterator();
            while (iterador.hasNext()) {
                Entry<String, Object> entradaMapa = iterador.next();
                paresNomeValor.add(new BasicNameValuePair(entradaMapa.getKey(), entradaMapa.getValue().toString()));
            }

            // Adicionar parâmetros empacotados à requisição POST
            try {
                httpPost.setEntity(new UrlEncodedFormEntity(paresNomeValor, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        try {
            // Executar requisição POST e obter resposta
            respostaHttp = httpClient.execute(httpPost);
            // Obter conteúdo da resposta
            HttpEntity entidade = respostaHttp.getEntity();
            resultado = EntityUtils.toString(entidade);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // Fechar recursos
            if (null != respostaHttp) {
                try {
                    respostaHttp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return resultado;
    }
}

Em algumas situações, ao usar requisições POST, os parâmetros podem estar em formato JSON ou outros tipos de dados. Nesses casos, precisamos modificar as configurações de cabeçalho e parâmetros.

**Para o HttpClient 4.5, por exemplo, podemos alterar as seguintes configurações:****httpPost.setEntity(new StringEntity("seu JSON aqui"));**httpPost.addHeader("Content-Type", "application/json")