XML-RPC - Guida rapida

RPC è l'acronimo di Remote Procedure Call. Come indica il nome, è un meccanismo per chiamare una procedura o una funzione disponibile su un computer remoto. RPC è una tecnologia molto più vecchia del Web. In effetti, RPC offre agli sviluppatori un meccanismo per definire le interfacce che possono essere chiamate su una rete. Queste interfacce possono essere semplici come una singola chiamata di funzione o complesse come una grande API.

Cos'è XML-RPC?

XML-RPC è tra gli approcci ai servizi Web più semplici e infallibili che rendono facile per i computer chiamare procedure su altri computer.

XML-RPC consente ai programmi di effettuare chiamate di funzioni o procedure attraverso una rete.
XML-RPC utilizza il protocollo HTTP per passare le informazioni da un computer client a un computer server.
XML-RPC utilizza un piccolo vocabolario XML per descrivere la natura delle richieste e delle risposte.
Il client XML-RPC specifica un nome di procedura e parametri nella richiesta XML e il server restituisce un errore o una risposta nella risposta XML.
I parametri XML-RPC sono un semplice elenco di tipi e contenuti: gli struct e gli array sono i tipi più complessi disponibili.
XML-RPC non ha la nozione di oggetti e nessun meccanismo per includere informazioni che utilizzano altri vocaboli XML.
Con XML-RPC e i servizi Web, tuttavia, il Web diventa una raccolta di connessioni procedurali in cui i computer scambiano informazioni lungo percorsi strettamente legati.
XML-RPC è emerso all'inizio del 1998; è stato pubblicato da UserLand Software e inizialmente implementato nel loro prodotto Frontier.

Perché XML-RPC?

Se è necessario integrare più ambienti di elaborazione, ma non è necessario condividere direttamente strutture di dati complesse, scoprirai che XML-RPC ti consente di stabilire comunicazioni rapidamente e facilmente.

Anche se si lavora in un unico ambiente, è possibile che l'approccio RPC semplifichi la connessione di programmi con modelli di dati o aspettative di elaborazione diversi e che possa fornire un facile accesso alla logica riutilizzabile.

XML-RPC è uno strumento eccellente per stabilire un'ampia varietà di connessioni tra computer.
XML-RPC offre agli integratori l'opportunità di utilizzare un vocabolario e un approccio standard per lo scambio di informazioni.
Il campo di applicazione più ovvio di XML-RPC è il collegamento di diversi tipi di ambienti, consentendo a Java di dialogare con Perl, Python, ASP e così via.

Panoramica tecnica XML-RPC

XML-RPC è costituito da tre parti relativamente piccole:

XML-RPC data model : Un insieme di tipi da utilizzare nel passaggio di parametri, valori restituiti e errori (messaggi di errore).
XML-RPC request structures : Una richiesta HTTP POST contenente informazioni sul metodo e sui parametri.
XML-RPC response structures : Una risposta HTTP che contiene valori di ritorno o informazioni sull'errore.

Studieremo tutte queste tre componenti nei prossimi tre capitoli.

La specifica XML-RPC definisce sei tipi di dati di base e due tipi di dati composti che rappresentano combinazioni di tipi.

Tipi di dati di base in XML-RPC

genere	Valore	Esempi
int o i4	Intero a 32 bit compreso tra - 2.147.483.648 e 2.147.483.647.	<int> 27 </int> <i4> 27 </i4>
Doppio	Numeri in virgola mobile a 64 bit	<double> 27.31415 </double> <double> -1,1465 </double>
Booleano	vero (1) o falso (0)	<boolean> 1 </boolean> <boolean> 0 </boolean>
corda	Testo ASCII, sebbene molte implementazioni supportino Unicode	<string> Ciao </string> <string> pazzi! @ </string>
dateTime.iso8601	Date in formato ISO8601: CCYYMMDDTHH: MM: SS	<dateTime.iso8601> 20021125T02: 20: 04 </dateTime.iso8601> <dateTime.iso8601> 20020104T17: 27: 30 </dateTime.iso8601>
base64	Informazioni binarie codificate come Base 64, come definito in RFC 2045	<base64> SGVsbG8sIFdvcmxkIQ == </base64>

Questi tipi di base sono sempre racchiusi in elementi di valore . Le stringhe (e solo le stringhe) possono essere racchiuse in un elemento valore ma omettono l' elemento stringa . Questi tipi di base possono essere combinati in due tipi, array e strutture più complessi. Gli array rappresentano informazioni sequenziali, mentre gli struct rappresentano coppie nome-valore, in modo molto simile agli hashtable, agli array associativi o alle proprietà.

Gli array sono indicati dall'elemento array , che contiene un elemento dati che contiene l'elenco di valori. Come altri tipi di dati, l' elemento array deve essere racchiuso in un elemento value . Ad esempio, il seguente array contiene quattro stringhe:

<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>

Il seguente array contiene quattro numeri interi:

<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>

Gli array possono contenere anche miscele di diversi tipi, come mostrato di seguito:

<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 creazione di array multidimensionali è semplice: basta aggiungere un array all'interno di un array:

<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>

Una struttura semplice potrebbe essere simile a:

<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>

In questo modo puoi implementare quasi tutti i tipi di dati supportati da qualsiasi linguaggio di programmazione.

Le richieste XML-RPC sono una combinazione di contenuto XML e intestazioni HTTP. Il contenuto XML utilizza la struttura di tipizzazione dei dati per passare i parametri e contiene informazioni aggiuntive che identificano quale procedura viene chiamata, mentre le intestazioni HTTP forniscono un wrapper per il passaggio della richiesta sul Web.

Ogni richiesta contiene un singolo documento XML, il cui elemento radice è un elemento methodCall . Ogni elemento methodCall contiene un elemento methodName e un elemento params . L' elemento methodName identifica il nome della procedura da chiamare, mentre l' elemento params contiene un elenco di parametri e dei loro valori. Ogni elemento params include un elenco di elementi param che a loro volta contengono elementi value .

Ad esempio, per passare una richiesta a un metodo chiamato circleArea , che accetta un parametro Double (per il raggio), la richiesta XML-RPC sarà simile a:

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

Le intestazioni HTTP per queste richieste rifletteranno i mittenti e il contenuto. Il modello di base è il seguente:

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

Ad esempio, se il metodo circleArea era disponibile da un server XML-RPC in ascolto su / xmlrpc , la richiesta potrebbe essere simile a:

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

Assemblata, l'intera richiesta sarebbe simile a:

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>

È una normale richiesta HTTP, con un payload costruito con cura.

Le risposte sono molto simili alle richieste, con alcuni colpi di scena in più. Se la risposta ha esito positivo (la procedura è stata trovata, eseguita correttamente e ha restituito risultati), la risposta XML-RPC sarà molto simile a una richiesta, tranne per il fatto che l' elemento methodCall è sostituito da un elemento methodResponse e non è presente alcun elemento methodName :

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

Una risposta XML-RPC può contenere solo un parametro.
Quel parametro può essere un array o una struttura, quindi è possibile restituire più valori.
È sempre necessario restituire un valore in risposta. Un "valore di successo", forse un valore booleano impostato su true (1).

Come le richieste, le risposte sono impacchettate in HTTP e hanno intestazioni HTTP. Tutte le risposte XML-RPC utilizzano il codice di risposta 200 OK, anche se nel messaggio è contenuto un errore. Le intestazioni utilizzano una struttura comune simile a quella delle richieste e un tipico insieme di intestazioni potrebbe essere simile a:

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 richiede solo il supporto HTTP 1.0, ma HTTP 1.1 è compatibile.
Il Content-Type deve essere impostato su text / xml.
L'intestazione Content-Length specifica la lunghezza della risposta in byte.

Una risposta completa, con entrambe le intestazioni e un payload di risposta, sarebbe simile a:

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>

Dopo che la risposta è stata consegnata dal server XML-RPC al client XML-RPC, la connessione viene chiusa. Le richieste di follow-up devono essere inviate come connessioni XML-RPC separate.

Gli errori XML-RPC sono un tipo di risposte. Se si è verificato un problema nell'elaborazione di una richiesta XML-RPC, l' elemento methodResponse conterrà un elemento fault invece di un elemento params. L'elemento fault, come l' elemento params , ha un solo valore che indica che qualcosa è andato storto. Una risposta all'errore potrebbe essere simile a:

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

Un guasto avrà anche un codice di errore. XML-RPC non standardizza affatto i codici di errore. Avrai bisogno di controllare la documentazione per particolari pacchetti per vedere come gestiscono gli errori.

Una risposta all'errore potrebbe anche essere simile a:

<?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>

Per dimostrare XML-RPC, creeremo un server che utilizza Java per elaborare i messaggi XML-RPC e creeremo un client Java per chiamare le procedure su quel server.

Il lato Java della conversazione utilizza Apache XML-RPC di Apache XML Project, disponibile all'indirizzo http://xml.apache.org/xmlrpc/

Metti tutti i file .jar nel percorso appropriato e creiamo un client e un piccolo server XML-RPC utilizzando JAVA.

Client XML-RPC

Scriviamo un client XML-RPC per chiamare una funzione chiamata funzione somma . Questa funzione accetta due parametri e restituisce la loro somma.

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);
      }
   }
}

Vediamo cosa è successo nel client di esempio sopra.

Il pacchetto Java org.apache.xmlrpc contiene classi per client Java XML-RPC e server XML-RPC, ad esempio XmlRpcClient.
Il pacchetto java.util è necessario per la classe Vector.
La funzione server.execute (...) invia la richiesta al server. La procedura sum (17,13) viene chiamata sul server come se fosse una procedura locale. Il valore di ritorno di una chiamata di procedura è sempre un Object.
Qui "sample" denota un gestore definito nel server.
Notare che tutti i parametri della chiamata di procedura sono sempre raccolti in un vettore.
La classe XmlRpcClient viene costruita specificando l '"indirizzo web" della macchina server seguito da / RPC2.
- localhost: indica la macchina locale
- È possibile specificare un numero IP invece di localhost, ad esempio 194.80.215.219
- Puoi specificare un nome di dominio come xyz.dyndns.org
- È possibile specificare un numero di porta insieme al nome di dominio come xyz.dyndns.org:8080. La porta predefinita è 80
Si noti che il risultato della chiamata di procedura remota è sempre un oggetto e deve essere eseguito il cast al tipo appropriato.
Quando si verificano problemi (nessuna connessione, ecc.), Viene lanciata un'eccezione e deve essere rilevata utilizzando l' istruzione catch .

A causa della chiamata di cui sopra, un client invia il seguente messaggio al server. Nota che questo è gestito internamente da server.execute (...) e non hai niente a che fare con esso.

<?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>

Server XML-RPC

Di seguito è riportato il codice sorgente di XML-RPC Server scritto in Java. Fa uso di classi integrate disponibili in 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);
      }
   }
}

Vediamo cosa abbiamo fatto nel server di esempio sopra.

Il pacchetto org.apache.xmlrpc contiene la classe WebServer per un'implementazione del server XML-RPC.
La procedura sum chiamata in remoto viene implementata come metodo pubblico in una classe.
Un'istanza della stessa classe server viene quindi associata a un gestore accessibile dal client.
Il server viene inizializzato dal numero di porta (qui: 80).
Quando si verificano problemi, viene generata un'eccezione che deve essere rilevata utilizzando l' istruzione catch .

Per la chiamata menzionata nel client di esempio fornito, il server invia la seguente risposta al client:

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

Ora il tuo server è pronto, quindi compilalo ed eseguilo al tuo prompt come segue:

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

Ora, per testare la funzionalità, chiama questo server come segue:

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

In questo tutorial, hai imparato cos'è XML-RPC e perché abbiamo bisogno di XML-RPC. Abbiamo discusso del suo modello di dati, nonché del formato del messaggio di richiesta e risposta da scambiare tra il client e il server. Abbiamo fornito un esempio per dimostrare come il client e il server XML-RPC funzionano per lo scambio di informazioni.

XML-RPC è un concetto molto semplice con un insieme limitato di capacità. Queste limitazioni sono per molti versi la caratteristica più interessante di XML-RPC, poiché riducono sostanzialmente la difficoltà di implementare il protocollo e testarne l'interoperabilità.

Sebbene XML-RPC sia semplice, l'applicazione creativa di strumenti semplici può creare architetture sofisticate e potenti. Nei casi in cui è necessario comunicare un'ampia varietà di sistemi diversi, XML-RPC può essere il minimo comune denominatore più appropriato.

Qual è il prossimo?

Il passaggio successivo consiste nell'apprendere WSDL e SOAP.

WSDL

WSDL è un linguaggio basato su XML per descrivere i servizi Web e come accedervi.

WSDL descrive un servizio Web, insieme al formato del messaggio e ai dettagli del protocollo per il servizio Web.

Se vuoi saperne di più su WSDL, segui il nostro tutorial WSDL .

SAPONE

SOAP è un semplice protocollo basato su XML che consente alle applicazioni di scambiare informazioni su HTTP.

Se vuoi saperne di più su SOAP, segui il nostro tutorial SOAP .

↰ Previous page