Salvador Dalì
Il marcatore di gestione delle intestazioni ha il compito di evidenziare i titoli all’interno del documento. La sintassi prevede il tag iniziale <hn> che significa header appunto titolo seguito da un numero (n) compreso tra 1 e 6 che identifica la dimensione.
Prevede l’uso di un tag di chiusura. Il numero n associato al tag ne definisce, oltre alla dimensione, anche l’importanza; l’importanza e quindi la dimensione sono proporzionali a tale numero.
Ad esempio:
che ha come output:
Salvador Dalì
La definizione del carattere viene stabilita dai delimitatori di rassetto, sottolineato, corsivo, apice e pedice.
<b> e </b> attiva il carattere grassetto o neretto; la B in inglese è l’iniziale di Bold
<u> e </u> attiva il carattere sottolineato; la U in inglese è l’iniziale di underscored
<i> e </i> attiva il carattere corsivo o italico; la I sta per Italic
<s> e </s> attiva la cancellazione visibile; la S è l’iniziale di StrikeOut;
<tt> e </tt> attiva la monospaziatura; TT è l’iniziale di TeleType;
<sup> e </sup> attiva il carattere apice: SUP in inglese corrisponde a Superscript
<sub> e </sub> attiva il carattere pedice; SUB in inglese sta per Subscript
Esempio:
Ecco l’output:
[:it]
abstract art, art movement, fine art, art critics, visual representation, Pablo Picasso, Henri Matisse, Wassily Kandinsky, Robert Delaunay
Ogni programma dovrà riportare come commento, al suo interno, il nome dell’esecutore, la data, e una breve descrizione del suo scopo. Il nome del programma dovrà riportare il nome dello sviluppatore.
Esercizio per il 9/10
Creare un programma che calcoli in maniera ricorsiva la somma, il prodotto, e l’elevazione a potenza di due numeri interi usando:
Esercizio per 7/8
Dato un insieme di numeri, calcolare la loro media mostrandoli a video dopo il loro inserimento.
Esercizio per il 6/7
Date due matrici formate da 2 righe e tre colonne, farne la loro somma, sapendo che la somma avviene sommando gli elementi posizionati alla stessa riga e colonna.
Mostrare a video le due matrici e la matrice somma.
[:]
[:it]Nel Server Windows 2012, si deve selezionare il ruolo DHCP nel menù a sinistra che compare nel Server Manager,
selezionare il server a cui si vuole attivare il DHCP:
quindi selezionare Gestore DHCP,
Nella schermata e si apre, selezionare il server e quindi ipv4:
Selezionare Azione e nuovo ambito:
quindi dare il il nome all’azione e poi inserire il range dei valori.[:]
[:it]Nel caso in cui si volesse installare il server web su Windows server, sempre dal Server Manager si installano i nuovi ruoli.
Quindi con ruolo di identificano i vari servizi che si vogliono attivare.
Ad esempio dopo aver installato il Windows server, il DNS ed il DHCP si presenterà la seguente schermata:
Digitando nel browser
http://localhost si presenterà la seguente schermata:
[:]
[:it]Windows server 2012 si presenta in questa maniera:
La dashboard o pannello di controllo nella seguente:
L’impostazione di un ip statico è fondamentale per impostare il DHCP.
Per farlo, spostando il mouse in alto a destra si apre il pannello che permette di accedere al pannello di controllo.
Si può ad esempio impostare nella seguente maniera:
A questi punto il DHCP risulta funzionante.[:]
[:it]
Salvator Dalì
1. Realizzare un’applicazione C/S che simula il distributore di etichette numerate presente in molti negozi o sportelli di uffici pubblici. Il programma server rappresenta il distributore di etichette numerate. I programmi client si connettono al server per ottenere un nuovo numero. Il server gestisce i numeri in maniera incrementale e il contatore viene inizializzato al valore 1 quando il server viene avviato.
2. Modificare il programma client presentato nel Paragrafo 2 per inserire da linea di comando il nome del server e della porta a cui connettersi. Il programma client deve essere poi eseguito usando il comando java ClientClock localhost 3333 (si ricordi che i valori passati da linea di comando al programma Java sono contenuti nell’array args[ ]).
3. Realizzare la classe server e la classe client in modo che, a connessione avvenuta, il server invii al client il messaggio di benvenuto: “Hello, World!”. Il client, ricevuto il messaggio, termina la connessione, mentre il server resta in attesa.
4. Simulare una postazione Bancomat per la distribuzione di banconote. Per semplicità, si suppone che l’apparecchio abbia a disposizione 5000 banconote da 50 euro e che l’utente possa richiedere il prelievo di importi espressi in multipli di 50: 50, 100, 150, 200, ecc. con un massimo di 500. Il programma client invia la cifra e ottiene dal programma server il numero di banconote da 50 euro che possono essere prelevate. Quando le banconote sono esaurite, il server restituisce un messaggio di prelievo non consentito.
5. Realizzare un’applicazione C/S con le seguenti funzionalità: – il client invia al server un numero – il server calcola il doppio del numero e lo restituisce al client. I numeri possono essere inviati come stringhe usando il comando println. Alla ricezione della stringa il programma esegue la conversione in un numero intero.
6. Realizzare un’applicazione C/S con le seguenti funzionalità: – il client invia al server due numeri in sequenza (con due operazioni di println), – il server legge i due numeri (con due operazioni di readLine), calcola il prodotto e lo restituisce al client.[:]
[:it]
Salvator Dalì
Costruire un’applicazione client/server che realizza una chat, consentendo di scambiare messaggi tra un client e un server. Il client può terminare la connessione inserendo la parola FINE.
La chat viene realizzata con due programmi di rete: un programma server e un programma client. Le due persone che vogliono partecipare alla chat devono disporre di uno dei due programmi. La persona che esegue il programma server resta in attesa che l’altra persona si colleghi usando il programma client. Quando la connessione è stata attivata, la chat può avere inizio.
Si suppone che la chat venga eseguita all’interno della finestra del Prompt dei comandi di Windows o nella finestra Terminale di Linux. I messaggi da inviare vengono letti da tastiera e i messaggi ricevuti vengono visualizzati all’interno della finestra. Dopo aver stabilito la connessione, la chat viene gestita in modo sequenziale, cioè le operazioni sono svolte nel seguente ordine, stabilendo un protocollo di comunicazione:
[client]: legge il messaggio da tastiera e lo invia al server.
[server]: riceve il messaggio e lo visualizza.
[server]: legge il messaggio da tastiera e lo invia al client.
[client]: riceve il messaggio e lo visualizza.
La sequenza precedente viene realizzata con un ciclo infinito sia sul client che sul server. Il ciclo nel programma client termina quando si inserisce da tastiera la parola FINE, come mostra il seguente frammento di codice.
while (true) {
// legge il messaggio da tastiera
msgDaInviare = tastiera.readLine();
// interrompe la chat
if (msgDaInviare.equals(“FINE”))
break;
// invia il messaggio al server
// riceve il messaggio e lo visualizza
}
Si osservi che anche la parola FINE rappresenta un elemento del protocollo di comunicazione.
Il ciclo nel programma server termina quando viene ricevuto il valore null dal flusso di input della socket. Questo indica che il client si è sconnesso.
while (true) {
// riceve il messaggio
msgRicevuto = sIN.readLine();
if (msgRicevuto == null)
{ System.out.println(“Il client ha chiuso la chat.”);
break; }
// visualizza il messaggio
// legge il messaggio da tastiera
// invia il messaggio al client
}
Sia il client che il server devono gestire tre flussi di dati: – flusso di lettura di dati da tastiera – flusso di lettura di dati dalla socket – flusso di scrittura di dati sulla socket.
Questi tre flussi sono gestiti usando i seguenti oggetti:
In particolare il server deve inizializzare i flussi nel seguente ordine:
// flusso in uscita su socket
out = connessione.getOutputStream();
sOUT = new PrintWriter(out);
// flusso in ingresso da socket
in = new InputStreamReader(connessione.getInputStream());
sIN = new BufferedReader(in);
// flusso in ingresso da tastiera
input = new InputStreamReader(System.in);
tastiera = new BufferedReader(input);
Il client deve inizializzare i flussi nel seguente ordine:
// flusso in ingresso da socket
in = new InputStreamReader(connessione.getInputStream());
sIN = new BufferedReader(in);
// flusso in uscita su socket out = connessione.getOutputStream();
sOUT = new PrintWriter(out);
// flusso in ingresso da tastiera
input = new InputStreamReader(System.in);
tastiera = new BufferedReader(input);
Come si può notare il server inizializza prima il flusso in uscita e poi il flusso in ingresso, mentre il client fa l’opposto.
Per fare in modo che l’invio dei messaggi avvenga immediatamente si devono usare le seguenti istruzioni:
sOUT.println(msgDaInviare);
sOUT.flush();
Il metodo flush serve per svuotare il buffer del flusso di output e inviare i dati. Di seguito sono riportati i programmi completi, lato server e lato client.
Ecco il sorgente sa parte server:
// chat con una sola connessione
import java.net.*;
import java.io.*;
public class ServerChat {
public static void main(String args[])
{
ServerSocket sSocket;
Socket connessione = null;
int port = 2345;
InputStreamReader in, input;
BufferedReader sIN, tastiera;
OutputStream out;
PrintWriter sOUT;
String msgDaInviare;
String msgRicevuto;
try
{
sSocket = new ServerSocket(port);
System.out.println(“In attesa di connessioni…”);
// ciclo infinito
while (true)
{
connessione = sSocket.accept();
// flusso in uscita su socket
out = connessione.getOutputStream();
sOUT = new PrintWriter(out);
// flusso in ingresso da socket
in = new InputStreamReader(connessione.getInputStream());
sIN = new BufferedReader(in);
// flusso in ingresso da tastiera
input = new InputStreamReader(System.in);
tastiera = new BufferedReader(input);
System.out.println(“Chat inizializzata.”);
while (true) {
// stampa il messaggio ricevuto
msgRicevuto = sIN.readLine();
if (msgRicevuto == null)
{
System.out.println(“Il client ha chiuso la chat.”);
break;
}
System.out.println(“>> ” + msgRicevuto);
// legge il messaggio da tastiera
msgDaInviare = tastiera.readLine();
// invia il messaggio
sOUT.println(msgDaInviare);
sOUT.flush();
}
}
}
catch (IOException e)
{ System.out.println(e); }
try { connessione.close(); }
catch (IOException e)
{ System.out.println(e); }
}import java.net.*;
import java.io.*;
public class ClientChat {
public static void main(String[] args)
{
Socket connessione = null;
String server = “localhost”;
int port = 2345;
InputStreamReader in, input;
BufferedReader sIN, tastiera;
OutputStream out;
PrintWriter sOUT;
String msgDaInviare;
String msgRicevuto;
try {
connessione = new Socket(server, port);
System.out.println(“Connessione eseguita.”);
}
catch (IOException e)
{
System.out.println(e);
System.exit(-1);
}
try {
// flusso in ingresso da socket
in = new InputStreamReader(connessione.getInputStream());
sIN = new BufferedReader(in);
// flusso in uscita su socket
out = connessione.getOutputStream();
sOUT = new PrintWriter(out);
// flusso in ingresso da tastiera
input = new InputStreamReader(System.in);
tastiera = new BufferedReader(input);
System.out.println(“Chat inizializzata.”);
while (true)
{
// legge il messaggio da tastiera
msgDaInviare = tastiera.readLine();
// interrompe la chat
if (msgDaInviare.equals(“FINE”)) break;
// invia il messaggio
sOUT.println(msgDaInviare);
sOUT.flush();
// stampa il messaggio ricevuto
msgRicevuto = sIN.readLine();
System.out.println(“>> ” + msgRicevuto);
}
}
catch (IOException e)
{
System.out.println(e);
}
try {
connessione.close();
}
catch (IOException e)
{
System.out.println(e);
}
}
}
Ecco il sorgente da parte client:
import java.net.*;
import java.io.*;
public class ClientChat {
public static void main(String[] args)
{
Socket connessione = null;
String server = “localhost”;
int port = 2345;
InputStreamReader in, input;
BufferedReader sIN, tastiera;
OutputStream out;
PrintWriter sOUT;
String msgDaInviare;
String msgRicevuto;
try {
connessione = new Socket(server, port);
System.out.println(“Connessione eseguita.”);
}
catch (IOException e)
{
System.out.println(e);
System.exit(-1);
}
try {
// flusso in ingresso da socket
in = new InputStreamReader(connessione.getInputStream());
sIN = new BufferedReader(in);
// flusso in uscita su socket
out = connessione.getOutputStream();
sOUT = new PrintWriter(out);
// flusso in ingresso da tastiera
input = new InputStreamReader(System.in);
tastiera = new BufferedReader(input);
System.out.println(“Chat inizializzata.”);
while (true)
{
// legge il messaggio da tastiera
msgDaInviare = tastiera.readLine();
// interrompe la chat
if (msgDaInviare.equals(“FINE”)) break;
// invia il messaggio
sOUT.println(msgDaInviare);
sOUT.flush();
// stampa il messaggio ricevuto
msgRicevuto = sIN.readLine();
System.out.println(“>> ” + msgRicevuto);
}
}
catch (IOException e)
{
System.out.println(e);
}
try {
connessione.close();
}
catch (IOException e)
{
System.out.println(e);
}
}
}
[:]
[:it]
Hans Arp
Realizzare un’applicazione client/server utile ai client per sincronizzare la data e l’ora con quella di un server. Il programma client si collega al server per ottenere le informazioni sulla data e sull’ora correnti. Il server, ogni volta che riceve una richiesta di connessione, invia al programma client l’informazione richiesta.
Programma Server (ServerClock.java)
Programma client
Per eseguire la precedente applicazione si devono usare due finestre del Prompt dei comandi in Windows, oppure due finestre Terminale in Linux. Nella prima finestra si esegue il programma server. Il server si ferma in attesa di ricevere le connessioni. A questo punto, nella seconda finestra, si esegue il programma client. Il risultato è che il client si collega al server sulla porta 3333. Il server crea una nuova connessione e invia al client l’informazione sulla data corrente. Successivamente interrompe la connessione e si mette in attesa di una nuova richiesta. Il client legge i dati che sono stati inviati dal server, li mostra a video e poi termina la connessione. Per interrompere l’esecuzione del programma server si deve digitare la combinazione di tasti Ctrl + C.
Oppure usando eclipse si riesce a riesce a simulare il comportamento.
Se si dispone di una rete con almeno due computer collegati, si può eseguire l’applicazione C/S in modo distribuito. Il programma server può essere eseguito su un computer di cui si conosce l’indirizzo IP oppure il nome.
Prima di eseguire il programma client si deve impostare nel codice il corretto parametro di connessione per l’indirizzo del server.
Per esempio:
String server = “192.168.1.2”;
Il programma client ricompilato può essere eseguito su un computer diverso da quello del server.
Ricapitolando, le fasi che portano alla creazione di una connessione possono essere schematizzate con la seguente sequenza di operazioni.
• Lato server: il programma server resta in attesa di una connessione su una determinata porta, mediante il comando accept della ServerSocket.
• Lato client: il programma client avvia un tentativo di connessione.
• Lato server: il programma server accetta la connessione e crea un oggetto Socket per comunicare con il client.
• Lato client: quando la connessione viene accettata, il programma client crea un oggetto Socket per comunicare con il server
Dopo aver stabilito la connessione, il programma client e server possono comunicare scrivendo e leggendo dagli stream associati alle rispettive socket.
Al termine della comunicazione, entrambi chiudono il canale di connessione.
[:]
[:it]
Hans Arp
La realizzazione di applicazioni client/server in Java si basa sulle classi contenute nel package java.net.
In quasi tutte le applicazioni di rete viene anche utilizzato il package java.io per gestire i flussi di comunicazione in input e output.
È quindi necessario importare i precedenti package in ogni programma in cui si vogliono eseguire operazioni con la rete.
import java.net.*;
import java.io.*;
I programmi client si differenziano dai programmi server per la loro struttura; la loro implementazione in Java è leggermente diversa. La comunicazione avviene tramite le entità chiamate socket (letteralmente, presa di corrente).
La socket è un punto da cui il programma può inviare i dati in rete e può ricevere i dati dalla rete.
Programma client
L’apertura di una connessione corrisponde a una richiesta inviata al programma server tramite la classe Socket.
connessione = new Socket(server, porta);
I due parametri da indicare al costruttore sono l’indirizzo del server, specificato come nome oppure come indirizzo IP del server, e la porta. Il risultato dell’apertura di una connessione è la creazione di una socket sul computer client che permette al programma di comunicare con la corrispondente socket presente sul computer server.
L’invio e la ricezione dei dati sono gestite in maniera simile alla scrittura e alla lettura dei file di dati, tramite uno stream. A ogni socket sono associati un flusso di input, da cui i programmi possono ricevere i dati, e un flusso di output, su cui i programmi possono inviare i dati in rete. Le seguenti istruzioni mostrano come viene impostato il flusso di input nel caso in cui la comunicazione avvenga con sequenze di caratteri:
InputStream in = connessione.getInputStream();
InputStreamReader input = new InputStreamReader(in);
BufferedReader sIN = new BufferedReader(input);
Il metodo getInputStream restituisce il flusso in input associato alla socket. Il programma utilizza il metodo readLine della classe BufferedReader per ricevere i dati.
Le seguenti istruzioni mostrano come viene impostato il flusso di output nel caso in cui la comunicazione avvenga con sequenze di caratteri:
OutputStream out = connessione.getOutputStream();
PrintWriter sOUT = new PrintWriter(out);
Il metodo getOutputStream restituisce il flusso in output associato alla socket.
Il programma utilizza il metodo println della classe PrintWriter per inviare i dati.
La chiusura della connessione viene eseguita quando si vuole interrompere la comunicazione di rete. Si deve richiamare il metodo close nel seguente modo:
connessione.close();
Programma server
I programmi server hanno la caratteristica di restare attivi in attesa di ricevere una richiesta di connessione da parte dei client. Questo comportamento viene realizzato con una socket particolare implementata con la classe ServerSocket.
La creazione di una socket di tipo server viene eseguita con la seguente istruzione:
ServerSocket sSocket = new ServerSocket(porta);
Il parametro indica la porta che viene riservata all’applicazione per ricevere le richieste dagli altri computer. Il numero di porta deve essere superiore a 1023.
Dopo aver creato la ServerSocket, il programma server si mette in attesa che un client si colleghi. Il metodo accept della classe ServerSocket è utilizzato per bloccare il programma server finché viene intercettata una richiesta di connessione. Quando giunge la richiesta, il metodo accept restituisce una socket che gestirà la connessione con il client.
Tramite questa nuova socket, il programma server potrà inviare e ricevere dati dal programma client.
La connessione viene chiusa con il metodo close. Il codice che riassume il comportamento del server è il seguente:
while (true) { Socket connessione = sSocket.accept();
// invio-ricezione dati tramite la connessione
connessione.close(); }
Tutte le operazioni eseguite con le socket possono generare delle eccezioni, principalmente eccezioni di tipo IOException. È quindi necessario racchiudere le istruzioni nei blocchi try…catch per evitare che il programma venga interrotto bruscamente.[:]