java - httppost - Necesito una opción alternativa a HttpClient en Android para enviar datos a PHP ya que ya no es compatible

httpclient post json java

Question

Actualmente estoy usando HttpClient , HttpPost para enviar datos a mi PHP server desde una Android app pero todos esos métodos fueron desaprobados en la API 22 y eliminados en la API 23, ¿cuáles son las opciones alternativas?

Busqué en todas partes pero no encontré nada.

Answer 1

¿Qué cliente es el mejor?

El cliente HTTP Apache tiene menos errores en Eclair y Froyo. Es la mejor opción para estos lanzamientos.

Para Gingerbread y mejores, HttpURLConnection es la mejor opción. Su API simple y su pequeño tamaño lo hacen ideal para Android ...

Consulte here para obtener más información (blog de desarrolladores de Android)

Answer 2

El siguiente código está en una AsyncTask:

En mi proceso de fondo:

String POST_PARAMS = "param1=" + params[0] + "&param2=" + params[1];
URL obj = null;
HttpURLConnection con = null;
try {
    obj = new URL(Config.YOUR_SERVER_URL);
    con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");

    // For POST only - BEGIN
    con.setDoOutput(true);
    OutputStream os = con.getOutputStream();
    os.write(POST_PARAMS.getBytes()); 
    os.flush();
    os.close();
    // For POST only - END

    int responseCode = con.getResponseCode();
    Log.i(TAG, "POST Response Code :: " + responseCode);

    if (responseCode == HttpURLConnection.HTTP_OK) { //success
         BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
         String inputLine;
         StringBuffer response = new StringBuffer();

         while ((inputLine = in.readLine()) != null) {
              response.append(inputLine);
         }
         in.close();

         // print result
            Log.i(TAG, response.toString());
            } else {
            Log.i(TAG, "POST request did not work.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

Referencia: http://www.journaldev.com/7148/java-httpurlconnection-example-to-send-http-getpost-requests

Answer 3

Eres libre de continuar usando HttpClient. Google desaprobó solo su propia versión de los componentes de Apache. Puede instalar una versión nueva, potente y no obsoleta del HttpClient de Apache como describí en esta publicación: https://.com/a/37623038/1727132

Answer 4

Esta es la solución que he aplicado al problema que httpclient desaprobó en esta versión de android 22`

 public static final String USER_AGENT = "Mozilla/5.0";



public static String sendPost(String _url,Map<String,String> parameter)  {
    StringBuilder params=new StringBuilder("");
    String result="";
    try {
    for(String s:parameter.keySet()){
        params.append("&"+s+"=");

            params.append(URLEncoder.encode(parameter.get(s),"UTF-8"));
    }


    String url =_url;
    URL obj = new URL(_url);
    HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();

    con.setRequestMethod("POST");
    con.setRequestProperty("User-Agent", USER_AGENT);
    con.setRequestProperty("Accept-Language", "UTF-8");

    con.setDoOutput(true);
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(con.getOutputStream());
    outputStreamWriter.write(params.toString());
    outputStreamWriter.flush();

    int responseCode = con.getResponseCode();
    System.out.println("/nSending ''POST'' request to URL : " + url);
    System.out.println("Post parameters : " + params);
    System.out.println("Response Code : " + responseCode);

    BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();

    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine + "/n");
    }
    in.close();

        result = response.toString();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (ProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }catch (Exception e) {
        e.printStackTrace();
    }finally {
    return  result;
    }

}

Answer 5

La documentación de HttpClient en la dirección correcta:

org.apache.http.client.HttpClient :

Esta interfaz fue obsoleta en el nivel 22 de la API. Utilice openConnection () en su lugar. Visite esta página web para más detalles.

significa que debe cambiar a java.net.URL.openConnection() .

Así es como puedes hacerlo:

URL url = new URL("http://some-server");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");

// read the response
System.out.println("Response Code: " + conn.getResponseCode());
InputStream in = new BufferedInputStream(conn.getInputStream());
String response = org.apache.commons.io.IOUtils.toString(in, "UTF-8");
System.out.println(response);

Documentación de IOUtils : Apache Commons IO
IOUtils Maven: http://search.maven.org/#artifactdetails|org.apache.commons|commons-io|1.3.2|jar

Answer 6

Puedes usar mi clase personalizada fácil de usar. Simplemente cree un objeto de la clase abstracta (Anónimo) y defina el método onsuccess () y onfail (). https://github.com/creativo123/POSTConnection

Answer 7

También me he encontrado con este problema para resolver que hice mi propia clase. Que se basa en java.net y es compatible con la API 24 de Android, échale un vistazo: HttpRequest.java

Usando esta clase puedes fácilmente:

1. Enviar solicitud HETP GET
2. Enviar POST Http POST
3. Enviar solicitud PUT Http
4. Enviar Http DELETE
5. Enviar solicitud sin parámetros de datos adicionales y verificar el HTTP status code respuesta
6. Agregue HTTP Headers personalizados para solicitar (usando varargs)
7. Agregar parámetros de datos como consulta de String para solicitar
8. Agregue parámetros de datos como HashMap {key = value}
9. Aceptar respuesta como String
10. Aceptar respuesta como JSONObject
11. Aceptar respuesta como byte [] Matriz de bytes (útil para archivos)

y cualquier combinación de esos, solo con una sola línea de código)

Aquí están algunos ejemplos:

//Consider next request: 
HttpRequest req=new HttpRequest("http://host:port/path");

Ejemplo 1 :

//prepare Http Post request and send to "http://host:port/path" with data params name=Bubu and age=29, return true - if worked
req.prepare(HttpRequest.Method.POST).withData("name=Bubu&age=29").send();

Ejemplo 2

// prepare http get request,  send to "http://host:port/path" and read server''s response as String 
req.prepare().sendAndReadString();

Ejemplo 3

// prepare Http Post request and send to "http://host:port/path" with data params name=Bubu and age=29 and read server''s response as JSONObject 
HashMap<String, String>params=new HashMap<>();
params.put("name", "Groot"); 
params.put("age", "29");
req.prepare(HttpRequest.Method.POST).withData(params).sendAndReadJSON();

Ejemplo 4

//send Http Post request to "http://url.com/b.c" in background  using AsyncTask
new AsyncTask<Void, Void, String>(){
        protected String doInBackground(Void[] params) {
            String response="";
            try {
                response=new HttpRequest("http://url.com/b.c").prepare(HttpRequest.Method.POST).sendAndReadString();
            } catch (Exception e) {
                response=e.getMessage();
            }
            return response;
        }
        protected void onPostExecute(String result) {
            //do something with response
        }
    }.execute(); 

Ejemplo 5 :

//Send Http PUT request to: "http://some.url" with request header:
String json="{/"name/":/"Deadpool/",/"age/":40}";//JSON that we need to send
String url="http://some.url";//URL address where we need to send it 
HttpRequest req=new HttpRequest(url);//HttpRequest to url: "http://some.url"
req.withHeaders("Content-Type: application/json");//add request header: "Content-Type: application/json"
req.prepare(HttpRequest.Method.PUT);//Set HttpRequest method as PUT
req.withData(json);//Add json data to request body
JSONObject res=req.sendAndReadJSON();//Accept response as JSONObject

Ejemplo 6

//Equivalent to previous example, but in a shorter way (using methods chaining):
String json="{/"name/":/"Deadpool/",/"age/":40}";//JSON that we need to send
String url="http://some.url";//URL address where we need to send it 
//Shortcut for example 5 complex request sending & reading response in one (chained) line
JSONObject res=new HttpRequest(url).withHeaders("Content-Type: application/json").prepare(HttpRequest.Method.PUT).withData(json).sendAndReadJSON();

Ejemplo 7

//Downloading file
byte [] file = new HttpRequest("http://some.file.url").prepare().sendAndReadBytes();
FileOutputStream fos = new FileOutputStream("smile.png");
fos.write(file);
fos.close();

Answer 8

Tuve problemas similares al usar el método HttpClent y HttpPost ya que no quería cambiar mi código, así que encontré una opción alternativa en el archivo build.gradle (módulo) eliminando ''rc3'' de buildToolsVersion "23.0.1 rc3" y funcionó para mí . Espero que ayude.

Answer 9

si está dirigido a API 22 y versiones anteriores, debería agregar la siguiente línea en build.gradle

dependencies {
    compile group: ''org.apache.httpcomponents'' , name: ''httpclient-android'' , version: ''4.3.5.1''
}

si está dirigido a API 23 y posterior, debería agregar la siguiente línea en build.gradle

dependencies {
    compile group: ''cz.msebera.android'' , name: ''httpclient'', version: ''4.4.1.1''
}

Si aún desea utilizar la biblioteca httpclient, en Android Marshmallow (sdk 23), puede agregar:

useLibrary ''org.apache.http.legacy''

para construir.gradle en la sección de Android {} como solución alternativa. ¡Esto parece ser necesario para algunas de las bibliotecas gms de Google!