example - httppost java

Cómo usar los parámetros con HttpPost

Question

Estoy usando un servicio web RESTfull con este método:

@POST
@Consumes({"application/json"})
@Path("create/")
public void create(String str1, String str2){
System.out.println("value 1 = " + str1);
System.out.println("value 2 = " + str2);
}

En mi aplicación de Android, quiero llamar a este método. Cómo proporciono los valores correctos a los parámetros usando org.apache.http.client.methods.HttpPost;

Me di cuenta de que puedo usar la anotación @HeaderParam y simplemente agregar encabezados al objeto HttpPost. ¿Es esta la manera correcta? Haciéndolo como:

httpPost.setHeader("Accept", "application/json");
httpPost.setHeader("str1", "a value");
httpPost.setHeader("str2", "another value");

El uso del método setEntity en httpPost no funcionará. Solo establece el parámetro str1 con la cadena json. Cuando lo usa como:

JSONObject json = new JSONObject();
json.put("str1", "a value");
json.put("str2", "another value");
HttpEntity e = new StringEntity(json.toString());
httpPost.setEntity(e);
//server output: value 1 = {"str1":"a value","str2":"another value"}

Answer 1

En general, un HTTP POST supone que el contenido del cuerpo contiene una serie de pares clave / valor que se crean (generalmente) mediante un formulario en el lado HTML. No establece los valores usando setHeader, ya que eso no los colocará en el cuerpo del contenido.

Entonces, con su segunda prueba, el problema que tiene aquí es que su cliente no está creando múltiples pares clave / valor, solo creó uno y eso se asignó por defecto al primer argumento en su método.

Hay un par de opciones que puede usar. Primero, podría cambiar su método para aceptar solo un parámetro de entrada, y luego pasar una cadena JSON como lo hace en su segunda prueba. Una vez dentro del método, luego analiza la cadena JSON en un objeto que permitiría el acceso a los campos.

Otra opción es definir una clase que represente los campos de los tipos de entrada y convertirlo en el único parámetro de entrada. Por ejemplo

class MyInput
{
String str1;
String str2;
public MyInput() { }
// getters, setters
}
@POST
@Consumes({"application/json"})
@Path("create/")
public void create(MyInput in){
System.out.println("value 1 = " + in.getStr1());
System.out.println("value 2 = " + in.getStr2());
}

Dependiendo del marco REST que esté utilizando, debería manejar la deserialización de JSON por usted.

La última opción es construir un cuerpo POST que se vea como:

str1=value1&str2=value2

luego agrega algunas anotaciones adicionales a tu método de servidor:

public void create(@QueryParam("str1") String str1,
@QueryParam("str2") String str2)

A @QueryParam no le importa si el campo está en una publicación de formulario o en la URL (como una consulta GET).

Si desea continuar utilizando argumentos individuales en la entrada, la clave es generar la solicitud del cliente para proporcionar parámetros de consulta con nombre, ya sea en la URL (para un GET) o en el cuerpo del POST.

Answer 2

Para establecer parámetros en su HttpPostRequest puede usar BasicNameValuePair , algo como esto:

 HttpClient httpclient;
HttpPost httppost;
ArrayList<NameValuePair> postParameters;
httpclient = new DefaultHttpClient();
httppost = new HttpPost("your login link");
postParameters = new ArrayList<NameValuePair>();
postParameters.add(new BasicNameValuePair("param1", "param1_value"));
postParameters.add(new BasicNameValuePair("param2", "param2_value"));
httpPost.setEntity(new UrlEncodedFormEntity(postParameters, "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);

Answer 3

También puede usar este enfoque en caso de que desee pasar algunos parámetros http y enviar una solicitud json:

(nota: he agregado un código adicional solo en caso de que ayude a otros lectores futuros)

public void postJsonWithHttpParams() throws URISyntaxException, UnsupportedEncodingException, IOException {
//add the http parameters you wish to pass
List<NameValuePair> postParameters = new ArrayList<>();
postParameters.add(new BasicNameValuePair("param1", "param1_value"));
postParameters.add(new BasicNameValuePair("param2", "param2_value"));
//Build the server URI together with the parameters you wish to pass
URIBuilder uriBuilder = new URIBuilder("http://google.ug");
uriBuilder.addParameters(postParameters);
HttpPost postRequest = new HttpPost(uriBuilder.build());
postRequest.setHeader("Content-Type", "application/json");
//this is your JSON string you are sending as a request
String yourJsonString = "{/"str1/":/"a value/",/"str2/":/"another value/"} ";
//pass the json string request in the entity
HttpEntity entity = new ByteArrayEntity(yourJsonString.getBytes("UTF-8"));
postRequest.setEntity(entity);
//create a socketfactory in order to use an http connection manager
PlainConnectionSocketFactory plainSocketFactory = PlainConnectionSocketFactory.getSocketFactory();
Registry<ConnectionSocketFactory> connSocketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", plainSocketFactory)
.build();
PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(connSocketFactoryRegistry);
connManager.setMaxTotal(20);
connManager.setDefaultMaxPerRoute(20);
RequestConfig defaultRequestConfig = RequestConfig.custom()
.setSocketTimeout(HttpClientPool.connTimeout)
.setConnectTimeout(HttpClientPool.connTimeout)
.setConnectionRequestTimeout(HttpClientPool.readTimeout)
.build();
// Build the http client.
CloseableHttpClient httpclient = HttpClients.custom()
.setConnectionManager(connManager)
.setDefaultRequestConfig(defaultRequestConfig)
.build();
CloseableHttpResponse response = httpclient.execute(postRequest);
//Read the response
String responseString = "";
int statusCode = response.getStatusLine().getStatusCode();
String message = response.getStatusLine().getReasonPhrase();
HttpEntity responseHttpEntity = response.getEntity();
InputStream content = responseHttpEntity.getContent();
BufferedReader buffer = new BufferedReader(new InputStreamReader(content));
String line;
while ((line = buffer.readLine()) != null) {
responseString += line;
}
//release all resources held by the responseHttpEntity
EntityUtils.consume(responseHttpEntity);
//close the stream
response.close();
// Close the connection manager.
connManager.close();
}