Creando un Web Service con PHP

Muchas veces es necesario que tus aplicaciones, a parte de ofrecer una interfaz gráfica para que los usuarios manipulen la información del sistema, puedan ofrecer un servicio web que les permita manipular la información sin necesidad de ver la interfaz gráfica. Esto es muy útil para crear aplicaciones automáticas que no les interesa una interfaz gráfica sino simplemente manipular datos. Además es útil para publicar servicios por internet, como por ejemplo convertir unidades, convertir pdf a doc, consultar gmail, etc.

¿Qué es un Web Service?

Un web service o servicio web, es simplemente un estándar para intercambiar datos entre aplicaciones. Al ser un estándar, no importa el lenguaje en el que se implemente ni en que sistema operativo se ejecute ya que si respeta el estándar es como si las aplicaciones hablaran el mismo idioma.

Un servicio web se parece en muchos aspectos a una página web tradicional y aquí menciono sus similitudes:

• Ambas trabajan en el modelo cliente-servidor dónde el cliente es el usuario que consume (página web o servicio web) y el servidor es quien provee (ofrece el contenido).
• Ambas por lo general corren sobre el puerto 80.
• Ambas utilizan el protocolo de comunicación HTTP.
• Ambos servidores reciben una petición y de acuerdo a eso producen un resultado.
• Ambos clientes envían peticiones a los servidores.

La principal diferencia entre una página web y un servicio web es que la primera recibe peticiones que no siguen un patrón establecido mientras que un servicio web recibe una petición en XML bajo un estándar establecido por el W3C (World Wide Web Consortium).

Existen dos principales tipos de web service, SOAP y XML-RPC. En este artículo voy a explicar ambos y a continuación voy a explicar algunas de sus diferencias.

SOAP	XML-RPC
Es un estándar complejo	Es un estándar simple.
No tiene restricción de tipos de datos	Solo maneja hasta 8 tipos de datos.
Se basa en un documento WSDL que define la información del servicio web. (El WSDL no es necesario pero casi siempre se define)	No tiene un documento que describa el servicio web. Las implementaciones se tienen que hacer con previo conocimiento de los métodos con los que cuenta el servicio web.
Es complicado de implementar.	Es más fácil de implementar.

Un Web Service sigue un estándar en el que se envía bastante información adicional a la data real. Por ejemplo para mandar un número a mi servicio web no basta con mandarle el número en sí, sino que tengo que mandarle el tipo de dato, que método lo debe procesar, etc. Dicho esto te recomiendo que si quieres realizar un programa que se ejecute en tiempo real y que tenga como principal objetivo mejorar la velocidad de ejecución entonces no debes utilizar un servicio web.

¿Cómo implementar un Web Service?

Es posible realizar una implementación desde cero en PHP de un Web Service. Sin embargo, es muy poco práctico ya que necesito tener un amplio conocimiento del estándar y además requiere mucho tiempo de implementación.

Es por esta razón que la mejor forma de implementar un servicio web es utilizando una librería ya creada. Existe una gran variedad de librerías gratuitas en el mercado tanto como para SOAP como XML-RPC pero de todas yo he escogido utilizar las clases del Zend Framework.

¿Por qué Zend Framework?

He escogido utilizar las clases del Zend Framework por las siguientes razones:

• Son Orientadas a Objetos (POO).
• Ofrece clases para SOAP y XML-RPC. Esto es bastante conveniente ya que puedo manipular sin problemas ambos tipos de servicio web en lugar de tener que conseguir una para SOAP y otra para XML-RPC.
• No requiere realizar modificaciones en la instalación de mi servidor web ni mi PHP. Muchas de las otras librerías que existen necesitan que PHP tenga incluida ciertas librerías que no necesariamente estarán presentes en un ambiente de producción, especialmente si se cuenta con un hosting compartido.
• Si realizas aplicaciones de gran escala, el Zend Framework es muy útil porque ofrece una gran librería de clases con las que puedes trabajar y realizar tareas en cuestión de segundos. Si no conoces el Zend Framework te recomiendo que le des una mirada, te va a encantar.
• En el caso de SOAP te permite generar automáticamente el archivo WSDL o sino te ofrece una clase para poder crearlo manualmente.

Preparando el ambiente de desarrollo para utilizar Zend Framework

Antes de mostrarte como crear y utilizar un web service, es necesario que prepares tu ambiente de desarrollo PHP para que utilice Zend Framework. Para ello asumo que ya cuentas con un servidor web con PHP instalado, si no lo tienes te recomiendo leer primero Instalando PHP y MySQL en Windows y/o Linux. Además asumo que sabes cuál es la raíz de tu servidor web por lo que trabajaremos directamente sobre esta ruta.

Descargar Zend Framework

Lo primero que tienes que hacer es descargar Zend Framework de la siguiente ruta http://framework.zend.com/download/latest. Te recomiendo descargar la versión Minimal ya que no necesitamos nada más para este caso. La versión que se utilizará en este artículo es Zend Framework 1.10.2 por ser la más reciente hasta el momento.

Copiar el Zend Framework al servidor web.

Una vez descargado debes descomprimir el Zend Framework. Una vez descomprimido encontrarás una carpeta library que tiene dentro de ella la carpeta Zend. La carpeta Zend es la que contiene a todo el Zend Framework y es la que debes copiar a tu servidor web.

No es necesario copiar todo el Zend Framework a tu servidor web, solo necesitas algunas clases para implementar servicios web así que dejo a tu criterio si copias todo o solo copias las carpetas necesarias. Más adelante cuando muestre la implementación voy a especificar que carpetas y archivos del framework son necesarios.

Es importante que la carpeta Zend exista en tu servidor web y no solo las carpetas internas del Framework ya que este es un requisito para que esto funcione.

Creando la estructura de archivos

En este artículo voy a enseñarte como crear web services con SOAP y XML-RPC. En ambos te voy a enseñar a crear el cliente (consumidor) y el servidor (proveedor). Es por esta razón que voy a necesitar que crees la siguiente estructura de archivos y carpetas en la raíz de tu servidor web (puede ser una carpeta dentro del servidor web).

• raíz
  • Zend
  • soap
    • cliente.php
    • servidor.php
  • xmlrpc
    • cliente.php
    • servidor.php
  • miWebService.php

La carpeta Zend contendrá al Framework. La carpeta soap es para el ejemplo de implementación de web service usando SOAP y la carpeta xmlrpc para la implementación de web service usando XML-RPC. En ambas carpetas hay 2 archivos. El archivo cliente.php contendrá al código para consultar el servicio web y el archivo servidor.php contendrá el código que procesa las peticiones de nuestro servicio web.

El archivo miWebService.php contendrá la implementación del servicio web en si para lo cual no importa si lo ofreceremos con SOAP o XML-RPC.

miWebService.php

El archivo miWebService.php contendrá una clase con los métodos que queremos que tenga nuestro servicio web. En este ejemplo voy a crear tres métodos:

Método	Descripción
Saludame	Recibirá un nombre y un idioma y devolverá una cadena de texto saludando a la persona en el idioma adecuado.
Sumar	Recibirá un arreglo de números a sumar y devolverá la suma de todos los números enviados.
InfoRectangulo	Recibirá un parámetro que represente una clase Rectangulo (que tenga ancho y altura) y devolverá una clase Informacion (que tenga area, volumen, hypotenusa y si es un cuadrado). Este método solo lo utilizaremos en SOAP ya que en XML-RPC no podemos mandar clases (solo tiene 8 tipos de datos).

En el código de miWebService.php voy a colocar las dos clases que voy a utilizar para el método InfoRectangulo. El código de miWebService.php es el siguiente:

<?php
//-----------------------------------------------
class Rectangulo
{
	/** @var int */
	public $ancho;

	/** @var int */
	public $altura;
}
//-----------------------------------------------
class Informacion
{
	/** @var int */
	public $area;

	/** @var int */
	public $perimetro;

	/** @var float */
	public $hypotenusa;

	/** @var bool */
	public $esCuadrado;
}
//-----------------------------------------------
class miWebService
{
	/**
	 * Saluda a una persona en un idioma
	 * especifico
	 *
	 * @param string $nombre
	 * @param string $idioma
	 * @return string
	*/
	function Saludame($nombre, $idioma)
	{
		if (strcmp($idioma, "es") == 0)
			return "Hola " . $nombre;
		else if (strcmp($idioma, "en") == 0)
			return "Hello " . $nombre;
		else if (strcmp($idioma, "fr") == 0)
			return "Bonjour " . $nombre;
		else
			return "??? " . $nombre;
	}

	/**
	 * Devuelve la suma de todos los
	 * numeros enviados
	 *
	 * @param array $numeros
	 * @return float
	 */
	function Sumar($numeros)
	{
		if (!is_array($numeros))
			return 0;
		$suma = 0;
		foreach($numeros as $num)
		{
			$suma += floatval($num);
		}
		return $suma;
	}

	/**
	 * Devuelve la informacion de un rectangulo
	 *
	 * @param Rectangulo $rect
	 * @return Informacion
	 */
	function InfoRectangulo($rect)
	{
		$info = new Informacion();
		$info->area = $rect->ancho * $rect->altura;
		$info->perimetro = $rect->ancho * 2 + $rect->altura * 2;
		$info->hypotenusa = sqrt($rect->ancho * $rect->ancho + $rect->altura * $rect->altura);
		$info->esCuadrado = ($rect->ancho == $rect->altura);
		return $info;
	}
}

Algo que tienes que tener muy en cuenta son los comentarios de esta clase. Estos comentarios definen la descripción de cada una de las funciones así como el tipo de dato de los parámetros (@param) y del valor de retorno (@return) así como de los atributos (@var) de mis clases Rectangulo e Informacion.

Sin estos comentarios el servicio web se creará con tipos de datos inciertos. Algunos tipos de datos que puedes usar son: int, string, float, bool, array. Pero como puedes ver en el ejemplo también puedes especificar nombres de clases.

En el caso de las clases, si no se puede determinar el tipo de dato de algún atributo de una clase el documento WSDL se creará como si el atributo no existiese.

Hasta ahora, lo único que hemos creado es una clase con métodos. Lo que haremos ahora es poner un web service al frente para que interactúe con esta clase.

Implementando el web service con SOAP

La gran mayoría de servicios web de tipo SOAP necesitan un documento WSDL. El documento WSDL es simplemente un documento en XML que contiene la información completa de nuestro servicio web como por ejemplo los métodos que implementa, los parámetros que recibe y devuelve e inclusive la descripción de nuevos tipos de datos.

El documento WSDL se puede generar manualmente o utilizando la clase Zend_Soap_Wsdl que viene con el framework. Estos dos métodos son bastantes tediosos y requieren un amplio conocimiento del estándar SOAP.

La mejor forma de crear el documento WSDL es utilizando la clase Zend_Soap_AutoDiscover que permite generarlo de forma automática.

Para esta implementación solo necesitas las siguientes carpetas y archivos del framework:

WSDL manual	WSDL automático (recomendada)
Zend Soap Server	Zend Server Soap Uri Validate Hostname Abstract.php Hostname.php Interface.php Ip.php Loader.php Registry.php Uri.php

soap / servidor.php

El código del servidor es bastante simple. Agregamos nuestra raiz al path del sistema para que los require_once busquen a partir de la raíz y así encuentren el framework de Zend sin necesidad de colocar una ruta completa o relativa.

Luego incluimos nuestro archivo miWebService.php y verificamos si se ha solicitado el documento WSDL o es una petición normal. Si se está solicitando el documento WSDL usamos la clase AutoDiscover para generar el documento de forma automática en base a mi clase miWebService, de lo contrario atendemos la petición utilizando la clase miWebService.

Aquí va el código:

<?php
// Agregamos la raíz al path para los require_once
set_include_path(get_include_path() .
                 PATH_SEPARATOR .
                 realpath(dirname(__FILE__) . "/../"));

// Incluimos nuestra clase que tiene el servicio web
require_once('miWebService.php');

if ($_SERVER['QUERY_STRING'] == 'wsdl')
{
	// Utilizamos la clase Zend_Soap_AutoDiscover para
	// generar de forma automática el WSDL
	require_once('Zend/Soap/AutoDiscover.php');
	$wsdl = new Zend_Soap_AutoDiscover();
	$wsdl->setClass('miWebService');
	$wsdl->handle();
}
else
{
	// Calculamos la ruta del WSDL del servidor
	$wsdl_url = sprintf('http://%s%s?wsdl', $_SERVER['HTTP_HOST'], $_SERVER['SCRIPT_NAME']);    

	// Creamos un servidor que atienda en base al WSDL generado
	require_once('Zend/Soap/Server.php');
	$server = new SoapServer($wsdl_url);
	$server->setClass('miWebService');
	$server->handle();
}

La ruta de tu documento WSDL es http://localhost/soap/servidor.php?wsdl 

soap / cliente.php

En el cliente vamos a consultar a nuestros tres métodos declarados. El código es bastante simple así que aquí va:

<?php
// Agregamos la raíz al path para que podamos
// incluir Zend de forma directa
set_include_path(get_include_path() .
                 PATH_SEPARATOR .
                 realpath(dirname(__FILE__) . "/../"));

//---------------------------------------------------------------
// Creamos un cliente soap
//---------------------------------------------------------------
require_once("Zend/Soap/Client.php");
$wsdl_url = "http://localhost/soap/servidor.php?wsdl";
$cliente = new Zend_Soap_Client($wsdl_url);

//---------------------------------------------------------------
// Saludamos en varios idiomas
//---------------------------------------------------------------
echo "<h1>Metodo Saludame</h1>";
foreach (array("es", "en", "fr", "gr") as $idioma)
{
	echo "<strong>$idioma: </strong>";
	echo $cliente->Saludame("Copstone", $idioma);
	echo "<br/>";
}

//---------------------------------------------------------------
// Sumamos una serie de numeros aleatorios
//---------------------------------------------------------------
echo "<h1>Metodo Sumar</h1>";
$numeros = array();
for ($i=0; $i<5; $i++)
{
	$numeros[$i] = rand()%100;
	printf("%4d<br/>", $numeros[$i]);
}
$suma = $cliente->Sumar($numeros);
echo "<strong>SUMA: </strong>" . $suma;

//---------------------------------------------------------------
// Calulamos la informacion de un rectangulo
//---------------------------------------------------------------
echo "<h1>Metodo InfoRectangulo</h1>";
// Incluyo miWebService.php para usar Rectangulo e Informacion
require_once("miWebService.php");
$rect = new Rectangulo();
$rect->ancho = 20;
$rect->altura = 30;
$info = $cliente->InfoRectangulo($rect);

echo "Rectangulo de {$rect->ancho}x{$rect->altura}<br/>";
echo "Area: {$info->area}<br/>";
echo "Perimetro: {$info->perimetro}<br/>";
echo "Hypotenusa: {$info->hypotenusa}<br/>";
if ($info->esCuadrado)
	echo "Es Cuadrado<br/>";
else
	echo "Es Rectangular<br/>";

 

Implementando el web service con XML-RPC

Con XML-RPC no necesitamos definir es bastante más directo.

Para esta implementación solo necesitas las siguientes carpetas y archivos del framework:

XML-RPC normal
Zend Http Loader Server Uri Validate Hostname Abstract.php Hostname.php Interface.php Ip.php XmlRpc Loader.php Registry.php Uri.php

xmlrpc / servidor.php

El código es bastante parecido a SOAP pero no necesita WSDL:

<?php
// Agregamos la raíz al path para que podamos
// incluir Zend de forma directa
set_include_path(get_include_path() .
                 PATH_SEPARATOR .
                 realpath(dirname(__FILE__) . "/../"));

// Incluimos nuestra clase que tiene el servicio web
require_once('miWebService.php');
require_once('Zend/XmlRpc/Server.php');

$server = new Zend_XmlRpc_Server();
$server->setClass('miWebService');
echo $server->handle();

xmlrpc / cliente.php

En el cliente solo vamos a consultar los primeros dos métodos debido a que el tercero necesita recibir un tipo de dato Rectangulo que no es soportado por XML-RPC por ser nuestro propio tipo de dato.

<?php
// Agregamos la raíz al path para que podamos
// incluir Zend de forma directa
set_include_path(get_include_path() .
                 PATH_SEPARATOR .
                 realpath(dirname(__FILE__) . "/../"));

//---------------------------------------------------------------
// Creamos un cliente xml-rpc
//---------------------------------------------------------------
require_once("Zend/XmlRpc/Client.php");
$xmlrpc_url = "http://localhost/xmlrpc/servidor.php";
$cliente = new Zend_XmlRpc_Client($xmlrpc_url);

//---------------------------------------------------------------
// Saludamos en varios idiomas
//---------------------------------------------------------------
echo "<h1>Metodo Saludame</h1>";
foreach (array("es", "en", "fr", "gr") as $idioma)
{
	echo "<strong>$idioma: </strong>";
	echo $cliente->call("Saludame", array("Copstone", $idioma));
	echo "<br/>";
}

//---------------------------------------------------------------
// Sumamos una serie de numeros aleatorios
//---------------------------------------------------------------
echo "<h1>Metodo Sumar</h1>";
$numeros = array();
for ($i=0; $i<5; $i++)
{
	$numeros[$i] = rand()%100;
	printf("%4d<br/>", $numeros[$i]);
}
$suma = $cliente->call("Sumar", array($numeros));
echo "<strong>SUMA: </strong>" . $suma;

Conclusión

Gracias a las clases del Zend Framework, no me tengo que preocupar del estándar ni como funciona y puedo generar servicios web en cuestión de minutos.

Al separar mi servicio web en un archivo adicional (miWebService.php) puedo reutilizar la clase para servir por SOAP o XML-RPC sin problemas.

Para agregar más métodos a mi servicio web, simplemente tengo que agregar funciones a mi clase miWebService.

Mi servicios web de SOAP y XML-RPC pueden ser consultados desde cualquier aplicación ya que respetan todos los estándares.

---

---

Comentarios (36)