solicitudes - ¿Cómo enviar una solicitud POST en JSON usando HTTPClient en Android?
httppost android (5)
Estoy tratando de averiguar cómo POSTAR JSON desde Android utilizando HTTPClient. He estado tratando de resolver esto por un tiempo, he encontrado muchos ejemplos en línea, pero no puedo hacer que ninguno de ellos funcione. Creo que esto se debe a mi falta de conocimientos de JSON / redes en general. Sé que hay muchos ejemplos por ahí, pero ¿alguien podría indicarme un tutorial real? Estoy buscando un proceso paso a paso con el código y la explicación de por qué haces cada paso, o de lo que hace ese paso. No es necesario que sea complicado, simple bastará.
Una vez más, sé que hay un montón de ejemplos, realmente estoy buscando un ejemplo con una explicación de lo que está sucediendo exactamente y por qué lo está haciendo de esa manera.
Si alguien sabe acerca de un buen libro de Android sobre esto, házmelo saber.
Gracias de nuevo por la ayuda @terrance, aquí está el código que describí a continuación
public void shNameVerParams() throws Exception{
String path = //removed
HashMap params = new HashMap();
params.put(new String("Name"), "Value");
params.put(new String("Name"), "Value");
try {
HttpClient.SendHttpPost(path, params);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Aquí hay una solución alternativa a la respuesta de @Terrance. Puede externalizar fácilmente la conversión. La biblioteca Gson hace un trabajo maravilloso convirtiendo varias estructuras de datos en JSON y viceversa.
public static void execute() {
Map<String, String> comment = new HashMap<String, String>();
comment.put("subject", "Using the GSON library");
comment.put("message", "Using libraries is convenient.");
String json = new GsonBuilder().create().toJson(comment, Map.class);
makeRequest("http://192.168.0.1:3000/post/77/comments", json);
}
public static HttpResponse makeRequest(String uri, String json) {
try {
HttpPost httpPost = new HttpPost(uri);
httpPost.setEntity(new StringEntity(json));
httpPost.setHeader("Accept", "application/json");
httpPost.setHeader("Content-type", "application/json");
return new DefaultHttpClient().execute(httpPost);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
Se puede hacer algo similar al usar Jackson lugar de Gson. También recomiendo echar un vistazo a Retrofit que esconde mucho de este código repetitivo para usted. Para desarrolladores más experimentados recomiendo probar RxAndroid .
Demasiado código para esta tarea, revise esta biblioteca https://github.com/kodart/Httpzoid Utiliza GSON internamente y proporciona API que funciona con objetos. Todos los detalles de JSON están ocultos.
Http http = HttpFactory.create(context);
http.get("http://example.com/users")
.handler(new ResponseHandler<User[]>() {
@Override
public void success(User[] users, HttpResponse response) {
}
}).execute();
En esta respuesta, estoy usando un ejemplo publicado por Justin Grammens .
Acerca de JSON
JSON significa Notación de Objeto JavaScript. En las propiedades de JavaScript se puede hacer referencia tanto a este object1.name como a este object[''name'']; . El ejemplo del artículo usa este bit de JSON.
Las partes
Un objeto de ventilador con el correo electrónico como clave y [email protected] como un valor
{
fan:
{
email : ''[email protected]''
}
}
Entonces el objeto equivalente sería fan.email; o fan[''email'']; . Ambos tendrían el mismo valor de ''[email protected]'' .
Acerca de HttpClient Request
Lo siguiente es lo que nuestro autor usó para hacer una Solicitud de HttpClient . No pretendo ser un experto en absoluto, así que si alguien tiene una mejor manera de decir algo de la terminología, siéntase libre.
public static HttpResponse makeRequest(String path, Map params) throws Exception
{
//instantiates httpclient to make request
DefaultHttpClient httpclient = new DefaultHttpClient();
//url with the post data
HttpPost httpost = new HttpPost(path);
//convert parameters into JSON object
JSONObject holder = getJsonObjectFromMap(params);
//passes the results to a string builder/entity
StringEntity se = new StringEntity(holder.toString());
//sets the post request as the resulting string
httpost.setEntity(se);
//sets a request header so the page receving the request
//will know what to do with it
httpost.setHeader("Accept", "application/json");
httpost.setHeader("Content-type", "application/json");
//Handles what is returned from the page
ResponseHandler responseHandler = new BasicResponseHandler();
return httpclient.execute(httpost, responseHandler);
}
Mapa
Si no está familiarizado con la estructura de datos de Map , consulte la referencia de Java Map . En resumen, un mapa es similar a un diccionario o hash.
private static JSONObject getJsonObjectFromMap(Map params) throws JSONException {
//all the passed parameters from the post request
//iterator used to loop through all the parameters
//passed in the post request
Iterator iter = params.entrySet().iterator();
//Stores JSON
JSONObject holder = new JSONObject();
//using the earlier example your first entry would get email
//and the inner while would get the value which would be ''[email protected]''
//{ fan: { email : ''[email protected]'' } }
//While there is another entry
while (iter.hasNext())
{
//gets an entry in the params
Map.Entry pairs = (Map.Entry)iter.next();
//creates a key for Map
String key = (String)pairs.getKey();
//Create a new map
Map m = (Map)pairs.getValue();
//object for storing Json
JSONObject data = new JSONObject();
//gets the value
Iterator iter2 = m.entrySet().iterator();
while (iter2.hasNext())
{
Map.Entry pairs2 = (Map.Entry)iter2.next();
data.put((String)pairs2.getKey(), (String)pairs2.getValue());
}
//puts email and ''[email protected]'' together in map
holder.put(key, data);
}
return holder;
}
Por favor, siéntete libre de comentar cualquier pregunta que surja sobre este post o si no he dejado algo claro o si no he tocado algo que aún te confunde ... etc., Lo que sea que surja realmente en tu cabeza.
(Destruiré si Justin Grammens no aprueba. Pero si no, entonces, gracias a Justin por ser bueno al respecto).
Actualizar
Acabo de pasar para obtener un comentario sobre cómo usar el código y me di cuenta de que había un error en el tipo de devolución. La firma del método estaba configurada para devolver una cadena, pero en este caso no devolvía nada. Cambié la firma a HttpResponse y lo referiré a este enlace en Getting Response Body of HttpResponse. La variable de ruta es la url y la actualicé para corregir un error en el código.
Hay dos formas de establecer la conexión HHTP y obtener datos de un servicio web RESTFULL. El más reciente es GSON. Pero antes de continuar con GSON debe tener alguna idea de la forma más tradicional de crear un cliente HTTP y realizar la comunicación de datos con un servidor remoto. He mencionado ambos métodos para enviar solicitudes POST y GET usando HTTPClient.
/**
* This method is used to process GET requests to the server.
*
* @param url
* @return String
* @throws IOException
*/
public static String connect(String url) throws IOException {
HttpGet httpget = new HttpGet(url);
HttpResponse response;
HttpParams httpParameters = new BasicHttpParams();
// Set the timeout in milliseconds until a connection is established.
// The default value is zero, that means the timeout is not used.
int timeoutConnection = 60*1000;
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
// Set the default socket timeout (SO_TIMEOUT)
// in milliseconds which is the timeout for waiting for data.
int timeoutSocket = 60*1000;
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
HttpClient httpclient = new DefaultHttpClient(httpParameters);
try {
response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream instream = entity.getContent();
result = convertStreamToString(instream);
//instream.close();
}
}
catch (ClientProtocolException e) {
Utilities.showDLog("connect","ClientProtocolException:-"+e);
} catch (IOException e) {
Utilities.showDLog("connect","IOException:-"+e);
}
return result;
}
/**
* This method is used to send POST requests to the server.
*
* @param URL
* @param paramenter
* @return result of server response
*/
static public String postHTPPRequest(String URL, String paramenter) {
HttpParams httpParameters = new BasicHttpParams();
// Set the timeout in milliseconds until a connection is established.
// The default value is zero, that means the timeout is not used.
int timeoutConnection = 60*1000;
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
// Set the default socket timeout (SO_TIMEOUT)
// in milliseconds which is the timeout for waiting for data.
int timeoutSocket = 60*1000;
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
HttpClient httpclient = new DefaultHttpClient(httpParameters);
HttpPost httppost = new HttpPost(URL);
httppost.setHeader("Content-Type", "application/json");
try {
if (paramenter != null) {
StringEntity tmp = null;
tmp = new StringEntity(paramenter, "UTF-8");
httppost.setEntity(tmp);
}
HttpResponse httpResponse = null;
httpResponse = httpclient.execute(httppost);
HttpEntity entity = httpResponse.getEntity();
if (entity != null) {
InputStream input = null;
input = entity.getContent();
String res = convertStreamToString(input);
return res;
}
}
catch (Exception e) {
System.out.print(e.toString());
}
return null;
}
Recomiendo usar este HttpURLConnection lugar de HttpGet . Como HttpGet ya está en desuso en Android API nivel 22.
HttpURLConnection httpcon;
String url = null;
String data = null;
String result = null;
try {
//Connect
httpcon = (HttpURLConnection) ((new URL (url).openConnection()));
httpcon.setDoOutput(true);
httpcon.setRequestProperty("Content-Type", "application/json");
httpcon.setRequestProperty("Accept", "application/json");
httpcon.setRequestMethod("POST");
httpcon.connect();
//Write
OutputStream os = httpcon.getOutputStream();
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
writer.write(data);
writer.close();
os.close();
//Read
BufferedReader br = new BufferedReader(new InputStreamReader(httpcon.getInputStream(),"UTF-8"));
String line = null;
StringBuilder sb = new StringBuilder();
while ((line = br.readLine()) != null) {
sb.append(line);
}
br.close();
result = sb.toString();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}