android - consumir - httppostattribute example

HttpDelete con cuerpo

Question

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 desde el cuerpo del mensaje. Sin embargo, no estoy logrando entender 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 mi JSON. No parece haber ningún método de este tipo para HttpDelete.

Si no hay forma de establecer un cuerpo para un objeto HttpDelete, ¿podría vincularme a un recurso que utiliza una superclase de HttpDelete para poder establecer el método (eliminar) y establecer un cuerpo? Sé que no es ideal, pero en este momento no puedo modificar el servicio web.

Answer 1

Hay diferentes interpretaciones en la pregunta si el cuerpo está permitido o no en la solicitud HTTP DELETE . Mira this por ejemplo. En la especificación HTTP 1.1, no está prohibido 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 usar parámetros de URL : mysite/myobject?objectName=table&color=red para enviar información adicional al servidor en la solicitud HTTP DELETE . La parte que comienza con ''?'' es los parámetros urlencoded divididos dy ''&''.

Si desea enviar información más compleja, puede convertir los datos a JSON con respecto a DataContractJsonSerializer o JavaScriptSerializer y luego enviar los datos convertidos (una cadena que myJsonData más adelante) también como el parámetro: mysite/myobject?objectInfo=myJsonData .

Si necesita enviar demasiados datos adicionales como parte de HTTP DELETE solicitud HTTP DELETE para que tenga problemas con la longitud de la URL, probablemente debería cambiar el diseño de su aplicación.

ACTUALIZADO : Si quieres enviar un cuerpo por HTTP DELETE, puedes hacer esto por ejemplo, como lo 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 este ya funcionará. Sin embargo, sigo diciendo que el servicio web necesitaba datos en el cuerpo de la solicitud HTTP DELETE mal diseñados.

Answer 2

Siguiendo los consejos de Walter Mudnt, puedes usar este código. Funciona, lo hice mientras probaba mi servicio web REST.

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();

Answer 3

en retroadaptació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());
}
}

tienes que desencadenar una condición, a través de algo y posiblemente tienes que hacer algún tipo de filtrado para la url / cabecera / cuerpo para eliminar el activador,

a menos que la URL eliminada / cuerpo / encabezado sea lo suficientemente única como para no colisionar con la publicación o recibir solicitudes.

Answer 4

utilizar esta,

class MyDelete extends HttpPost{
public MyDelete(String url){
super(url);
}
@Override
public String getMethod() {
return "DELETE";
}
}

Answer 5

¿Has intentado anular 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, por lo que puede ser todo lo que se necesita.

FWIW, el código se basa en esta fuente para HttpPost que apareció Google .