Sigueme en Facebook Sigueme en Twitter Sigueme en Instagram Sigueme en Youtube
JC Mouse Bolivia
Index / Android / Métodos GET y POST en RestFul y JSON

Métodos GET y POST en RestFul y JSON

Autor jc mouse jueves, noviembre 27, 2014

En este post veremos como enviar solicitudes GET y POST a un API RestFul  desde un dispositivo con android.

Nuestra aplicación consistirá en un pequeño formulario para escribir un nombre y una edad y enviar estos al servidor quien dará una respuesta (Result:200). Si bien GET se utiliza más que todos para realizar consultas y POST para insertar datos por la cantidad de información que maneja cada uno, GET también puede ser utilizada para enviar pequeña cantidad de datos.

Necesitamos

  • IDE Eclipse con SDK android instalado
  • Conocimientos sobre java, php, json

Si se usara el Emulador android necesitamos:

  • Servidor Local (XAMP,Appserv,etc)

Si se usara un dispositivo físico necesitamos

  • Conexión a internet y un hosting para el api rest

Nivel: Intermedio

Tiempo: 20 minutos

Proyecto en Eclipse

1. ApiRest

Construir un Api REST no esta entre los objetivos de este tutorial, por lo que reduciremos nuestro api de prueba a un archivo PHP que recibirá peticiones GET/ POST y retornara un resultado en formato JSON, el nombre del archivo es “apirest.php” y el código es el siguiente

<?php

if( $_GET )
{
   $data = json_encode($_GET);
   $datares = array( 'Result'=>"200" );
   print ( json_encode( $datares ) );
   saveLog($data,"GET"); 
}
else
{
   $data = file_get_contents("php://input");
   $datares = array( 'Result'=>"200", 'data'=>$data );
   print ( json_encode( $datares ) );
   saveLog($data,"POST");
}

function saveLog($data,$peticion)
{
   $linea = "-------------------------------------------------------------------------------";
   $buffer = $peticion . " :: " .$data . "\r\n" . $linea;

   $file = 'log.txt';

   if (file_exists($file)) {
            $buffer = file_get_contents($file) . "\r\n" . $buffer;
   }
   $success = file_put_contents($file, $buffer);
}
?>

Crea este archivo en tu servidor local o sube a tu hosting, la dirección para acceder a este archivo es de la forma: “http://localhost/api/apirest.php” y lo que hace es procesar peticiones GET o POST darles un formato JSON, guardar en un archivo log.txt y retornar un resultado también en formato JSON de la forma:

{"Result":"200","data":""}

donde Result:200 quiere decir que el proceso se realizo correctamente.

2. Proyecto Android

Crea un nuevo proyecto android en Eclipse que se llamará RestFulGP, a continuación dale la siguiente estructura:

RestFul

Nuestro proyecto contará con:

  • MainActivity: Se crea por defecto al crear el proyecto
  • MyAsyncTask: Clase que nos permitirá realizar una tarea en segundo plano
  • MyRestFulGP: Clase que implementara los métodos necesarios para trabajar con el Api REST

3. Permisos

Necesitamos añadir un permiso de Internet al archivo AndroidManifest.xml, ábrelo y añade:

<uses-permission android:name="android.permission.INTERNET" />

4. Interfaz de usuario

Abre el activity_main.xml y pega el siguiente código:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/LinearLayout1"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/str_name" />

    <EditText
        android:id="@+id/txtName"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:ems="10"
        android:inputType="textPersonName" >

        <requestFocus />
    </EditText>

    <TextView
        android:id="@+id/textView2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="32dp"
        android:text="@string/str_edad" />

    <EditText
        android:id="@+id/txtAge"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:ems="10"
        android:inputType="number" />

    <Button
        android:id="@+id/btnGet"
        android:layout_marginTop="20dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/str_btnGet" />

    <Button
        android:id="@+id/btnPost"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="@string/str_btnPost" />

    <TextView
        android:id="@+id/txtResponse"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text="@string/str_status"
        android:textAppearance="?android:attr/textAppearanceLarge" />

</LinearLayout>

Abre el archivo strings.xml y añade:

<string name="str_name">Nombre completo</string>
<string name="str_edad">Edad</string>
<string name="str_btnGet">Enviar por GET</string>
<string name="str_btnPost">Enviar por Post</string>
<string name="str_status">Status:</string>

Guarda todo y en el diseñador gráfico debes tener algo como esto:

GUI android

Si todo bien continuemos

5. MyRestFulGP

Como dijimos al principio, esta clase nos permite trabajar con el API REST implementando dos métodos uno para GET y otro para POST, el código es pequeño y esta comentado. Lo importante aquí es indicar en la variable HTTP_EVENT la dirección del apirest.php ya sea en local o internet.

package com.bolivia.restfulgp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLEncoder;
import java.util.UUID;

import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.json.JSONException;
import org.json.JSONObject;
import android.util.Log;

public class MyRestFulGP  {

 private final String HTTP_EVENT="http://localhost/api/apirest.php"; 
 private HttpClient httpclient; 

 /**
 * Envia los datos por GET
 * @throws IOException 
 * @throws ClientProtocolException 
 * @throws JSONException 
 * */
 public String addEventGet(String name, String age) throws ClientProtocolException, IOException, JSONException
 {
  httpclient = new DefaultHttpClient();
  //los datos a enviar
  String uuid = UUID.randomUUID().toString();
  name = URLEncoder.encode(name,"UTF-8");
  age = URLEncoder.encode(age,"UTF-8");
  //url, cabecera JSON y ejecuta
  HttpGet httpget = new HttpGet(HTTP_EVENT + "?name="+name+"&age="+age+"&uuid="+uuid );
  httpget.addHeader("Content-Type", "application/json");  
  HttpResponse response = httpclient.execute(httpget);
  //obtiene la respuesta del servidor se transforma a objeto JSON
  String jsonResult = inputStreamToString(response.getEntity().getContent()).toString();   
  JSONObject object = new JSONObject(jsonResult);
  Log.i("jsonResult",jsonResult);  
  if( object.getString("Result").equals("200"))
  {    
   return "Petición GET: Exito";
  } 
  return "Petición GET: Fracaso";
 }

 /**
 * Envia los datos por POST
 * @throws IOException 
 * @throws ClientProtocolException 
 * @throws JSONException
 * */
 public String addEventPost(String name, String age) throws ClientProtocolException, IOException, JSONException
 {
  httpclient = new DefaultHttpClient();
  String uuid = UUID.randomUUID().toString();
  //url y tipo de contenido
  HttpPost httppost = new HttpPost(HTTP_EVENT);
  httppost.addHeader("Content-Type", "application/json");
  //forma el JSON y tipo de contenido
  JSONObject jsonObject = new JSONObject();
  jsonObject.put("uuid", uuid );
  jsonObject.put("name", name );
  jsonObject.put("age", age );  
  StringEntity stringEntity = new StringEntity( jsonObject.toString());
  stringEntity.setContentType( (Header) new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));  
  httppost.setEntity(stringEntity); 
  //ejecuta
  HttpResponse response = httpclient.execute(httppost);
  //obtiene la respuesta y transorma a objeto JSON
  String jsonResult = inputStreamToString(response.getEntity().getContent()).toString();   
  JSONObject object = new JSONObject(jsonResult);
  Log.i("jsonResult",jsonResult);  
  if( object.getString("Result").equals("200"))
  {    
   return "Petición POST: Exito";
  } 
  return "Petición POST: Fracaso";
 } 

 /**
 * Transforma el InputStream en un String
 * @return StringBuilder
 * */
 private StringBuilder inputStreamToString(InputStream is)
 {  
  String line = "";
  StringBuilder stringBuilder = new StringBuilder();
  BufferedReader rd = new BufferedReader( new InputStreamReader(is) );  
  try
  {
   while( (line = rd.readLine()) != null )
   {
    stringBuilder.append(line);
   }
  }
  catch( IOException e)
  {
   e.printStackTrace(); 
  }

  return stringBuilder;
 }
}

Vemos que en esta clase, hacemos uso de una variable llamada UUID el cual generamos con randomUUID y tiene la forma de “ecf02d7e-c10a-4904-aad1-1bb294845ac0“,  UUID son las siglas en inglés de Identificador Universalmente Único y se usa para que las peticiones que lleguen al servidor, no sean repetidas, esto porque a un api rest le llegan cientos sino es que miles de peticiones y este debe saber como identificarlas para por ejemplo no insertar el mismo registro dos veces. En el ejemplo de este post, no se le esta dando ningún uso, sin embargo hay que tenerlo en cuenta para futuros proyectos.

6. MyAsyncTask

Esta clase que se extiende de AsyncTask  nos permite realizar tareas en segundo plano, mostrará un ProgressDialog mientras se realiza la tarea, al terminar pasara el resultado a la interfaz, el resultado es un string.

package com.bolivia.restfulgp;
import java.io.IOException;
import org.apache.http.client.ClientProtocolException;
import org.json.JSONException;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.widget.TextView;

public class MyAsyncTask extends AsyncTask<String,Void,String>{

 private ProgressDialog progressDialog;
 private Context context; 
 TextView textView; 

 /**Constructor de clase */
 public MyAsyncTask(Context context, TextView textView) {
        this.context = context;
        this.textView = textView;
    }
 /**
 * Realiza la tarea en segundo plano
 * @param params[0] Comando GET/POST
 * @param params[1] Nombre
 * @param params[2] Edad
 * */
 @Override
 protected String doInBackground(String... params) {

  if( params[1].length()==0 || params[2].length()==0 )
  {
   return "Todos los campos son obligatorios";
  }
  else
  {
   MyRestFulGP myRestFulGP = new MyRestFulGP();
   try {
    if( params[0].equals("GET"))
    {
     return myRestFulGP.addEventGet(params[1],params[2]);
    }else if( params[0].equals("POST"))
    {
     return myRestFulGP.addEventPost(params[1],params[2]);
    }   
   } catch (ClientProtocolException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   } catch (JSONException e) {
    e.printStackTrace();
   }  
  }    
  return "";
 }

 /**
 * Antes de comenzar la tarea muestra el progressDialog
 * */
  @Override
  protected void onPreExecute() {
       super.onPreExecute();         
       progressDialog = ProgressDialog.show(
           context, "Por favor espere", "Procesando...");
  }

    /**
 * Cuando se termina de ejecutar, cierra el progressDialog y retorna el resultado a la interfaz
 * **/
  @Override
  protected void onPostExecute(String resul) {
   progressDialog.dismiss();   
      textView.setText(resul);   
  }
}

7. MainActivity

Para terminar implementaremos en el MainActivity el evento CLIC para los botones GET y POST que ejecutaran una instancia del MyAsyncTask para cada una de las peticiones de la siguiente manera:

public class MainActivity extends Activity {

 Button btnGet;
 Button btnPost;
 EditText txtName;
 EditText txtAge;
 TextView txtResponse;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  btnGet = (Button) findViewById( R.id.btnGet );
  btnPost = (Button) findViewById( R.id.btnPost );
  txtName = (EditText) findViewById( R.id.txtName );
  txtAge = (EditText) findViewById( R.id.txtAge );
  txtResponse = (TextView) findViewById( R.id.txtResponse );
  //Evento para el boton GET
  btnGet.setOnClickListener( new View.OnClickListener() {
      @Override
      public void onClick(View view) {
       new MyAsyncTask(MainActivity.this, txtResponse)
               .execute("GET", txtName.getText().toString(), txtAge.getText().toString());  
      }      
  });
  //Evento para el boton POST
  btnPost.setOnClickListener( new View.OnClickListener() {
      @Override
      public void onClick(View view) {
       new MyAsyncTask(MainActivity.this, txtResponse)
               .execute("POST", txtName.getText().toString(), txtAge.getText().toString());  
      }      
  });
 }

Ejecuta

REST ANdroid

Si la petición tuvo éxito te avisara en la interfaz, así tambien las peticiones que se envien tanto por GET como por POST, se almacenaran en un archivo de texto en el servidor con el nombre de log.txt, después de realizar unas cuantas peticiones al apirest, el archivo log tendrá la forma de:

-------------------------------------------------------------------------------
GET :: {"name":"Lago Losina","age":"23","uuid":"da29ec34-a45d-4e78-be4d-f0f844815ea2"}
-------------------------------------------------------------------------------
POST :: {"age":"65","name":"Subiran Alatorre","uuid":"eeac4133-6ee7-4411-962f-4b8705953d5b"}
-------------------------------------------------------------------------------

enjoy!!!

Tags

Si te ha gustado podrías compartirlo o dejar un comentario. ¡Muchas gracias!
Autor: JC Mouse

Yo soy yo :) JC Mouse, Soy orgullosamente boliviano soy fundador y CEO de la web jc-Mouse.net uno de las pocas web en emprendimiento y tecnología en Bolivia.

Toda la información que encuentres en este sitio es y sera completamente gratis siempre, puedes copiar, descargar y re-publicar si así lo deseas en otros blogs o sitios web, solo te pido a cambio que dejes una referencia a esta web. Esto nos ayuda a crecer y seguir aportando. Bye

Enjoy! :)

También Te Podría Interesar

Añade un PlaceHolder a un JTextField

Añade un PlaceHolder a un JTextField

PlaceHolder: PlaceHolder es un atributo propio de HTML5 y es el texto que aparece dentro de un campo de texto (un JTextF...

Terminator: Terminal multiventanas para Linux

Terminator: Terminal multiventanas para Linux

Cada versión de Linux viene con su propia terminal predeterminada para interactuar con el Sistema Operativo a través de...

Crea un “Juego de Memoria” en java

Crea un “Juego de Memoria” en java

En este tutorial crearemos un sencillo juego de memoria en lenguaje java. Necesitamos IDE Netbeans 7.x Editor de imágene...

Ejemplo de aplicación Android y SQLite

Ejemplo de aplicación Android y SQLite

En esta oportunidad dejo para estudio y critica de los programadores android un ejemplo sencillo de una aplicación que h...

Renombrar atributos JSON con GSON

Renombrar atributos JSON con GSON

Si quieres cambiar el nombre de tus atributos sin tener que reescribir código java por X o Y razón, GSON te permite reno...

Tutorial Gráficos Vectoriales SVG – Parte I

Tutorial Gráficos Vectoriales SVG – Parte I

Estructura Interna de un archivo SVG. <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD...

2 comentarios en “Métodos GET y POST en RestFul y JSON”

  1. Ricardo dice:

    Hola, muchas gracias por el tutorial está muy bueno y me ha ayudado bastante, ya que soy bastante nuevo en el tema de Android, por lo mismo me ha surgido una duda, te explico lo que estoy haciendo, bueno estoy haciendo una petición desde un Android a un php el cual hace un insert en una tabla que tengo en mysql, con el código que has dado puedo comunicarme y hacer lo que quiero, pero que pasa si la conexión a internet se interrumpe justo cuando en el momento cuando el php a recibido el json y estoy haciendo el insert en mi tabla, como sabrá el Android que el insert se realizó correctamente si no esta conectado si se perdió la comunicación entre ambos?
    Gracias.. y insisto muy buen tutorial

  2. cristina dice:

    Hola, me muestra los resultados del post en blanco en el archivo log.txt y no me muestra el msj. del status en pantalla.

Los comentarios estan cerrados

Comparte lo que sabes

Categorias

Últimas entradas

MyBatis es un framework de persistencia Java que se encarga de mapear sentencias SQL y procedimientos almacenados a part...

Webcam Capture es un API  que permite usar una cámara web incorporada o externa directamente desde código Java utilizand...

im4java es una interfaz pura de Java para la línea de comandos de ImageMagick. La interfaz de la línea de comandos de IM...

En un post anterior conocimos una herramienta Open Source con un conjunto de herramientas para el trabajo con imágenes e...

Herramientas

Generador de Enlaces a Whatsapp