HttpDelete con el cuerpo
Estoy intentando utilizar un objeto HttpDelete para invocar el método de eliminación de un servicio web. El código del servicio web analiza JSON del cuerpo del mensaje. Sin embargo, no entiendo cómo agregar un cuerpo a un objeto HttpDelete. ¿Hay alguna forma de hacer esto?
Con HttpPut y HttpPost, llamo al método setEntity y paso en mi JSON. No parece haber ningún método para HttpDelete.
- Cancelar la descarga de archivos con httpclient y asynctask
- Utilizar HttpCore + HttpNIO de Apache para HTTP Pipelining en Android?
- Java.net.SocketException: recvfrom falló: ECONNRESET (Conexión restablecida por pares) Más de WIFI
- ¿Cookies compartidas entre WebView y HTTPClient?
- Impresión de Logcat "nombre de la interfaz: null" durante cada llamada al método de ejecución DefaultHttpClient
Si no hay manera de establecer un cuerpo para un objeto HttpDelete, ¿podría por favor vincularme a un recurso que utiliza una superclase de HttpDelete tal que puedo establecer el método (eliminar) y establecer un cuerpo. Sé que no es ideal, pero en este momento no puedo alterar el servicio web.
- Android API 23 - HttpClient 4.X reempaquetado
- La invocación de Apache DefaultHttpClient resulta en "java.lang.RuntimeException: Stub!"
- Httpclient redirecciona android
- Ejemplo de cómo descargar JSON desde el servidor?
- Cómo implementar un servidor HTTP en android
- ¿Cuál debería ser el tiempo de espera de conexión estándar y el tiempo de espera del socket en android
- Android: periódicamente se produce el tiempo de espera de HttpClient
- Android HttpClient no utiliza configuración de proxy del sistema
¿Ha intentado reemplazar HttpEntityEnclosingRequestBase
siguiente manera:
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase; import java.net.URI; import org.apache.http.annotation.NotThreadSafe; @NotThreadSafe class HttpDeleteWithBody extends HttpEntityEnclosingRequestBase { public static final String METHOD_NAME = "DELETE"; public String getMethod() { return METHOD_NAME; } public HttpDeleteWithBody(final String uri) { super(); setURI(URI.create(uri)); } public HttpDeleteWithBody(final URI uri) { super(); setURI(uri); } public HttpDeleteWithBody() { super(); } }
Eso creará un HttpDelete
-lookalike que tiene un método setEntity
. Creo que la clase abstracta hace casi todo por ti, así que eso puede ser todo lo que se necesita.
FWIW, el código se basa en esta fuente a HttpPost que Google apareció .
Siguiendo a Walter Mudnt, puedes usar este código. Funciona, solo lo hizo mientras probaba mi REST webservice.
try { HttpEntity entity = new StringEntity(jsonArray.toString()); HttpClient httpClient = new DefaultHttpClient(); HttpDeleteWithBody httpDeleteWithBody = new HttpDeleteWithBody("http://10.17.1.72:8080/contacts"); httpDeleteWithBody.setEntity(entity); HttpResponse response = httpClient.execute(httpDeleteWithBody); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }
Para acceder a la respuesta simplemente puede hacer: response.getStatusLine();
Hay diferentes interpretaciones en la pregunta de si el cuerpo está permitido o no en la solicitud HTTP DELETE
. Vea esto por ejemplo. En la especificación HTTP 1.1 no se prohíbe explícitamente. En mi opinión, no deberías usar body en el HTTP DELETE
.
Sin embargo, creo que deberías usar URL como mysite/myobject/objectId
( mysite/myobject/objectId
) donde objectId
( una parte de la url ) es la información adicional. Como alternativa, puede utilizar los parámetros URL : mysite/myobject?objectName=table&color=red
para enviar información additipnal al servidor en la solicitud HTTP DELETE
. La parte que comienza con '?' Es el urlencoded parámetros devided dy '&'.
Si desea enviar información más compleja puede convertir los datos a JSON con respecto a DataContractJsonSerializer o JavaScriptSerializer y, a continuación, enviar los datos convertidos (una cadena que myJsonData
más tarde) también como parámetro: mysite/myobject?objectInfo=myJsonData
.
Si necesita enviar demasiados datos adicionales como parte de HTTP DELETE
solicitud HTTP DELETE
para que tenga un problema con la longitud de la URL, probablemente debería cambiar el diseño de su aplicación.
ACTUALIZADO : Iy que desea enviar un cuerpo por HTTP DELETE puede hacer esto por ejemplo como siguiente
// somewhere above add: using System.Net; and using System.IO; WebClient myWebClient = new WebClient (); // 1) version: do simple request string t= myWebClient.UploadString ("http://www.examples.com/", "DELETE", "bla bla"); // will be send following: // // DELETE http://www.examples.com/ HTTP/1.1 // Host: www.examples.com // Content-Length: 7 // Expect: 100-continue // Connection: Keep-Alive // //bla bla // 2) version do complex request Stream stream = myWebClient.OpenWrite ("http://www.examples.com/", "DELETE"); string postData = "bla bla"; byte[] myDataAsBytes = Encoding.UTF8.GetBytes (postData); stream.Write (myDataAsBytes, 0, myDataAsBytes.Length); stream.Close (); // it send the data // will be send following: // // DELETE http://www.examples.com/ HTTP/1.1 // Host: www.examples.com // Content-Length: 7 // Expect: 100-continue // // bla bla // 3) version // create web request HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create ("http://www.examples.com/"); webRequest.Method = "DELETE"; webRequest.ServicePoint.Expect100Continue = false; // post data Stream requestStream = webRequest.GetRequestStream (); StreamWriter requestWriter = new StreamWriter (requestStream); requestWriter.Write (postData); requestWriter.Close (); //wait for server response HttpWebResponse response = (HttpWebResponse)webRequest.GetResponse (); // send following: // DELETE http://www.examples.com/ HTTP/1.1 // Host: www.examples.com // Content-Length: 7 // Connection: Keep-Alive // // bla bla
El código completo podría ser un poco más complejo, pero éste ya funcionará. Sin embargo, sigo diciendo que el servicio web de datos necesarios en el cuerpo de la solicitud DELETE HTTP es mal diseñado.
utilizar esta,
class MyDelete extends HttpPost{ public MyDelete(String url){ super(url); } @Override public String getMethod() { return "DELETE"; } }
En la modernización
import okhttp3.Request; private final class ApiInterceptor implements Interceptor { @Override public Response intercept(Chain chain) throws IOException { Request oldRequest = chain.request(); Request.Builder builder = oldRequest.newBuilder(); if(condition) { return chain.proceed(builder.build().newBuilder().delete(builder.build().body()).build()); } return chain.proceed(builder.build()); } }
Usted tiene que activar la condición, a través de algo y potencialmente tiene que hacer algún filtrado para el url / header / body para eliminar el disparador,
A menos que el url de la cancelación / el cuerpo / el jefe sea bastante único no chocar con las peticiones del poste o de la compra.
- ¿Cuál es la diferencia entre el estado de la red de acceso (ACCESS_NETWORK_STATE) y los permisos de estado WIFI (ACCESS_WIFI_STATE)?
- Apache Commons Codec con Android: no se pudo encontrar el método