XML-RPC - Guide rapide

RPC signifie Remote Procedure Call. Comme son nom l'indique, il s'agit d'un mécanisme pour appeler une procédure ou une fonction disponible sur un ordinateur distant. Le RPC est une technologie beaucoup plus ancienne que le Web. En effet, RPC offre aux développeurs un mécanisme pour définir des interfaces qui peuvent être appelées sur un réseau. Ces interfaces peuvent être aussi simples qu'un seul appel de fonction ou aussi complexes qu'une grande API.

Qu'est-ce que XML-RPC?

XML-RPC est l'une des approches de service Web les plus simples et les plus infaillibles qui permet aux ordinateurs d'appeler facilement des procédures sur d'autres ordinateurs.

XML-RPC permet aux programmes d'effectuer des appels de fonction ou de procédure sur un réseau.
XML-RPC utilise le protocole HTTP pour transmettre des informations d'un ordinateur client à un ordinateur serveur.
XML-RPC utilise un petit vocabulaire XML pour décrire la nature des demandes et des réponses.
Le client XML-RPC spécifie un nom de procédure et des paramètres dans la requête XML, et le serveur renvoie une erreur ou une réponse dans la réponse XML.
Les paramètres XML-RPC sont une simple liste de types et de contenu - les structures et les tableaux sont les types les plus complexes disponibles.
XML-RPC n'a aucune notion d'objets et aucun mécanisme pour inclure des informations qui utilisent un autre vocabulaire XML.
Cependant, avec XML-RPC et les services Web, le Web devient un ensemble de connexions procédurales où les ordinateurs échangent des informations le long de chemins étroitement liés.
XML-RPC est apparu au début de 1998; il a été publié par UserLand Software et initialement implémenté dans leur produit Frontier.

Pourquoi XML-RPC?

Si vous avez besoin d'intégrer plusieurs environnements informatiques, mais que vous n'avez pas besoin de partager directement des structures de données complexes, vous constaterez que XML-RPC vous permet d'établir des communications rapidement et facilement.

Même si vous travaillez dans un seul environnement, vous constaterez peut-être que l'approche RPC facilite la connexion de programmes qui ont des modèles de données ou des attentes de traitement différents et qu'elle peut fournir un accès facile à la logique réutilisable.

XML-RPC est un excellent outil pour établir une grande variété de connexions entre ordinateurs.
XML-RPC offre aux intégrateurs la possibilité d'utiliser un vocabulaire et une approche standard pour l'échange d'informations.
Le domaine d'application le plus évident de XML-RPC est la connexion de différents types d'environnements, permettant à Java de communiquer avec Perl, Python, ASP, etc.

Présentation technique de XML-RPC

XML-RPC se compose de trois parties relativement petites:

XML-RPC data model : Ensemble de types à utiliser pour transmettre des paramètres, des valeurs de retour et des erreurs (messages d'erreur).
XML-RPC request structures : Une requête HTTP POST contenant des informations sur la méthode et les paramètres.
XML-RPC response structures : Une réponse HTTP qui contient des valeurs de retour ou des informations d'erreur.

Nous étudierons ces trois composantes dans les trois prochains chapitres.

La spécification XML-RPC définit six types de données de base et deux types de données composés qui représentent des combinaisons de types.

Types de données de base dans XML-RPC

Type	Valeur	Exemples
int ou i4	Entiers 32 bits compris entre - 2 147 483 648 et 2 147 483 647.	<int> 27 </int> <i4> 27 </i4>
double	Nombres à virgule flottante 64 bits	<double> 27.31415 </double> <double> -1,1465 </double>
Booléen	vrai (1) ou faux (0)	<boolean> 1 </boolean> <boolean> 0 </boolean>
chaîne	Texte ASCII, bien que de nombreuses implémentations prennent en charge Unicode	<string> Bonjour </string> <string> dingue! @ </string>
dateTime.iso8601	Dates au format ISO8601: CCAAMMJJTHH: MM: SS	<dateTime.iso8601> 20021125T02: 20: 04 </dateTime.iso8601> <dateTime.iso8601> 20020104T17: 27: 30 </dateTime.iso8601>
base64	Informations binaires codées en Base 64, telles que définies dans la RFC 2045	<base64> SGVsbG8sIFdvcmxkIQ == </base64>

Ces types de base sont toujours inclus dans des éléments de valeur . Les chaînes (et uniquement les chaînes) peuvent être incluses dans un élément de valeur mais omettre l' élément de chaîne . Ces types de base peuvent être combinés en deux types, tableaux et structures plus complexes. Les tableaux représentent des informations séquentielles, tandis que les structures représentent des paires nom-valeur, tout comme les tables de hachage, les tableaux associatifs ou les propriétés.

Les tableaux sont indiqués par l' élément de tableau , qui contient un élément de données contenant la liste des valeurs. Comme les autres types de données, l' élément de tableau doit être inclus dans un élément de valeur . Par exemple, le tableau suivant contient quatre chaînes:

<value>
   <array>
      <data>
         <value><string>This </string></value>
         <value><string>is </string></value>
         <value><string>an </string></value>
         <value><string>array.</string></value>
      </data>
   </array>
</value>

Le tableau suivant contient quatre entiers:

<value>
   <array>
      <data>
         <value><int>7</int></value>
         <value><int>1247</int></value>
         <value><int>-91</int></value>
         <value><int>42</int></value>
      </data>
   </array>
</value>

Les tableaux peuvent également contenir des mélanges de différents types, comme illustré ici:

<value>
   <array>
      <data>
         <value><boolean>1</boolean></value>
         <value><string>Chaotic collection, eh?</string></value>
         <value><int>-91</int></value>
         <value><double>42.14159265</double></value>
      </data>
   </array>
</value>

La création de tableaux multidimensionnels est simple - ajoutez simplement un tableau à l'intérieur d'un tableau:

<value>
   <array>
      <data>
		
         <value>
            <array>
               <data>
                  <value><int>10</int></value>
                  <value><int>20</int></value>
                  <value><int>30</int></value>
               </data>
            </array>
         </value>
			
         <value>
            <array>
               <data>
                  <value><int>15</int></value>
                  <value><int>25</int></value>
                  <value><int>35</int></value>
               </data>
            </array>
         </value>
			
      </data>
   </array>
</value>

Une structure simple pourrait ressembler à:

<value>
   <struct>
      <member>
         <name>givenName</name>
         <value><string>Joseph</string></value>
      </member>
		
      <member>
         <name>familyName</name>
         <value><string>DiNardo</string></value>
      </member>
		
      <member>
         <name>age</name>
         <value><int>27</int></value>
      </member>
   </struct>
</value>

De cette façon, vous pouvez implémenter presque tous les types de données pris en charge par n'importe quel langage de programmation.

Les requêtes XML-RPC sont une combinaison de contenu XML et d'en-têtes HTTP. Le contenu XML utilise la structure de typage des données pour transmettre des paramètres et contient des informations supplémentaires identifiant la procédure appelée, tandis que les en-têtes HTTP fournissent un wrapper pour transmettre la requête sur le Web.

Chaque requête contient un seul document XML, dont l'élément racine est un élément methodCall . Chaque élément methodCall contient un élément methodName et un élément params . L' élément methodName identifie le nom de la procédure à appeler, tandis que l' élément params contient une liste de paramètres et leurs valeurs. Chaque élément params comprend une liste d'éléments param qui à leur tour contiennent des éléments value .

Par exemple, pour passer une requête à une méthode appelée circleArea , qui prend un paramètre Double (pour le rayon), la requête XML-RPC ressemblerait à ceci:

<?xml version="1.0"?>
<methodCall>
   <methodName>circleArea</methodName>
      <params>
         <param>
            <value><double>2.41</double></value>
         </param>
      </params>
</methodCall>

Les en-têtes HTTP de ces demandes refléteront les expéditeurs et le contenu. Le modèle de base se présente comme suit:

POST /target HTTP 1.0
User-Agent: Identifier
Host: host.making.request
Content-Type: text/xml
Content-Length: length of request in bytes

Par exemple, si la méthode circleArea était disponible à partir d'un serveur XML-RPC écoutant sur / xmlrpc , la requête pourrait ressembler à ceci :

POST /xmlrpc HTTP 1.0
User-Agent: myXMLRPCClient/1.0
Host: 192.168.124.2
Content-Type: text/xml
Content-Length: 169

Assemblé, la demande entière ressemblerait à:

POST /xmlrpc HTTP 1.0
User-Agent: myXMLRPCClient/1.0
Host: 192.168.124.2
Content-Type: text/xml
Content-Length: 169
<?xml version="1.0"?>
<methodCall>
   <methodName>circleArea</methodName>
      <params>
         <param>
            <value><double>2.41</double></value>
         </param>
      </params>
</methodCall>

C'est une requête HTTP ordinaire, avec une charge utile soigneusement construite.

Les réponses ressemblent beaucoup à des demandes, avec quelques rebondissements supplémentaires. Si la réponse est réussie - la procédure a été trouvée, exécutée correctement et résultats renvoyés - alors la réponse XML-RPC sera beaucoup comme une demande, à l' exception que le methodCall élément est remplacé par un methodResponse élément et il n'y a pas methodName élément:

<?xml version="1.0"?>
<methodResponse>
   <params>
      <param>
         <value><double>18.24668429131</double></value>
      </param>
   </params>
</methodResponse>

Une réponse XML-RPC ne peut contenir qu'un seul paramètre.
Ce paramètre peut être un tableau ou une structure, il est donc possible de renvoyer plusieurs valeurs.
Il est toujours nécessaire de renvoyer une valeur en réponse. Une "valeur de succès" - peut-être une valeur booléenne définie sur true (1).

Comme les demandes, les réponses sont empaquetées en HTTP et ont des en-têtes HTTP. Toutes les réponses XML-RPC utilisent le code de réponse 200 OK, même si une erreur est contenue dans le message. Les en-têtes utilisent une structure commune similaire à celle des requêtes, et un ensemble typique d'en-têtes peut ressembler à ceci:

HTTP/1.1 200 OK
Date: Sat, 06 Oct 2001 23:20:04 GMT
Server: Apache.1.3.12 (Unix)
Connection: close
Content-Type: text/xml
Content-Length: 124

XML-RPC nécessite uniquement la prise en charge de HTTP 1.0, mais HTTP 1.1 est compatible.
Le Content-Type doit être défini sur text / xml.
L'en-tête Content-Length spécifie la longueur de la réponse en octets.

Une réponse complète, avec les deux en-têtes et une charge utile de réponse, ressemblerait à ceci:

HTTP/1.1 200 OK
Date: Sat, 06 Oct 2001 23:20:04 GMT
Server: Apache.1.3.12 (Unix)
Connection: close
Content-Type: text/xml
Content-Length: 124

<?xml version="1.0"?>
<methodResponse>
   <params>
      <param>
         <value><double>18.24668429131</double></value>
      </param>
   </params>
</methodResponse>

Une fois la réponse envoyée du serveur XML-RPC au client XML-RPC, la connexion est fermée. Les demandes de suivi doivent être envoyées sous forme de connexions XML-RPC distinctes.

Les erreurs XML-RPC sont un type de réponses. S'il y avait un problème lors du traitement d'une requête XML-RPC, l' élément methodResponse contiendra un élément fault au lieu d'un élément params. L'élément fault, comme l' élément params , n'a qu'une seule valeur indiquant que quelque chose s'est mal passé. Une réponse d'erreur peut ressembler à:

<?xml version="1.0"?>
<methodResponse>
   <fault>
      <value><string>No such method!</string></value>
   </fault>
</methodResponse>

Un défaut aura également un code d'erreur. XML-RPC ne standardise pas du tout les codes d'erreur. Vous devrez consulter la documentation des packages particuliers pour voir comment ils gèrent les erreurs.

Une réponse d'erreur pourrait également ressembler à:

<?xml version="1.0"?>
<methodResponse>
   <fault>
      <value>
         <struct>
            <member>
               <name>code</name>
               <value><int>26</int></value>
            </member>
				
            <member>
               <name>message</name>
               <value><string>No such method!</string></value>
            </member>
				
         </struct>
      </value>
   </fault>
</methodResponse>

Pour démontrer XML-RPC, nous allons créer un serveur qui utilise Java pour traiter les messages XML-RPC, et nous allons créer un client Java pour appeler des procédures sur ce serveur.

Le côté Java de la conversation utilise Apache XML-RPC du projet Apache XML, disponible sur http://xml.apache.org/xmlrpc/

Mettez tous les fichiers .jar dans le chemin approprié et créons un client et un petit serveur XML-RPC en utilisant JAVA.

Client XML-RPC

Écrivons un client XML-RPC pour appeler une fonction appelée fonction somme . Cette fonction prend deux paramètres et renvoie leur somme.

import java.util.*;
import org.apache.xmlrpc.*;

public class JavaClient 
{
   public static void main (String [] args) 
   {
      try {

         XmlRpcClient client = new XmlRpcClient("http://localhost/RPC2"); 
         Vector params = new Vector();
         params.addElement(new Integer(17));
         params.addElement(new Integer(13));

         Object result = server.execute("sample.sum", params);

         int sum = ((Integer) result).intValue();
         System.out.println("The sum is: "+ sum);

      } catch (Exception exception) {
         System.err.println("JavaClient: " + exception);
      }
   }
}

Voyons ce qui s'est passé dans l'exemple de client ci-dessus.

Le package Java org.apache.xmlrpc contient des classes pour les clients XML-RPC Java et le serveur XML-RPC, par exemple XmlRpcClient.
Le package java.util est nécessaire pour la classe Vector.
La fonction server.execute (...) envoie la requête au serveur. La procédure sum (17,13) est appelée sur le serveur comme s'il s'agissait d'une procédure locale. La valeur de retour d'un appel de procédure est toujours un Object.
Ici, "échantillon" désigne un gestionnaire défini dans le serveur.
Notez que tous les paramètres de l'appel de procédure sont toujours collectés dans un vecteur.
La classe XmlRpcClient est construite en spécifiant "l'adresse Web" de la machine serveur suivie de / RPC2.
- localhost - signifie la machine locale
- Vous pouvez spécifier un numéro IP au lieu de localhost, par exemple 194.80.215.219
- Vous pouvez spécifier un nom de domaine comme xyz.dyndns.org
- Vous pouvez spécifier un numéro de port avec le nom de domaine en tant que xyz.dyndns.org:8080. Le port par défaut est 80
Notez que le résultat de l'appel de procédure distante est toujours un objet et qu'il doit être transtypé dans le type approprié.
Lorsque des problèmes surviennent (pas de connexion, etc.), une exception est levée et elle doit être interceptée à l'aide de l' instruction catch .

En raison de l'appel ci-dessus, un client envoie le message suivant au serveur. Notez que cela est géré par server.execute (...) en interne et que vous n'avez rien à voir avec cela.

<?xml version="1.0" encoding="ISO-8859-1"?>
<methodCall>
   <methodName>sample.sum</methodName>
   <params>
      <param>
         <value><int>17</int></value>
      </param>
		 
      <param>
         <value><int>13</int></value>
      </param>
   </params>
</methodCall>

Serveur XML-RPC

Voici le code source de XML-RPC Server écrit en Java. Il utilise les classes intégrées disponibles dans org.apache.xmlrpc. *

import org.apache.xmlrpc.*;

public class JavaServer 
{ 

   public Integer sum(int x, int y) 
   {
      return new Integer(x+y);
   }

   public static void main (String [] args) 
   {
      try {

         System.out.println("Attempting to start XML-RPC Server...");
         WebServer server = new WebServer(80);
         server.addHandler("sample", new JavaServer());
         server.start();
         System.out.println("Started successfully.");
         System.out.println("Accepting requests. (Halt program to stop.)");
      } catch (Exception exception) 
      {
         System.err.println("JavaServer: " + exception);
      }
   }
}

Voyons ce que nous avons fait dans l'exemple de serveur ci-dessus.

Le package org.apache.xmlrpc contient la classe WebServer pour une implémentation de serveur XML-RPC.
La somme de procédure appelée à distance est implémentée en tant que méthode publique dans une classe.
Une instance de la même classe de serveur est alors associée à un gestionnaire accessible par le client.
Le serveur est initialisé par le numéro de port (ici: 80).
Lorsque des problèmes surviennent, une exception est levée et doit être interceptée à l'aide de l' instruction catch .

Pour l'appel mentionné dans l'exemple de client donné, le serveur renvoie la réponse suivante au client:

<?xml version="1.0" encoding="ISO-8859-1"?>
<methodResponse>
   <params>
      <param>
         <value><int>30</int></value>
      </param>
   </params>
</methodResponse>

Maintenant que votre serveur est prêt, compilez-le et exécutez-le à votre invite comme suit:

C:\ora\xmlrpc\java>java JavaServer
Attempting to start XML-RPC Server...
Started successfully.
Accepting requests. (Halt program to stop.)

Maintenant, pour tester la fonctionnalité, appelez ce serveur comme suit:

C:\ora\xmlrpc\java>java JavaClient
30

Dans ce didacticiel, vous avez appris ce qu'est XML-RPC et pourquoi avons-nous besoin de XML-RPC. Nous avons discuté de son modèle de données, ainsi que du format des messages de demande et de réponse à échanger entre le client et le serveur. Nous avons donné un exemple pour montrer comment le client et le serveur XML-RPC fonctionnent pour échanger des informations.

XML-RPC est un concept très simple avec un ensemble limité de capacités. Ces limitations sont à bien des égards la caractéristique la plus intéressante de XML-RPC, car elles réduisent considérablement la difficulté d'implémentation du protocole et de tester son interopérabilité.

Alors que XML-RPC est simple, l'application créative d'outils simples peut créer des architectures sophistiquées et puissantes. Dans les cas où une grande variété de systèmes différents doivent communiquer, XML-RPC peut être le plus petit dénominateur commun le plus approprié.

Et après?

L'étape suivante consiste à apprendre WSDL et SOAP.

WSDL

WSDL est un langage basé sur XML pour décrire les services Web et comment y accéder.

WSDL décrit un service Web, ainsi que le format de message et les détails du protocole pour le service Web.

Si vous souhaitez en savoir plus sur WSDL, veuillez suivre notre tutoriel WSDL .

SAVON

SOAP est un protocole XML simple qui permet aux applications d'échanger des informations via HTTP.

Si vous souhaitez en savoir plus sur SOAP, veuillez suivre notre tutoriel SOAP .

↰ Previous page