A menos que tenga una razón explícita para elegir Apache HttpClient, debería preferir java.net.URLConnection. puede encontrar muchos ejemplos de cómo usarlo en la web.

También hemos mejorado la documentación de Android desde tu publicación original: http://developer.android.com/reference/java/net/HttpURLConnection.html

Y hemos hablado de las compensaciones en el blog oficial: http://android-developers.blogspot.com/2011/09/androids-http-clients.html

Nota: El cliente HTTP Apache incluido con Android ahora está en desuso a favor de HttpURLConnection. Consulta el Blog de Desarrolladores de Android para obtener más detalles.

Añade <uses-permission android:name="android.permission.INTERNET" /> a tu manifiesto.

Entonces recuperarías una página web así:

URL url = new URL("http://www.android.com/");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
try {
     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
}
finally {
     urlConnection.disconnect();
}

También sugiero ejecutarlo en un hilo separado:

class RequestTask extends AsyncTask<String, String, String>{

@Override
protected String doInBackground(String... uri) {
    String responseString = null;
    try {
        URL url = new URL(myurl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        if(conn.getResponseCode() == HttpsURLConnection.HTTP_OK){
            // Do normal input or output stream reading
        }
        else {
            response = "FAILED"; // See documentation for more info on response handling
        }
    } catch (ClientProtocolException e) {
        //TODO Handle problems..
    } catch (IOException e) {
        //TODO Handle problems..
    }
    return responseString;
}

@Override
protected void onPostExecute(String result) {
    super.onPostExecute(result);
    //Do anything with response..
}
}

Consulte la documentación para obtener más información sobre el manejo de respuestas y las solicitudes POST.

La forma más sencilla es usar la lib Android llamada Volley

Volley ofrece los siguientes beneficios:

Programación automática de solicitudes de red. Red concurrente múltiple conexiones. Almacenamiento en caché de respuesta de disco y memoria transparente con coherencia estándar de la caché HTTP. Soporte para priorización de solicitudes. API de solicitud de cancelación. Puede cancelar una sola solicitud, o puede establecer bloques o ámbitos de solicitudes para cancelar. Facilidad de personalización, para ejemplo, para reintentar y retroceder. Fuerte pedido que hace que sea fácil de rellene correctamente su interfaz de usuario con datos obtenidos de forma asíncrona desde el red. Herramientas de depuración y rastreo.

Puede enviar una solicitud http/https tan simple como esto:

        // Instantiate the RequestQueue.
        RequestQueue queue = Volley.newRequestQueue(this);
        String url ="http://www.yourapi.com";
        JsonObjectRequest request = new JsonObjectRequest(url, null,
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if (null != response) {
                         try {
                             //handle your response
                         } catch (JSONException e) {
                             e.printStackTrace();
                         }
                    }
                }
            }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {

            }
        });
        queue.add(request);

En este caso, no necesita considerar "correr en segundo plano" o "usar caché", ya que Volley ya ha hecho todo esto.

private String getToServer(String service) throws IOException {
    HttpGet httpget = new HttpGet(service);
    ResponseHandler<String> responseHandler = new BasicResponseHandler();
    return new DefaultHttpClient().execute(httpget, responseHandler);

}

Saludos

Con un hilo:

private class LoadingThread extends Thread {
    Handler handler;

    LoadingThread(Handler h) {
        handler = h;
    }
    @Override
    public void run() {
        Message m = handler.obtainMessage();
        try {
            BufferedReader in = 
                new BufferedReader(new InputStreamReader(url.openStream()));
            String page = "";
            String inLine;

            while ((inLine = in.readLine()) != null) {
                page += inLine;
            }

            in.close();
            Bundle b = new Bundle();
            b.putString("result", page);
            m.setData(b);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        handler.sendMessage(m);
    }
}

Mira esta nueva biblioteca impresionante que está disponible a través de gradle:)

Construir.gradle: compile 'com.apptakk.http_request:http-request:0.1.2'

Uso:

new HttpRequestTask(
    new HttpRequest("http://httpbin.org/post", HttpRequest.POST, "{ \"some\": \"data\" }"),
    new HttpRequest.Handler() {
      @Override
      public void response(HttpResponse response) {
        if (response.code == 200) {
          Log.d(this.getClass().toString(), "Request successful!");
        } else {
          Log.e(this.getClass().toString(), "Request unsuccessful: " + response);
        }
      }
    }).execute();

Https://github.com/erf/http-request

Hice esto para un webservice a requerst en URL, usando una lib Gson:

Cliente:

public EstabelecimentoList getListaEstabelecimentoPorPromocao(){

        EstabelecimentoList estabelecimentoList  = new EstabelecimentoList();
        try{
            URL url = new URL("http://" +  Conexao.getSERVIDOR()+ "/cardapio.online/rest/recursos/busca_estabelecimento_promocao_android");
            HttpURLConnection con = (HttpURLConnection) url.openConnection();

            if (con.getResponseCode() != 200) {
                    throw new RuntimeException("HTTP error code : "+ con.getResponseCode());
            }

            BufferedReader br = new BufferedReader(new InputStreamReader((con.getInputStream())));
            estabelecimentoList = new Gson().fromJson(br, EstabelecimentoList.class);
            con.disconnect();

        } catch (IOException e) {
            e.printStackTrace();
        }
        return estabelecimentoList;
}

Este es el nuevo código para la solicitud HTTP Get/POST en android. HTTPClient está depricated y puede no estar disponible como estaba en mi caso.

Primero agregue las dos dependencias en build.gradle:

compile 'org.apache.httpcomponents:httpcore:4.4.1'
compile 'org.apache.httpcomponents:httpclient:4.5'

Luego escribe este código en ASyncTask en el método doBackground.

 URL url = new URL("http://localhost:8080/web/get?key=value");
 HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
 urlConnection.setRequestMethod("GET");
 int statusCode = urlConnection.getResponseCode();
 if (statusCode ==  200) {
      InputStream it = new BufferedInputStream(urlConnection.getInputStream());
      InputStreamReader read = new InputStreamReader(it);
      BufferedReader buff = new BufferedReader(read);
      StringBuilder dta = new StringBuilder();
      String chunks ;
      while((chunks = buff.readLine()) != null)
      {
         dta.append(chunks);
      }
 }
 else
 {
     //Handle else
 }

Para mí, la forma más fácil es usar la biblioteca llamada Retrofit2

Solo necesitamos crear una Interfaz que contenga nuestro método de solicitud, parámetros, y también podemos hacer encabezado personalizado para cada solicitud :

    public interface MyService {

      @GET("users/{user}/repos")
      Call<List<Repo>> listRepos(@Path("user") String user);

      @GET("user")
      Call<UserDetails> getUserDetails(@Header("Authorization") String   credentials);

      @POST("users/new")
      Call<User> createUser(@Body User user);

      @FormUrlEncoded
      @POST("user/edit")
      Call<User> updateUser(@Field("first_name") String first, 
                            @Field("last_name") String last);

      @Multipart
      @PUT("user/photo")
      Call<User> updateUser(@Part("photo") RequestBody photo, 
                            @Part("description") RequestBody description);

      @Headers({
        "Accept: application/vnd.github.v3.full+json",
        "User-Agent: Retrofit-Sample-App"
      })
      @GET("users/{username}")
      Call<User> getUser(@Path("username") String username);    

    }

Y lo mejor es que podemos hacerlo de forma asíncrona fácilmente usando el método enqueue

Como ninguna de las respuestas describía una forma de realizar solicitudes con OkHttp , que es un cliente http muy popular hoy en día para Android y Java en general, voy a proporcionar un ejemplo simple:

//get an instance of the client
OkHttpClient client = new OkHttpClient();

//add parameters
HttpUrl.Builder urlBuilder = HttpUrl.parse("https://www.example.com").newBuilder();
urlBuilder.addQueryParameter("query", "stack-overflow");


String url = urlBuilder.build().toString();

//build the request
Request request = new Request.Builder().url(url).build();

//execute
Response response = client.newCall(request).execute();

La clara ventaja de esta biblioteca es que nos abstrae de algunos detalles de bajo nivel, proporcionando formas más amigables y seguras de interactuar con ellos. La sintaxis también se simplifica y permite escribir código agradable.