Basic Network Tutorial

CRS4 - http://www.crs4.it
java.net.*
Basic Network Tutorial
maggio 2004
Stefano Sanna - [email protected]
Agenda
CRS4 - http://www.crs4.it
●
●
Java e network programming
Low-level programming, network
programming e distributed computing
●
UDP e TCP
●
Client e Server
●
Applicazioni
●
XML-RPC
●
Bibliografia
●
Conclusioni
Stefano Sanna - [email protected]
CRS4 - http://www.crs4.it
Java
Stefano Sanna - [email protected]
CRS4 - http://www.crs4.it
Protocol stack
Applicazione
(HTTP, FTP...)
Applicazione
(HTTP, FTP...)
Trasporto
(UDP, FTP, RTP)
Trasporto
(UDP, FTP, RTP)
Rete
(IP)
Rete
(IP)
Hardware
Hardware
Stefano Sanna - [email protected]
Protocolli di rete
CRS4 - http://www.crs4.it
●
●
E' importante conoscere i diversi protocolli
a disposizione: i limiti, le potenzialità,
l'affidabilità, la robustezza, l'overhead
introdotto, la sicurezza, i requisiti di
memoria e calcolo
La scelta del protocollo giusto deve essere
fatta in base a:
–
banda della rete
–
affidabilità della rete (wired/wireless)
–
volume dei dati scambiati
–
...
Stefano Sanna - [email protected]
Tre livelli di sviluppo
CRS4 - http://www.crs4.it
●
L'evoluzione dei protocolli e delle
infrastrutture di rete ha portato
“idealmente” a tre livelli distinti di
programmazione e sviluppo networkoriented:
–
Low-level Network Programming
–
Network Programming
–
Distributed Computing
Stefano Sanna - [email protected]
Low-level network programming
CRS4 - http://www.crs4.it
●
●
●
Per low-level network programming
intendiamo la possibilità di scambiare dati
primitivi e complessi attraverso stream su
trasporto TCP e UDP.
Attraverso le classi Socket e ServerSocket
è possibile gestire la comunicazione
client/server per l'invio di byte[], tipi base,
oggetti serializzati
La logica di comunicazione è responsabilità
del programmatore che dovrà prevedere
opportuni codici di controllo
Stefano Sanna - [email protected]
Network Programming
CRS4 - http://www.crs4.it
●
●
●
Per network programming intendiamo
l'utilizzo di uno o più protocolli applicativi,
che si occupano di gestire la logica di
comunicazione tra client e server
A seconda del protocollo scelto, il
programmatore dispone di strumenti più o
meno complessi che nascondono i dettagli
implementativi della specifica
Esempi di protocolli applicativi: Telnet, FTP,
HTTP, SSH, NFS, NTP...
Stefano Sanna - [email protected]
Distributed Computing
CRS4 - http://www.crs4.it
●
●
Il distributed computing rappresenta la
possibilità di delocalizzare l'elaborazione
sui nodi di una rete in modo trasparente
per il programmatore ed il codice
applicativo
Attraverso opportuni meccanisimi di
binding, lookup e serializzazione di oggetti,
l'invocazione di metodi e l'accesso a
funzioni remote avviene come se risorse
fossero locali: la presenza della rete è
totalmente mascherata dalle librerie
applicative
Stefano Sanna - [email protected]
Distributed Computing
CRS4 - http://www.crs4.it
●
Esempi di distributed computing sono:
–
Java RMI: permette l'invocazione remota di
metodi in maniera trasparente per il
programmatore. Oggetti locali e remoti sono
trattati allo stesso modo
–
CORBA: permette l'interoperabilità tra
componenti software scritti in linguaggi diversi
–
Web Service: usano l'invocazione remota di
metodi attraverso scambio di documenti XML
su protocollo HTTP
●
XML-RPC
●
SOAP
Stefano Sanna - [email protected]
Stream model
CRS4 - http://www.crs4.it
●
●
●
Il sistema di I/O di Java è basato sul
modello a stream: opportuni oggetti
permettono di gestire i flussi di byte in
ingresso e in uscita
Il modello a stream permette una gestione
omogenea delle sorgenti di dati, a
prescindere dal supporto fisico (file, rete,
porta seriale, link Bluetooth...)
Attraverso un insieme componibile di filtri
(decorator) e adattatori è possibile
elaborare i byte in transito
Stefano Sanna - [email protected]
Input/Output Stream
CRS4 - http://www.crs4.it
●
●
InputStream:
–
Gestisce i flussi di byte in ingresso
–
Fornisce facility di buffering elementari
OutputStream:
–
Gestisce i flussi di byte in uscita (con buffering)
DataSource
Applicazione
Input/Output Stream
Filter 1
Filter 2
Stefano Sanna - [email protected]
Filter n
Data Stream
CRS4 - http://www.crs4.it
●
●
I tipi base quali numeri interi, numeri in
virgola mobile, valori logici e stringhe
(ASCII, Unicode, UTF) sono codificati con
più byte (non sempre indipendenti dalla
piattaforma)
Al fine di rendere la trasmissione di tali dati
trasparente rispetto alla effettiva codifica
(si pensi alla variabilità del numero di bit di
un valore numerico intero) si utilizzano i
DataStream, che offrono i metodi per
leggere/scrivere int, short, long, float,
double...
Stefano Sanna - [email protected]
Gestione caratteri: reader
CRS4 - http://www.crs4.it
●
●
L'introduzione di specifiche quali Unicode
(1.0 e 2.0) e UTF-8 ha portato alla
necessità di trattare in maniera dedicata il
trasferimento di stream di caratteri: non è
garantita, infatti, la corrispondenza
“classica” 1byte == 1char!
:-(
Gli stream Reader e Writer sono gli
strumenti utilizzati da Java per accedere a
flussi di caratteri indipendentemente dalla
codifica utilizzata
Stefano Sanna - [email protected]
Buffering
CRS4 - http://www.crs4.it
●
●
Alcuni protocolli si basano su scambio
sequenze di stringhe separate da CR+LF: il
protocollo HTTP, ad esempio, descrivere le
intestazioni (header) delle HTTP Request e
Response
La gestione dei flussi “per righe” può
essere fatta agevolmente attraverso l'uso
di classi quali il BufferedReader, che offre
metodi per la lettura “line by line”
Stefano Sanna - [email protected]
Low-level network programming
CRS4 - http://www.crs4.it
●
Introduciamo ora i concetti base per lo
sviluppo di applicazioni che utilizzano i
protocolli di comunicazione a basso livello:
–
IP
–
UDP (Datagram Packet e Datagram Socket)
–
TCP (Socket e ServerSocket)
Stefano Sanna - [email protected]
IP
CRS4 - http://www.crs4.it
●
●
La libreria standard di Java offre classi per:
–
Selezione di una specifica interfaccia di rete
sulla macchina host
–
Recuperare informazioni su un indirizzo Internet
(Ipv4 e Ipv6)
InetAddress: è la classe che incapsula un
indirizzo IP. E' utilizzata dalle classi per la
gestione dei protocolli UDP e TCP.
Stefano Sanna - [email protected]
InetAdress
CRS4 - http://www.crs4.it
●
Metodi principali dell'interfaccia pubblica:
–
InetAddress.getByName(String host)
–
InetAddress.getAllByName(String host)
–
String getHostName()
–
byte[] getAddress()
–
String getHostAddress()
Stefano Sanna - [email protected]
nslookup...
import java.net.*;
CRS4 - http://www.crs4.it
public class NSLookup {
public static void main(String[] args) {
try {
String add = InetAddress.getByName(args[0]).getHostAddress();
System.out.println("Host " + args[0] + " has IP: " + add);
}
catch(Exception e) {
System.out.println("Error: " + args[0]);
}
}
}
Stefano Sanna - [email protected]
UDP
CRS4 - http://www.crs4.it
●
UDP: User Datagram Protocol
–
Permette di inviare/ricevere pacchetti di byte
(datagram) ad/da un host su una porta nota
–
E' un protocollo connection-less, non orientato
alla connessione (in senso stretto); non è
garantito l'ordine di arrivo dei pacchetti: è
compito dell'applicazione marcare i dati per
ricostruirne la sequenza
–
Non offre meccanismi di controllo sul corretto
invio dei dati: lo strato applicativo deve gestire
tale controllo
–
Protocolli applicativi basati su UDP: DNS, NFS...
Stefano Sanna - [email protected]
Datagram
CRS4 - http://www.crs4.it
●
Java offre alcune classi per la ricezione e
l'invio di pacchetti UDP:
–
Datagram Packet: è un classe “double-face”
usato come contenitore per l'invio e la ricezione
dei pacchetti
–
Datagram Socket: è la classe responsabile
dell'invio dei Datagram Packet ad un server
remoto e l'ascolto su una porta UDP locale
Stefano Sanna - [email protected]
Datagram Packet
CRS4 - http://www.crs4.it
●
Pacchetti in uscita
–
Sono costruiti a partire da un byte[] contenente
i dati da inviare:
DatagramPacket(byte[] buf, int length,
InetAddress address, int port)
●
Pacchetti in ingresso
–
Sono costruiti a partire da un byte[] usato come
buffer per i dati in arrivo:
DatagramPacket(byte[] buf, int length)
Stefano Sanna - [email protected]
Datagram Packet
CRS4 - http://www.crs4.it
●
Metodi principali dell'interfaccia pubblica:
–
byte[] getData()
–
InetAddress getAddress()
–
int getLength()
–
int getPort()
Stefano Sanna - [email protected]
Datagram Socket
CRS4 - http://www.crs4.it
●
●
E' responsabile dell'invio e della ricezione
dei Datagram Packet. Metodi principali
dell'interfaccia pubblica:
–
DatagramSocket(int port)
–
int getLocalPort()
–
void send(DatagramPacket p)
–
void receive(DatagramPacket p)
E' possibile assegnare staticamente un
Datagram Socket ad un host remoto
(ferme restando tutte le caratteristiche di
UDP)
Stefano Sanna - [email protected]
TCP/IP
CRS4 - http://www.crs4.it
●
Il TCP/IP è un protocollo a livello di
trasporto:
–
Orientato alla connessione: si stabilisce un
canale virtuale tra client e server che rimane
attivo sino alla chiusura della connessione o
malfunzionamento della rete
–
Trasparente: l'implementazione si occupa di
assemblare la corretta sequenza dei pacchetti
in arrivo
–
Affidabile: in caso di pacchetti persi o corrotti,
lo stack si occupa di chiedere la ritrasmissione
dei pacchetti mancanti
Stefano Sanna - [email protected]
Socket
CRS4 - http://www.crs4.it
●
●
La classe Socket offre i meccanismi base
per aprire una connessione TCP verso un
server remoto
Attraverso il modello basato su stream è
possibile ricevere e inviare dati in modo
trasparente rispetto alla rete fisica
utilizzata e ai meccanismi di connessione
di quest'ultima
Stefano Sanna - [email protected]
Socket
CRS4 - http://www.crs4.it
●
Metodi principali dell'interfaccia pubblica:
–
Socket(String host, int port)
–
InputStream getInputStream()
–
OutputStream getOutputStream()
–
int getPort()
–
int getLocalPort()
–
InetAddress getInetAddress()
–
InetAddress getLocalInetAddress()
–
void close()
Stefano Sanna - [email protected]
ServerSocket
CRS4 - http://www.crs4.it
●
●
La classe ServerSocket è utilizzata creare
ed assegnare server TCP ad una porta nota
Il modello di comunicazione è simmetrico:
per ogni connessione, la classe
ServerSocket restituisce una istanza di
Socket, i cui input e output stream
forniscono i canali di comunicazione verso
il client remoto
Stefano Sanna - [email protected]
ServerSocket
CRS4 - http://www.crs4.it
●
Metodi principali dell'interfaccia pubblica:
–
ServerSocket(int port)
–
Socket accept();
–
int getLocalPort()
–
InetAddress getInetAddress()
–
void close()
Stefano Sanna - [email protected]
Network games :-)
CRS4 - http://www.crs4.it
●
●
Il miglior modo per acquisire praticità con
lo sviluppo di applicazioni network-oriented
e con i protocolli più comuni è...
giocarci! :-)
Sistemi asincroni, multithreading,
sicurezza, accesso concorrente ai dati sono
problematiche comuni a molt
Stefano Sanna - [email protected]
Echo
CRS4 - http://www.crs4.it
●
●
●
Vogliamo scrivere una semplicissima
applicazione che riceve una stringa
attraverso Socket e la rimanda indietro.
Client
–
Apre un socket verso il server
–
Invia una stringa
–
Legge una stringa
Server
–
Apre un serversocket e accetta una
connessione
–
Restituisce le stringhe ricevute
Stefano Sanna - [email protected]
Echo server
import java.io.*;
CRS4 - http://www.crs4.it
import java.net.*;
public class EchoServer {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8899);
Socket clientSocket = serverSocket.accept();
Reader reader = new InputStreamReader(clientSocket.getInputStream());
BufferedReader buffer = new BufferedReader(reader);
PrintStream ps = new PrintStream(clientSocket.getOutputStream());
String read = "";
while ((read = buffer.readLine()) != null) {
System.out.println("Ricevuto: " + read);
ps.println(read);
}
}
}
Stefano Sanna - [email protected]
Echo client
import java.io.*;
CRS4 - http://www.crs4.it
import java.net.*;
import java.util.Date;
public class EchoClient {
public static void main(String[] args) throws Exception {
Socket clientSocket = new Socket("127.0.0.1", 8899);
Reader reader = new InputStreamReader(clientSocket.getInputStream());
BufferedReader buffer = new BufferedReader(reader);
PrintStream ps = new PrintStream(clientSocket.getOutputStream());
while (true) {
ps.println(new Date(System.currentTimeMillis()));
System.out.println("Tornato indietro: " + buffer.readLine());
Thread.sleep(200);
}
} }
Stefano Sanna - [email protected]
Esplorazione di un protocollo
CRS4 - http://www.crs4.it
●
●
I Socket costituiscono un ottimo strumento
didattico per imparare a gestire protocolli
di complessità crescente
In un modello client/server è possibile:
–
Creare un server fittizio per intercettare e
tracciare il formato delle chiamate effettuate
da un client
–
Create un client fittizio che, a fronte di una
richiesta “elementare” ad un server reale,
intercetti e descriva nel dettaglio il formato dei
dati restituiti dal server
Stefano Sanna - [email protected]
Cosa manda un browser?
CRS4 - http://www.crs4.it
●
●
Si supponga di voler esaminare il formato
di una richiesta HTTP inviata da un browser
al server web
Sarà necessario:
–
Creare un serversocket (verosimilmente sulla
porta 80)
–
Leggere i dati inviati dal client riga per riga
Stefano Sanna - [email protected]
HTTP Request sniffer...
import java.io.*;
import java.net.*;
CRS4 - http://www.crs4.it
public class HTTPRequestSniffer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(80);
Socket clientSocket = serverSocket.accept();
InputStream input = clientSocket.getInputStream();
BufferedReader buffer = new BufferedReader(new InputStreamReader(input));
String read = "";
int line = 0;
while ((read = buffer.readLine()) != null) {
System.out.println(Integer.toString(line++) + " " + read);
}
} catch(Exception e) { e.printStackTrace(); }
}
}
Stefano Sanna - [email protected]
HTTP Request: Mozilla
GET / HTTP/1.1
CRS4 - http://www.crs4.it
Host: localhost
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.0.1)
Gecko/20020823 Netscape/7.0
Accept:
text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text
/plain;q=0.8,video/xmng,image/png,image/jpeg,image/gif;q=0.2,text/css,*/*;q=0.1
Accept-Language: en-us, en;q=0.50
Accept-Encoding: gzip, deflate, compress;q=0.9
Accept-Charset: ISO-8859-1, utf-8;q=0.66, *;q=0.66
Keep-Alive: 300
Connection: keep-alive
Stefano Sanna - [email protected]
HTTP Request: Internet Explorer
CRS4 - http://www.crs4.it
GET / HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg,
application/vnd.ms-powerpoint, application/vnd.ms-excel,
application/msword, application/x-shockwave-flash, */*
Accept-Language: it
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET
CLR 1.1.4322)
Host: localhost
Connection: Keep-Alive
Stefano Sanna - [email protected]
Cosa invia un server web?
CRS4 - http://www.crs4.it
●
●
Conoscendo il formato di una richiesta
elementare inviata da un browser web,
possiamo preparare un client fittizio con
cui tracciare la risposta restituita dal server
Sarà necessario:
–
Create un client socket verso un server web
attivo
–
Inviare la richiesta minima (GET / HTTP/1.x)
–
Leggere i dati inviati dal server riga per riga
Stefano Sanna - [email protected]
HTTP Response sniffer...
import java.io.*; import java.net.*;
public class HTTPResponseSniffer {
CRS4 - http://www.crs4.it
public static void main(String[] args) throws Exception {
Socket clientSocket = new Socket("java.sun.com", 80);
InputStream input = clientSocket.getInputStream();
BufferedReader buffer = new BufferedReader(new InputStreamReader(input));
PrintStream ps = new PrintStream(clientSocket.getOutputStream());
ps.println("GET / HTTP/1.0\n\n");
String read = "";
int line = 0;
while ((read = buffer.readLine()) != null) {
System.out.println(Integer.toString(line++) + " " + read);
}
}
}
Stefano Sanna - [email protected]
HTTP Response di java.sun.com
HTTP/1.1 200 OK
CRS4 - http://www.crs4.it
Server: Netscape-Enterprise/6.0
Date: Tue, 18 May 2004 12:53:33 GMT
Content-type: text/html;charset=ISO-8859-1
Set-cookie: JSESSIONID=java.sun.com-987f%253A40aa074a%
253A391e72d077d4b9a;path=/;expires=Tue, 18-May-2004 13:23:31 GMT
Connection: close
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Java Technology</title>
<meta name="keywords" content="Java, platform" />
[...]
Stefano Sanna - [email protected]
Multithreading
CRS4 - http://www.crs4.it
●
●
●
Rispetto ad altri linguaggi (Pascal,
C/C++...), Java nasce con la
multiprogrammazione “in mente”
La possibilità di gestire più flussi di
esecuzione concorrenti in maniera nativa
nel linguaggio è fondamentale per facilitare
lo sviluppo di applicazioni network-oriented
Il server deve gestire in modo concorrente
più connessioni, delegando a ciascun
thread la gestione di un client
Stefano Sanna - [email protected]
Multithreading
CRS4 - http://www.crs4.it
●
●
L'esempio di “Echo server”
precedentemente illustrato... funziona una
sola volta e con un solo client!
E' necessario incapsulare la gestione di una
singola connessione all'interno di un
Thread separato
Connection 1
Echo Server
Connection 1
Connection 1
Stefano Sanna - [email protected]
Multithreading
CRS4 - http://www.crs4.it
●
Un Thread gestisce la connessione:
private static class Connection extends Thread {
private Socket clientSocket;
public Connection(Socket socket) {
this.clientSocket = socket;
start();
}
public void run() {
try {
// CODICE DI LETTURA:..
}
catch(Exception e) { e.printStackTrace(); }
}
}
Stefano Sanna - [email protected]
Multithreading
CRS4 - http://www.crs4.it
●
Il server istanzia un Thread per ogni
connessione ricevuta:
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8899);
while (true) {
Socket clientSocket = serverSocket.accept();
new Connection(clientSocket);
}
}
Stefano Sanna - [email protected]
Protocolli applicativi
CRS4 - http://www.crs4.it
●
●
L'API Java offre classi per la gestione di
protocolli a livello applicativo (ad esempio
HTTP), che permettono di sviluppare in
modo semplice e rapido potenti
applicazioni network oriented
Il network programming permette di
trascurare tutti i dettagli del protocollo
sottostante per concentrarsi solamente
sullo scambio dei contenuti
Stefano Sanna - [email protected]
URL e URLConnection
CRS4 - http://www.crs4.it
●
●
●
La classe URL rappresenta un Uniform
Resource Locator, cioè un riferimento
formale ad una risorsa reperibile su
Internet
La classe URLConnection rappresenta la
connessione al servizio su cui risiede la
risorsa individuata da un URL
Attenzione:
–
URL: non più “indirizzo IP”!
–
URLConnection: non più Socket!
Stefano Sanna - [email protected]
HttpURLConnection
CRS4 - http://www.crs4.it
●
●
●
E' la classe che incapsula la gestione di
una connessione HTTP ad un server web
Nasconde tutti i dettagli del protocollo,
gestendo l'invio degli header, la codifica
dei dati binari e la notifica degli errori di
elaborazione
Si ottiene a partire da una URL valida
Stefano Sanna - [email protected]
HttpURLConnection
CRS4 - http://www.crs4.it
●
Metodi principali dell'interfaccia pubblica:
–
URL.openConnection()
–
Object getContent()
–
int getContentLength()
–
String getHeaderField(String name)
–
String getRequestProperty(String name)
–
InputStream getInputStream()
–
OutputStream getOutputStream()
Stefano Sanna - [email protected]
Distributed computing: XML-RPC
CRS4 - http://www.crs4.it
●
●
●
●
XML-RPC: XML Remote Procedure Call
XML-RPC è una specifica sviluppata nel
1998 da UserLand Software per
l'invocazione remota di metodi tra diverse
versioni di Frontier
XML-RPC utilizza HTTP (POST) come livello
di trasporto per documenti XML
XML-RPC è indipendente dal linguaggio di
programmazione: supporta un set minimo
di tipi disponibili su tutti i moderni
linguaggi
Stefano Sanna - [email protected]
XML-RPC: sincrono
CRS4 - http://www.crs4.it
●
●
●
Essendo basato su HTTP, un server XMLRPC invia una risposta contestualmente
alla connessione TCP/IP della invocazione
La richiesta è bloccante, nel senso che
l'operazione non è conclusa finché il server
non restituisce il documento XML di output
È importante interfacciare tramite XMLRPC procedure che richiedono tempi di
elaborazione predicibili e non
eccessivamente lunghi
Stefano Sanna - [email protected]
XML-RPC: stateless
CRS4 - http://www.crs4.it
●
●
●
L'uso di HTTP rende scorrelate due
invocazioni successive ad una interfaccia
XML-RPC.
Né il protocollo XML-RPC né HTTP
contengono meccanismi per tracciare la
sequenza delle invocazioni:
È compito del programmatore inserire
metadati (indicatori di sessione) per
conoscere la storia dell'accesso ad una
certa interfaccia
Stefano Sanna - [email protected]
XML-RPC: invocazioni
CRS4 - http://www.crs4.it
●
Esempio di invocazione XML-RPC:
<?xml version=”1.0”?>
<methodCall>
<methodName>NOME_DEL_METODO</methodName>
<params>
<param>
<value><TIPO>VALORE</TIPO></value>
</param>
<param>
<value><TIPO>VALORE</TIPO></value>
</param>
</params>
</methodCall>
Stefano Sanna - [email protected]
XML-RPC: risposte
CRS4 - http://www.crs4.it
●
Esempio di risposta:
<?xml version=”1.0”?>
<methodResponse>
<methodName>NOME_DEL_METODO</methodName>
<params>
<param>
<value><TIPO>VALORE RESTITUITO</TIPO></value>
</param>
</params>
</methodResponse>
Stefano Sanna - [email protected]
XML-RPC in Java
CRS4 - http://www.crs4.it
●
●
Il progetto è stato iniziato da Hannes
Wallnofer ed è poi diventato parte
dell'Apache XML Project.
La libreria fornisce:
–
Classi per realizzare di server e client XML-RPC
–
Un web server minimale per sistemi non dotati
di application server dedicato
–
Classi per l'integrazione in un servlet container
–
Classi per l'integrazione di XML-RPC in Applet
Stefano Sanna - [email protected]
Mapping dei tipi
CRS4 - http://www.crs4.it
●
I tipi XML-RPC vengono mappati in Java:
XML-RPC
Java
string
String
int
Integer (int)
double
Double (double)
boolean
Boolean (boolean)
date.iso8601
Date (java.util)
base64
byte[]
array
Vector (java.util)
struct
Hashtable (java.util)
Stefano Sanna - [email protected]
XML-RPC Server
CRS4 - http://www.crs4.it
●
●
●
Un server XML-RPC risponde a invocazioni
XML-RPC attraverso richieste su HTTP POST
Le invocazioni devono essere interpretate:
–
Trasformare i parametri secondo la mappa dei
tipi locale
–
Individuare oggetto e metodo al quale
l'invocazione si riferisce
L'esecutore di una invocazione è detto
handler.
Stefano Sanna - [email protected]
Registrazione implicita
CRS4 - http://www.crs4.it
●
Il WebServer mappa automaticamente le
invocazioni XML-RPC sui metodi pubblici
della classe handler (registrazione
implicita)
Stefano Sanna - [email protected]
Registrazione implicita
CRS4 - http://www.crs4.it
●
Può capitare che si voglia disabilitare
questo meccanismo:
–
per non avere una corrispondenza 1:1 tra
metodi della classe handler e signature dei
metodi invocabili via XML-RPC
–
per nascondere alcuni metodi pubblici della
classe handler, che devono essere accessibili
da altre classi dell'applicazione ma non
attraverso l'interfaccia XML-RPC
Stefano Sanna - [email protected]
Registrazione esplicita
CRS4 - http://www.crs4.it
●
Il pacchetto fornisce l'interfaccia
XmlRpcHandler per la registrazione
esplicita
Stefano Sanna - [email protected]
Registrazione esplicita
CRS4 - http://www.crs4.it
●
La registrazione esplicita è utile:
–
per supportare metodi con numero arbitrario di
parametri (?)
–
per “arricchire” l'interfaccia dell'handler con i
metodi pubblici di altre classi
–
modificare a runtime i nomi dei metodi
Stefano Sanna - [email protected]
Scrittura di un server (1)
CRS4 - http://www.crs4.it
●
Prima di tutto è necessario predisporre gli
handler:
public class HandlerImplicito {
public HandlerImplicito() {}
public String getSystemInfo() {
return System.getProperty("os.name");
}
public String delay() throws InterruptedException {
Thread.currentThread().sleep(2000);
return "I have stolen 2 seconds of your life!";
}
}
Stefano Sanna - [email protected]
Scrittura di un server (2)
CRS4 - http://www.crs4.it
●
L'handler esplicito ha un solo metodo:
public class HandlerEsplicito implemens XmlRpcHandler {
public HandlerEsplicito() {}
public Object execute(String method, Vector params)
throws Exception {
System.out.println("Metodo: " + method);
for (int i =0; i < params.size(); i++) {
System.out.println("Parametro " + i + ": " +
params.elementAt(i).toString());
}
return "Well done!";
}
}
Stefano Sanna - [email protected]
Scrittura di un server (3)
CRS4 - http://www.crs4.it
●
Si istanzia il server, aggiungendo gli
handler, ai quali è assegnato un nome:
WebServer server = new WebServer(3569);
server.addHandler("implicito", new HandlerImplicito());
server.addHandler("esplicito", new HandlerEsplicito());
●
Ora il server è pronto ad accettare
richieste sulla porta 3569...
Stefano Sanna - [email protected]
XML-RPC Client
CRS4 - http://www.crs4.it
●
●
●
Un client XML-RPC invia richieste XML ad
un server remoto e riceve un XML di
risposta
La libreria gestisce automaticamente le
eccezioni, trasformando i messaggi di
errore XML-RPC in eccezioni Java.
I metodi da invocare sono individuati da:
–
URL del server (http://ws.gulch.it/RPC2)
–
Nome dell'oggetto (dbsoci, mailserver...)
–
Nome del metodo (getList(), showStat())
Stefano Sanna - [email protected]
Scrittura di un client
CRS4 - http://www.crs4.it
●
XmlRpcClient incapsula le richieste:
XmlRpcClient client = new XmlRpcClient
("http://ws.gulch.it:3569/RPC2");
Vector paramsEmpty = new Vector();
Object result = client.execute("implicito.getSystemInfo",
paramsEmpty));
●
I parametri sono contenuti all'interno del
vettore. Anche se il metodo non accetta
parametri, deve essere fornito un vettore
vuoto.
Stefano Sanna - [email protected]
CRS4 - http://www.crs4.it
Domande?
Stefano Sanna - [email protected]
Bibliografia
CRS4 - http://www.crs4.it
●
Java Network Programming
E. Rusty Harold
O'Reilly 2000
ISBN: 1565928709
XML-RPC
F. Caboni e S. Sanna
Gruppo Utenti Linux Cagliari
LinuxDay 2003
http://linuxday.gulch.crs4.it
Stefano Sanna - [email protected]
Conclusioni
CRS4 - http://www.crs4.it
●
●
●
Java offre una potente libreria per la
gestione delle connessioni in rete.
Qualsiasi sia la versione utilizzata
(Enterprise, Standard, Micro), vi è sempre
la possibilità di connettersi ad un server
remoto per inviare e ricevere dati
java.net.* è una buona palestra per
prendere dimestichezza con i più diffusi
protocolli di comunicazione!
Stefano Sanna - [email protected]
CRS4 - http://www.crs4.it
Grazie... :-)
Stefano Sanna - [email protected]