miércoles, 13 de julio de 2011

Java Tips


Buenos consejos para el desarrollador


Hola a todos, buscando información sobre como inciarse en el desarrollo de aplicaciones web en Java (JSP y Servlets), me encontré esta página que tiene bastante contenido para los que quieran incursionar a fondo en la plataforma Java, el sitio es llamado Java Tips. En este sitio encontraremos abundantes tutoriales que nos llevarán paso a paso para conocer cada una de las diferentes tecnologías de programación que esta plataforma ofrece (como JSP y los Servlets, tecnicas para el lenguaje Java, manipulación de imágenes, Java EE, Swing, Applets y diferentes utilerias, entre otros).

Más adelante, espero poder desarrollar algunas entradas en este blog, con las aplicaciones de estos tutoriales que haya encotrado más interesantes.

Hasta pronto.

martes, 21 de junio de 2011

Tutorial de PHP de Zend


El que sabe sabe

Hola, después de mucho tiempo sin publicar, ahora traigo una entrada algo corta pero sustancial. Se trata de uno de los tutoriales del lenguaje PHP más completos que he encontrado, desarrollado por la propia compañía Zend, y que nos lleva de la mano dando los primeros pasos hasta el desarrollo de aplicaciones avanzadas. Sin más preámbulos, aquí está:

PHP 101: PHP For the Absolute Beginner

This area is intended for everyone new to PHP. It opens with a series of informal, entertaining tutorials written by Vikram Vaswani, founder and CEO of Melonfire. These tutorials build on a previously-published 5-part series which has now been updated and extended to embrace PHP 5, making parts of it suitable for those of you who already have worked with PHP 4 in the past.

If you came here to learn about elementary PHP 4 or basic PHP 5, this is for you. Enjoy!


El tutorial se divide en 15 partes, cada una con su respectiva introducción teórica, acompañadas de interesantes ejercicios para poner el práctica lo aprendido.

Saludos.

lunes, 14 de junio de 2010

Como devolver arreglos y estructuras de datos en SOAP transparentemente, utilizando PHP y NuSOAP


¡Saludos nuevamente blogueros!

En este artículo veremos como resolver una duda que apareció hace un tiempo, acerca del envío de datos por servicios web utilizando la biblioteca NuSOAP de PHP. En un artículo pasado, hablamos de como implementar un servicio web desde PHP utilizando esta biblioteca; este servicio contaba con dos métodos, uno de ellos devolvía una cadena y el otro un arreglo asociativo de PHP, se pudo consumir el servicio desde un cliente AJAX sin problema procesando el código XML directamente, sin embargo, al trabajar de esta manera se pierde uno de los puntos importantes para utilizar protocolos de comunicación entre aplicaciones: la transparencia. Es decir, al consumir el servicio el cliente no pudo extraer la estructura de datos recibida, sin necesidad de darle un tratamiento al XML de la respuesta y teniendo que saber de antemano cuál era la estructura XML que recibiría.

Ahora, la idea es corregir este problema de transparencia, al mismo tiempo que mostramos como mandar diferentes tipos de datos complejos, como son: estructuras, arreglos y arreglos de estructuras.

Manos a la obra

Para poder llegar a este nivel de transparencia entre aplicaciones es que el protocolo SOAP utiliza el WSDL, el cual además de contener la definición de cada uno de los métodos que posee un servicio web, puede tener también la definición de tipos de datos complejos. Un tipo de dato complejo consiste una colección de valores agrupados dentro de una estructura, y dentro de este tipo de datos es que encontramos los objetos y arreglos.

Podemos definir estos datos complejos utilizando la clase soap_server de la biblioteca NuSOAP. Como recordarán -y si no es así lo menciono- esta clase nos permite crear servicios web en nuestro servidor para que lo consuman los clientes. Dentro de esta clase se encuentra un objeto llamado wsdl, definido como una propiedad de la misma clase, el cual posee una serie de métodos para definir las características del WSDL del servicio web. El método que emplearemos concretamente para definir los nuevos tipos de datos será el addComplexType. El primer paso consistirá en instanciar la clase soap_server de la siguiente forma:

require_once('nusoap.php');
$servidor = new soap_server;


Una vez hecho esto contamos con un objeto de esta clase, para el cual podemos definir sus características:

$ns = "http://nuestroespaciodenombres";
$servidor->configureWSDL('NombreDelServicio',$ns);
$servidor->wsdl->schematargetnamespace = $ns;


Ahora viene lo bueno, definir tipos de datos complejos para que sean devueltos por los métodos de nuestro servicio. Para este ejemplo definiremos 3 estructuras diferentes para probar las posibilidades que nos ofrece esta clase:

  • Primero un arreglo de cadenas sencillo:

$servidor->wsdl->addComplexType(
        'ArregloDeCadenas',
        'complexType',
        'array',
        'sequence',
        'http://schemas.xmlsoap.org/soap/encoding/:Array',
        array(),
        array(array('ref' => 'http://schemas.xmlsoap.org/soap/encoding/:arrayType',
         'wsdl:arrayType' => 'xsd:string[]')
        ),
        'xsd:string'  
);


Como vemos, se incluye una referencia(http://schemas.xmlsoap.org/soap/encoding/:Array) a la definición del formato que debe tener un dato de tipo complejo Array.

  • Después una estructura de datos, similar a los arreglos asociativos, que contendrá una serie de valores distinguidos por un nombre:


  • $servidor->wsdl->addComplexType(
            'Estructura',
            'complexType',
            'struct',
            'all',
            '',
            array(
            'Nombre' => array('name' => 'Nombre', 'type' => 'xsd:string'),
            'Apellidos'=>array('name' => 'Apellidos', 'type' => 'xsd:string'),
            'Edad'=>array('name' => 'Edad', 'type' => 'xsd:integer')
            )
    );


  • Finalmente -y lo más interesante-, un arreglo de estructuras de datos:

$servidor->wsdl->addComplexType(
        'ArregloDeEstructuras',
        'complexType',
        'array',
        'sequence',
        'http://schemas.xmlsoap.org/soap/encoding/:Array',
        array(),
        array(array('ref' => 'http://schemas.xmlsoap.org/soap/encoding/:arrayType',
         'wsdl:arrayType' => 'tns:Estructura[]')
        ),
        'tns:Estructura'  
);


Digo que el último ejemplo me parece el más interesante porque con este podemos definir datos de entrada y de salida para los métodos que consistirán en listas de estructuras de datos, similares a las que encontramos en muchos lenguajes de programación de alto nivel y sobre todo muy útiles para representar registros de bases de datos y archivos estructurados.

Para incluir estos datos de entrada y de salida de los métodos, basta con declararlo en el método registrer donde se declaran los métodos, y asegurarnos por supuesto de que la estructura de los parámetros de estos métodos que hagan referencia los tipos de datos complejos, corresponda con la estructura declarada, es decir:

function consultaPersonas($param) {
    $arreglo = array();
    $arreglo[] = array('Nombre'=>"Juan", 'Apellidos'=>"Torres", 'Edad'=>18);
    $arreglo[] = array('Nombre'=>"Teresa", 'Apellidos'=>"Jiménez Sánchez", 'Edad'=>19);
    $arreglo[] = array('Nombre'=>"Efraín", 'Apellidos'=>"Ovalles López", 'Edad'=>22);
    return $arreglo;
}

$servidor->register('consultaPersonas',
    array('param'=>'xsd:string'),
    array('return'=>'tns:ArregloDeEstructuras'),
    $ns
);



Si por ejemplo creamos un método que devuelva el tipo de dato complejo ArregloDeEstructuras, en el código de nuestro método deberemos incluir una estructura de datos equivalente, en este caso un arreglo asociativo, donde cada llave del arreglo corresponde al identificador de los datos de nuestra estructura previamente definida -llamada Estructura en este ejemplo-; así en el método, cada entrada del arreglo contendrá a la vez un arreglo asociativo, que corresponderá a esta estructura de datos.

De esta forma es posible crear servicios web que devuelvan a nuestras aplicaciones arreglos de estructuras de datos, e incluso arreglos de arreglos, lo cual ayudará a que nuestros servicios puedan generar mayor variedad de datos de salida, y de esta forma aumentaremos el poder las capacidades nuestras aplicaciones. Además de esto, se logra mucha mayor transparencia, ya que cualquier aplicación de terceros o que nosotros mismos desarrollemos, solo tendrá que seguir el formato definido en el WSDL de nuestros servicios web, para poder desentrañar estos tipos de datos complejos. Algunos entornos de desarrollo -como el de .Net- incluso permiten implementar el consumo de estos servicios web interpretando los tipos de datos complejos como objetos nativos del lenguaje, lo que nos permite manipularlos con mucha mayor facilidad, así que las posibilidades son muchas.

Hasta la próxima.

viernes, 11 de junio de 2010

Devolver objetos en JSON desde PHP


Yo digo que es una dona

¡Saludos blogueros!

Ese pequeño artículo va para los que se preguntaban en el ejemplo anterior, ¿qué era ese formato llamado JSON que utiliza flickr para enviarnos la información? Se trata más que nada de una forma para intercambiar datos estructurados entre diferentes sistemas sobre protocolos como HTTP. JSON, define cómo se deberán codificar los objetos de un determinado lenguaje para convertirlos en cadenas de texto, con el propósito de enviarlos hacia otras aplicaciones, y que estas puedan reconstruirlos como objetos nativos, utilizando la decodificación definida por el mismo formato JSON.

Por ejemplo, digamos que mi aplicación desea mandar un objeto que contiene determinada información hacia un cliente Javascript, además de las ya conocidas técnicas basadas en XML o protocolos como SOAP, tenemos la posibilidad de mandarlo codificado en JSON, de modo que desde nuestra aplicación convertiremos ese objeto en una cadena de texto que lo representará, y lo enviaremos a nuestro cliente Javascript como una respuesta en texto simple, el cliente -con previo conocimiento del formato de la respuesta-, solo tendrá que aplicar las reglas de la notación para -partir de la cadena- reconstruir el objeto y utilizarlo dentro de su propia ejecución de instrucciones. Tal y como hicimos en el ejemplo anterior con los servicios de flickr.

La gran ventaja de JSON, es que el cliente Javascript puede utilizar la instrucción eval, para reconstruir el objeto partir de la cadena recibida, sin necesidad de ningún interprete especia, tal y como explica el artículo de la Wikipedia sobre JSON. Del lado de nuestra aplicación en el servidor por otro lado sí se necesitará de una funcionalidad que haga el trabajo de codificar los objetos u arreglos en la notación de JSON, pero para eso la gran mayoría de los lenguajes cuentan ya con bibliotecas de funciones o clases para hacer la tarea.

En este artículo veremos cómo hacer esa tarea del lado del servidor, utilizando la biblioteca de funciones para JSON de PHP, disponible a partir de la versión 5.2.0. Creando la siguiente aplicación web en este lenguaje:

respuestajson.php
<?php

//Clase para representar una serie de diferentes artículos para tiendas

class Articulo {
public $id;
public $nombre;
public $categoria;
public $precioDeSalida;
public $detalles;
}



$articulo = new Articulo();
$articulo->id = 1;
$articulo->nombre = "Nintendo DS";
$articulo->categoria = "Videojuego";
$articulo->precioDeSalida = "$3 500";
$articulo->detalles = array('Soporta juegos para Gameboy advance','Pantalla tactil','Reproducción de MP3');
echo json_encode($articulo);?>


El programa en PHP codificara en notación JSON el objeto $articulo, dando como resultado una cadena que devolverá al cliente, la cual podemos visualizar si accedemos a la aplicación desde el navegador (http://localhost/respuestajson.php):


{"id":1,"nombre":"Nintendo DS","categoria":"Videojuego","precioDeSalida":"$3 500","detalles":["Soporta juegos para Gameboy advance","Pantalla tactil","Reproducci\u00f3n de MP3"]}


Ahora, el cliente AJAX para procesar estos datos sería el siguiente:

clientejson.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Decodifica un objeto en JSON</title>
<script type="application/javascript">
var http_request = new XMLHttpRequest();
var url = "http://localhost/respuestajson.php"; // Esta URL debería devolver datos JSON

// Descarga los datos JSON del servidor.
http_request.onreadystatechange = manejaJSON;
http_request.open("GET", url, true);
http_request.send(null);

function manejaJSON() {
  if (http_request.readyState == 4) {
    if (http_request.status == 200) {
      var cadCodificadaJSON = http_request.responseText;
      var objDatos = eval("(" + cadCodificadaJSON + ")"); //Creamos el objeto utilizando la cadena codificada
      //Ahora con el objeto desplegamos los datos mandados desde el servidor
      document.getElementById("divId").innerHTML = objDatos.id;
      document.getElementById("divNombre").innerHTML = objDatos.nombre;
      document.getElementById("divCategoria").innerHTML = objDatos.categoria;
      document.getElementById("divPrecio").innerHTML = objDatos.precioDeSalida;
      document.getElementById("divDetalles").innerHTML = objDatos.detalles[0] + ", " + objDatos.detalles[1] + ", " + objDatos.detalles[2];
    } else {
      alert("Ocurrio un problema con la URL.");
    }
    http_request = null;
  }
}
</script>
</head>
<body>
<h2>Producto</h2>
<div id="divId"></div>
<div id="divNombre"></div>
<div id="divCategoria"></div>
<div id="divPrecio"></div>
<div id="divDetalles"></div>
</body>
</html>


Este código implementa una sencilla aplicación AJAX, similar a las vistas en los primero ejemplos sobre esta tecnología vistos en este blog. Básicamente accede a la aplicación en PHP que creamos previamente, y procesa el texto plano que recibe como respuesta, almacenándolo en la cadena, debido a que este texto consiste en la codificación en JSON del objeto original, lo decodifica utilizando la instrucción eval("(" + cadCodificadaJSON + ")"), creando el objeto objDatos como resultado.

El resultado obtenido se vería en el navegador como sigue:

Producto


1

Nintendo DS

Videojuego

$3 500

Soporta juegos para Gameboy advance, Pantalla tactil, Reproducción de MP3


De esta forma, podemos transmitir conjuntos de datos estructurados sin recurrir a formatos como XML o protocolos como SOAP, que requieren un mayor trabajo de procesamiento de la información en el cliente, pero que en contra parte, exige que el servidor pueda llevar a cabo la codificación de objetos en JSON. La elección final de la forma en que vayamos a transmitir los datos sobre HTTP, dependerá de los requerimientos que nos exijan la arquitectura y la plataforma que habremos de utilizar.

Saludos.

miércoles, 28 de abril de 2010

Una forma rápida de acceder a una galería de Flickr utilizando jQuery




¡Saludos de nuevo blogueros!

Siguiendo con las pruebas de la biblioteca jQuery, ahora me puse a revisar su potencial explotando algún servicio de imágenes de Internet, entre los que encontré los servicios para acceder a las galerías de imágenes de Flickr. Este manejador de imágenes posee varias formas para que nuestras aplicaciones puedan descargarse una lista con la información de las imágenes que tienen sus álbumes, ya sea a consumiendo alguna de sus APIs para la búsqueda de fotografías o utilizando su servicio de suscripción al feed RSS de un usuario.

Si consumimos alguna de las APIs de Flickr, tenemos la posibilidad de buscar sobre toda la base de datos del sistema, cualquier fotografía que coincida con las palabras clave o el identificador del usuario que estemos buscando. Esta forma de utlizar jQuery se explora en este artículo de CocinaMental, donde se utiliza la API flickr.photos.search.

Por otro lado, a través de un feed RSS, podemos acceder a la información de las últimas fotografías que han sido agregadas a la galería de un usuario específico.

El método que exploraremos en este artículo consistirá en consumir el feed RSS de una galería de Flickr desde nuestra aplicación AJAX, dejando a los usuarios que deseen saber como explotar las APIs de Flickr la referencia a al artículo en CocinaMental, donde se expone bastante claro como lograrlo. Como no es mi intención crear una artículo redundante me decante por este método sobre el de las APIs, además de que es sumamente rápido ponerlo a trabajar.

Antes de empezar

Adicionalmente a la biblioteca jQuery, en el programa utilizaremos un plug in llamado cycle, el cual nos permitirá agregar el efecto de cambio automático de imágenes con desvanecimiento a la galería que mostraremos.

Ambas bibliotecas las incluiremos en nuestro código con referencias a sus archivos fuente, pero en esta ocasión no será necesario descargar ningún archivo, ya que referenciaremos directamente al último archivo fuente, que se encuentra en los servidores de cada uno de los proveedores de sus códigos fuente.

Primero elegimos las imágenes


El primer paso consiste en darnos un paseo por Flickr y encontrar alguna galería que nos interese utilizar para la prueba, toda galería posee un autor, es decir el usuario que subió las imágenes, así que la galería que elijamos está directamente vinculada con este usuario. Por ejemplo en una consulta a una imagen de Flickr acabé accediendo a la galería del usuario Plateada, que podemos ver en la imagen siguiente:



Dentro de la información que aparece, lo que nos interesa para nuestra aplicación está al final de la página, en esta parte podemos ver el enlace al feed RSS de la galería, llamado Latest:



Pero no haremos clic sobre el enlace, sino que nos fijaremos en la URL que aparece en éste, ya que dentro de esta URL está la información que utilizaremos para acceder a la galería. Podemos copiar esta dirección URL para verla con calma y obtendremos un texto como el siguiente:

http://api.flickr.com/services/feeds/photos_public.gne?id=59492828@N00&lang=en-us&format=rss_200


El campo id corresponde al identificador del usuario autor de la galería Plateada, y este es precisamente el dato que utilizaremos en nuestra aplicación de ejemplo.

Vamos al código

El código para la aplicación Web que implementará esta galería es el siguiente:

galeriaJQuery.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Galería de imágenes de Flickr con jQuery</title>
    <style type="text/css">
.slideshow { margin: 20px auto; padding: 0; }
.slide { margin: 0; padding: 0}
.slide img { padding: 15px; border: 1px solid #ccc; background-color: #eee; margin: auto; display: block }
    </style>
    <script src="http://code.jquery.com/jquery-latest.js" type="text/javascript"></script>
    <script src="http://cloud.github.com/downloads/malsup/cycle/jquery.cycle.all.latest.min.js" type="text/javascript"></script>
    <script type="text/javascript">
$.getJSON("http://api.flickr.com/services/feeds/photos_public.gne?id=59492828@N00&lang=en-us&format=json&jsoncallback=?",
function(data){
   $.each(data.items, function(i,item){
     $("<img/>").attr("src", item.media.m).appendTo("#imagenes").wrap("<div class=\"slide\"><h3>"+ item.title +"</h3><a href='" + item.link + "'></a></div>");
   });
   $('#imagenes').cycle({
     fx:     'fade',     
    timeout:  5000
   });
});
    </script>    
</head>
<body>
<div id="imagenes" class="slideshow"></div>
</body>
</html>


Como vemos, se referencia a los archivos fuente de las blibliotecas jQuery y cycle desde su ubicación dentro de Internet en sus servidores Web.

Además se incluye un pequeño syle CSS para darle una apariencia más agradable a las imágenes, incluyendo en cada una un pequeño marco gris.

En lo que corresponde a la funcionalidad, el acceso a la lista de imágenes se lleva a cabo por mediante la funcionalidad jQuery.getJSON, que lleva a cabo una petición de datos en formato JSON al servidor de Flickr, utilizando una solicitud HTTP-GET (es decir, con los datos incluidos un la dirección URL del recurso al que estamos accediendo).

$.getJSON("http://api.flickr.com/services/feeds/photos_public.gne?id=59492828@N00〈=en-us&format=json&jsoncallback=?",


Dentro de la URL que utiliza la función es donde se incluirá el id del usuario que obtuvimos previamente, en este caso 59492828@N00.

Recibir la información de respuesta en formato JSON facilita bastante el trabajo, ya que es interpretada por javascript como una estructura nativa del lenguaje, y gracias a esto podemos utilizarla directamente dentro de la aplicación. Como sucede en la función que se define en seguida:

function(data){
$.each(data.items, function(i,item){
$("<img/>").attr("src", item.media.m).appendTo("#imagenes").wrap("<div class=\"slide\"><h3>"+ item.title +"</h3><a href='" + item.link + "'></a></div>");
});
$('#imagenes').cycle({
fx: 'fade',
timeout: 5000
});
});


En donde, utilizando la funcionalidad de jQuery each, podemos rellenar el elemento div "imagenes" con la información de cada una de las imágenes que recibimos como respuesta a la petición, incluyendo la ruta URL al archivo de la imagen, con lo que utilizando etiquetas HTML podemos visualizar todas las imagenes un nuestra aplicación.

Finalmente, utilizando el plug in cycle, es que podemos agregar la función para cambiar automáticamente una imagen por la siguiente en la lista, incluyendo un atractivo efecto de desvanecimiento entre una imagen y la otra. En este caso el efecto para hacer el cambio es el 'fade' (se desvanecen) que nos proporciona la biblioteca, con un tiempo entre los cambios de 5000 milisegundos.

El resultado final deberá desplegar todas las imágenes de la galería Plateada, incluyendo el título de cada una, haciendo automáticamente el cambio ante nuestros ojos:



Para visualizar cualquier otra galería de Flickr que deseemos, bastará modificar el argumento id dentro de la URL que aparece en el código fuente, con el identficador del autor de la galería que queramos. De esta forma, utilizando recursos 100% libres, podemos agregar un atractivo elemento para nuestras aplicaciones Web.

Hasta la próxima.

martes, 27 de abril de 2010

El cuerpo humano en HTML y PHP

Me encontré esta imagen en Chistes Geek y no puede dejar de traerla, en el cuerpo humano descrito en HTML con código PHP embebido para hacerlo dinámico:


miércoles, 14 de abril de 2010

AJAX utilizando jQuery


Escribir menos suena bien, veamos que sigue...


¡Saludos nuevamente blogueros!

De regreso con un breve artículo sobre como utilizar el framework para trabajar con AJAX llamado jQuery. Esta biblioteca de funciones tiene como objetivo general facilitar nuestro trabajo no solo con AJAX sino con todos nuestros scripts de Javascript, ofreciendo -como podemos ver en su documentación anterior- APIs como selectores para el acceso directo a los elementos de la página, manipulación del contenido CSS, efectos de animación en los elementos HTML, manejo de eventos, entre otras muchas utilidades. Debido a la gran popularidad de que ha gozado en las noticias que han llegado a un servidor, decidí explorar un poco este paquete para ver que cosas se pueden hacer con sus herramientas.

Una de las diferencias principales que aparecen en esta framework comparado con Prototype, es que en jQuery existe un mayor encapsulamiento de las funciones, lo que se aprecia en la cantidad de código que resulta al comparar ambos métodos, y queda todavía más claro cuando revisamos que Prototype nos permite crear nuestras propias clases para utilizarlas en las aplicaciones, cosa que no existe en jQuery, donde la filosofía es reducir el trabajo del programador y alejarlo de los detalles tras el código. En este artículo del blog de anieto2k podemos ver una pequeña comparación entre el rendimiento de ambas soluciones. Por otro lado, la conclusión a la que llegan la web intenta sobre el por qué ha ganado tanto terreno el framework jQuery, es que realmente hace más sencillo el desarrollo, cosa que siempre es bienvenida. :-)

Pero bueno, vayamos a la práctica y veamos cómo trabajar con AJAX utilizando este framework. El archivo de esta biblioteca lo encontraremos en su página oficial, dentro de la sección download. Este archivo lo utilizaremos en el código HTML haciendo referencia a él por medio del ya conocido acceso a archivos javascript:

<script type="text/javascript" src="jquery-1.4.2.min.js"></script>


Antes de empezar

Dentro de la documentación que la página oficial contiene, podemos revisar el apartado sobre la funcionalidad de jQuery para AJAX, gracias al conjunto de métodos que posee es posible llevar a cabo todo el proceso de petición al servidor Web, y procesamiento de la respuesta en unas pocas líneas de código. Concretamente nos centraremos en el método jQuery.ajax(), ya que en un solo llamado a esta función podemos configurar todo el proceso de la petición AJAX.

Esta función recibe un único parámetro que consisten en un objeto, que posee una serie de propiedades que nos permiten definir todo el proceso de la petición AJAX. Para este ejemplo utilizaremos las siguientes:

url
Dirección URL del recurso Web al que accederemos.

type
Define el tipo de envío de información que se hará, ya sea GET o POST.

data
Corresponde a la información que se mandará al servidor, en forma de parejas llave-valor, éste representa los mismos datos que pasamos en la cadena de consulta (query) cuando solicitamos una URL remota en los ejemplos sobre AJAX anteriores. Puede ser una cadena de valores codificada en formato de URL (p.e. '&dato1=valor1&dato2=valor2') o un objeto cuyas propiedades correspondan a los datos (p.e. {dato1:"valor1",dato2:"valor2"}).

dataType
Especifica el tipo de datos que esperamos que nos devuelva el servidor después de nuestra petición, estos pueden ser xml, json, script o html.

error
Guarda la referencia a la función que se ejecutará en caso de que haya algún error durante la petición al servidor Web.

complete
Guarda la referencia a la función que se ejecutará cuando la petición al servidor haya tenido una respuesta de parte de éste. Esta función puede recibir como parámetro la información devuelta por el servidor como respuesta a nuestra petición.

beforeSend
Guarda la referencia a la función que se ejecutará antes de iniciar el proceso de petición a nuestro sevidor Web.


Manos a la obra

Para la implementación de la petición asíncrona al servidor utilizaremos la funcionalidad jQuery.ajax que aparece en la documentación, con el código que aparece a continuación:

ajaxJQuery.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Prueba de AJAX con JQuery</title>
<script type="text/javascript" src="jquery-1.4.2.min.js"></script>
<script type="text/javascript">
function peticionAjax() {  
    var objParametros = creaObjParametros();
    $.ajax({url:  "http://localhost/validaDatos.php",
        type: 'POST',
        data: objParametros,
dataType: "html",
        beforeSend: function() {
                document.getElementById("divRespuesta").innerHTML = "<p>Iniciando nueva petición Ajax...</p>";
                },
        complete: function(respuesta) {
                document.getElementById("divRespuesta").innerHTML += respuesta.responseText;
                },
        error : function(respuesta) {
                alert("Ocurrió un error al acceder al servidor Web");
                }
    });
}

function creaObjParametros() {
    var obj = new Object();
    obj.txtAutor = document.getElementById("txtAutor").value;
    obj.txtAnio = document.getElementById("txtAnio").value;
    obj.txtTitulo = document.getElementById("txtTitulo").value;
    return obj;
}
</script>
</head>
<body>
<form style="background-color:#EFEDF1">
    <label for="txtAutor">Autor:</label>
    <input type="text" id="txtAutor" name="txtAutor" size="40" /><br/>
    <label for="txtAnio">Año:</label>
    <input type="text" id="txtAnio" name="txtAnio" size="10" /><br/>
    <label for="txtTitulo">Títiulo:</label>
    <input type="text" id="txtTitulo" name="txtTitulo" size="50" /><br/>
    <input type="button" value="Validar datos" onclick="peticionAjax()" />
    </form>
<div id="divRespuesta"></div>
</body>
</html>


Dentro del código javascript existen 2 funciones, la primera, peticionAjax() lleva a cabo la petición al servidor Web y procesamiento de la respuesta. La segunda, creaObjParametros() se encarga de recuperar los datos capturados por el usuario en el formulario, y almacenarlos dentro de las propiedades de un objeto que regresa como resultado. En la función para enviar la petición se utiliza la función $.ajax (jQuery.ajax) para realizar todo el proceso, ya que el único parámetro que recibe consiste en un objeto, cuyas propiedades contienen todos los datos para que jQuery, lleve a cabo las acciones de petición al servidor Web y el manejo de la respuesta que éste devuelva.

Cómo ya habíamos señalado la propiedad url contiene la dirección URL del recurso Web al que estamos accediendo, en este caso el archivo validaDatos.php, que consiste en una aplicación Web escrita en PHP para validar datos de entrada. El código de este programa aparece en el tercer ejemplo que vimos en este blog sobre Ajax, que se titula Combinando Ajax con PHP. Pueden consultar este artículo para mayor referencia sobre el comportamiento de este programa.

El código aparece a continuación:

validaDatos.php
<?php
//Expresiones regulares para la validación de los datos
$er_titulo = "/^([a-z]|[A-Z]|[ÁÉÍÓÚáéíóúÑñÜü]|[0-9]|[\s\.\-,:'\"])+$/";
$er_autor = "/^([a-z]|[A-Z]|[ÁÉÍÓÚáéíóúÑñÜü]|[\s,\.'\-])+$/";
$er_anio = "/^([1-2][0-9][0-9][0-9])$/";
//Validamos que se hayan enviado todos los datos por post
if(isset($_POST['txtAutor']) && isset($_POST['txtAnio']) && isset($_POST['txtTitulo'])){
  //Validamos el contenido de los campos
  $autor = stripslashes(trim($_POST['txtAutor']));
  $anio = trim($_POST['txtAnio']);
  $titulo = stripslashes(trim($_POST['txtTitulo']));
  if(!preg_match($er_autor,$autor)){
    $campo = "autor";
  }
  else if(!preg_match($er_anio,$anio)){
    $campo = "año";
  }
  else if(!preg_match($er_titulo,$titulo)){
    $campo = "título";
  }
  else{
    $mensaje = "Todos los campos capturados son correctos :)";
  }
  if(isset($campo))
    $mensaje = "Error: El texto capturado en el campo $campo es incorrecto";
}
else{
  $mensaje = "No se recibieron los valores";
}
?>
<p><?=$mensaje?></p>
<p><u>Valores recibidos</u>:<br />
Autor: <?=$_POST['txtAutor']?><br />
Año: <?=$_POST['txtAnio']?><br />
Título: <?=$_POST['txtTitulo']?><br />
</p>


Básicamente es un programa que recibe una serie de datos enviados por POST desde nuestro navegador, los valida utilizando expresiones regulares, y dependiendo de si cumplieron o no con estás, imprime un mensaje correspondiente al resultado del proceso.

El resultado final de la implementación se puede probar localmente, almacenado en nuestro servidor Web estos dos archivos, y accediendo con nuestro navegador ajaxJQuery.html:



Y así, con unas pocas líneas podemos adaptar nuestros programas anteriores al framework jQuery, y comprobar como es bastante sencillo de utilizar permite además tener un código mucho más limpio.

Al momento de decidir entre cual framework para Ajax utilizar, deberiamos revisar cada una de las funcionalidades que aparecen en sus respectivas documentaciones, y en base a nuestras necesidades y conocimientos previos elegir el que mejor se nos adapte. Al final, la decisión recaerá unicamente en el desarrollador.

Saludos y hasta la próxima.