Cibernetia > Manuales > Servicios web > XML-RPC
Búsqueda personalizada







XML-RPC

XML–RPC es un protocolo de llamada remota a procedimientos que funciona sobre Internet. Es más simple que SOAP y más sencillo de implementar. XML–RPC funciona mediante intercambio de mensajes entre cliente y servidor, utilizando el protocolo HTTP para el transporte de los mensajes. XML–RPC utiliza peticiones POST de HTTP para enviar un mensaje, en formato XML, señalando:

  • El procedimiento que se va a ejecutar en el servidor
  • Los parámetros

El servidor devuelve el resultado en formato XML.

Formato de la petición XML–RPC

Ejemplo de petición:

POST /RPC2 HTTP/1.1
User-Agent: Frontier/5.1.2
Host: carlesm.com
Content-Type: text/xml
Content-Length: 186
<?xml version="1.0"?>
<methodCall>
<methodName>ejemplo.Método</methodName>
<params>
<param>
<value><i4>51</i4></value>
</param>
</params>
</methodCall>
  • La URI que se observa en primer lugar, RPC2, no está definida en el estándar. Esto permite, en caso de que el servidor de respuesta a diversos tipos de peticiones, usar dicha URI para enrutarlas.
  • Los campos User-Agent y Host son obligatorios y el valor ha de ser válido.
  • El campo Content-Type será siempre text/xml.
  • El valor de Content-Length ha de aparecer siempre y ser correcto.

El cuerpo:

  • El mensaje contiene un único elemento <methodCall> que contiene, a su vez, los subelementos
  • <methodName> que contiene la cadena con el nombre del método que se va a invocar.
  • Si el método utiliza parámetros, debe tener un subelemento <params>, con tantos <param> diferentes como parámetros tenga el método, Cada uno de los cuales posee un <value>.

Para especificar los valores de los parámetros disponemos de marcas que nos permiten especificar escalares:

  • <i4> o <int>: entero de 4 bytes con signo
  • &
  • lt;boolean>: 0 (falso) o 1 (cierto)
  • <string>: cadena ASCII
  • <double>: coma flotante con signo y de doble precisión
  • <dateTime.iso8601>: día y hora en formato iso8601
  • <base64>: binario codificado en formato base-64

Si no se especifica ningún tipo, se asignará un tipo <string> por defecto.

También es posible usar tipos complejos. Para eso existe un tipo <struct>, que presenta esta estructura:

  • Contiene subelementos de tipo <member>.
  • Cada uno de estos subelementos tiene un <name> y <value> de alguno de los diferentes tipos básicos.

Un parámetro de tipo <struct> sería, por ejemplo:

<struct>
<member>
<name>nombre</name>
<value><string>Juan Manuel</string></value>
</member>
<member>
<name>Pasaporte</name>
<value><i4>67821456</i4></value>
</member>
</struct>

Disponemos de un mecanismo para pasar valores de tipo lista (o "array") a los métodos llamados:

  • Contiene un único subelemento, que es de tipo <data>.
  • Éste puede contener un número cualquiera de subelementos <value>.

Un ejemplo:

<array>
<data>
<value><int>15</int></value>
<value><string>Hola</string></value>
<value><boolean>1</boolean></value>
<value><int>56</int></value>
</data>
<array>

Formato de la respuesta XML–RPC

La respuesta XML–RPC será una respuesta HTTP con código de estatus 200 (OK), siempre y cuando no haya un error de bajo nivel. Los errores de XML–RPC se retornarán como mensajes de HTTP correctos, notificándose éste error en el contenido del mensaje.

La respuesta tendrá este formato:

  • El Content-Type debe ser text/xml.
  • El campo Content-Length es obligatorio y deberá contener un valor correcto.
  • El cuerpo de la respuesta contendrá un único <methodResponse> con el formato:
    • Si el proceso ha sido correcto:
      • Contendrá un único campo <params>, que
      • contendrá un único campo <params>, que
      • contendrá un único campo <value>.
    • En caso de error:
      • contendrá un único <fault>, que
      • contendrá un único <value> que es un <struct> que tiene los campos
        • faultCode que es <int>, y
        • faultString que es <string>.

Una respuesta correcta de ejemplo:

HTTP/1.1 200 OK
Connection: close
Content-Length: 172
Content-Type: text/xml
Date: Fri, 24 Jul 1998 17:26:42 GMT
Server: UserLand Frontier/5.1.2
<?xml version="1.0"?> <methodResponse>
<params>
<param>
<value><string>Hola<string></value>
</param>
</params>
</methodResponse>

Una respuesta errónea sería, por ejemplo:

HTTP/1.1 200 OK
Connection: close
Content-Length: 444
Content-Type: text/xml
Date: Fri, 24 Jul 1998 17:26:42 GMT
Server: UserLand Frontier/5.1.2
<?xml version="1.0"?> <methodResponse>
<fault>
<value>
<struct>
<member>
<name>FaultCode</name>
<value><int>4</int></value>
</member>
<member>
<name>FaultString</name>
<value><int>Too many parameters</int></value>
</member>
</struct>
</value>
</fault>
</methodResponse>

Desarrollo de aplicaciones con XML–RPC

En el kit de desarrollo de aplicaciones de Java, el JDK, en su versión 1.4.2, no hay soporte para el desarrollo de aplicaciones XML–RPC. Es necesario utilizar librería de clases adicional. Por ejemplo, la librería de clases del proyecto Apache, disponible en: http://ws.apache.org/xmlrpc/.

El código del servidor de ejemplo:

import java.util.Hashtable;
import org.apache.xmlrpc.WebServer;
public class JavaServer {
public Hashtable sumAndDifference(int x, int y) {
Hashtable result = new Hashtable();
result.put("sum", new Integer(x + y));
result.put("difference", new Integer(x - y));
return result;
}
public static void main(String[] args) {
try {
WebServer server =new WebServer(9090);
server.addHandler("sample", new JavaServer());
} catch (Exception exception) {
System.err.println("JavaServer:" + exception.toString());
}
}
}

Como puede apreciarse, este servidor proporciona un método llamado: sample.sumAndDifference.

El código de un cliente para el anterior servicio sería:

XmlRpcClient server = new XmlRpcClient("192.168.100.2", 9090);
Vector params = new Vector();
params.addElement(new Integer(5));
params.addElement(new Integer(3));

Hashtable result =
(Hashtable) server.execute(
"sample.sumAndDifference",
params);
int sum = ((Integer) result.get("sum")).intValue();
int difference =
((Integer) result.get("difference")).intValue();

System.out.println(
"Sum: "
+ Integer.toString(sum)
+ ", Difference: "
+ Integer.toString(difference));

Los manuales titulados Introducción a las aplicaciones web, Instalación del servidor web y Servicios web han sido extraídos, con algunas modificaciones, del manual "Desarrollo de aplicaciones web", publicado por la UOC dentro de su máster de software libre, escrito por Carles Mateu i Piñol.

El manual tiene licencia GFDL, la cual otorga permiso para copiar, distribuir y modificar el documento según los términos de la GNU Free Documentation License, Version 1.2 o cualquiera posterior publicada por la Free Software Foundation, sin secciones invariantes ni textos de cubierta delantera o trasera.

Se puede acceder al documento original en: http://www.uoc.edu/masters/esp/img/873.pdf (versión imprimible) y http://www.uoc.edu/masters/esp/img/692.zip (versión editable, formato zip).

Manuales | Tesis: Ordenadores, Circuitos integrados...
english
Cibernetia