6. Allegati
Di seguito illustriamo come installare gli strumenti utilizzati in questo documento su computer con sistema operativo Windows 7-10. Il lettore dovrà adattare la procedura al proprio ambiente.
6.1. Installazione di IDE Arduino
Il sito ufficiale di Arduino è [http://www.arduino.cc/]. È qui che si trova l'IDE di sviluppo per gli Arduino [http://arduino.cc/en/Main/Software]:
 |  |
Il file scaricato [1] è un file zip che, una volta decompresso, genera la struttura di directory [2]. È possibile avviare IDE facendo doppio clic sull'eseguibile [3].
6.2. Installazione del driver di Arduino
Affinché IDE possa comunicare con un Arduino, quest’ultimo deve essere riconosciuto dall’host PC. A tal fine, è possibile procedere come segue:
- collegare l'Arduino a una porta USB del computer host;
- il sistema tenterà quindi di individuare il driver del nuovo dispositivo USB. Non lo troverà. A questo punto, indicare che il driver si trova sul disco nella cartella <arduino>/drivers, dove <arduino> è la cartella di installazione dell'Arduino IDE.
6.3. Test dell’IDE
Per testare l'IDE, è possibile procedere come segue:
- avviare l’IDE;
- collegare l’Arduino al PC tramite il cavo USB. Per il momento, non includere la scheda di rete;
 |  |
- in [1], selezionare il tipo di scheda Arduino collegata alla porta USB;
- in [2], specificare la porta USB a cui è collegato l'Arduino. Per individuarla, scollegare l'Arduino e prendere nota delle porte. Ricollegarlo e ricontrollare le porte: quella che è stata aggiunta è quella dell'Arduino;
Eseguite alcuni degli esempi inclusi nel IDE:
 |
L'esempio viene caricato e visualizzato:
 |
Gli esempi che accompagnano il file IDE sono molto didattici e ben commentati. Il codice Arduino è scritto in linguaggio C e si compone di due parti ben distinte:
- una funzione [setup] che viene eseguita una sola volta all’avvio dell’applicazione, ovvero quando questa viene “caricata " dall'host PC sull'Arduino, oppure quando l'applicazione è già presente sull'Arduino e si preme il pulsante [Reset]. È qui che si inserisce il codice di inizializzazione dell'applicazione;
- una funzione [loop] che viene eseguita continuamente (ciclo infinito). È qui che va inserito il nucleo dell’applicazione.
Qui,
- la funzione [setup] configura il pin n. 13 come uscita;
- la funzione [loop] la accende e la spegne ripetutamente: il LED si accende e si spegne ogni secondo.
1  |
Il programma visualizzato viene trasferito (caricato) su Arduino tramite il pulsante [1]. Una volta trasferito, viene eseguito e il LED n. 13 inizia a lampeggiare all’infinito.
6.4. Connessione di rete dell’Arduino
L'Arduino o gli Arduino e l'host PC devono trovarsi sulla stessa rete privata:
 |
Se c'è un solo Arduino, è possibile collegarlo all'host PC tramite un semplice cavo RJ 45. Se ce ne sono più di uno, l'host PC e gli Arduino saranno collegati alla stessa rete tramite un mini-hub.
L'host PC e gli Arduino saranno inseriti nella rete privata 192.168.2.x.
- L'indirizzo IP degli Arduino è definito dal codice sorgente. Vedremo come;
- l'indirizzo IP del computer host potrà essere impostato come segue:
- scegliere l’opzione [Panneau de configuration\Réseau et Internet\Centre Réseau et partage]:
 |
- in [1], seguire il link [Connexion au réseau local]
 |  |
- in [2], visualizzare le proprietà della connessione;
- in [4], visualizzare le proprietà IP v4 [3] della connessione;
 |
- in [5], assegnare l'indirizzo IP [192.168.2.1] al computer host;
- in [6], assegnare la subnet mask [255.255.255.0] alla rete;
- confermare il tutto in [7].
6.5. Test di un'applicazione di rete
Con IDE, caricare l'esempio [Exemples / Ethernet / WebServer]:
/*
Web Server
A simple web server that shows the value of the analog input pins.
using an Arduino Wiznet Ethernet shield.
Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13
* Analog inputs attached to pins A0 through A5 (optional)
created 18 Dec 2009
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe
*/
#include <SPI.h>
#include <Ethernet.h>
// Inserisci qui sotto un indirizzo MAC e un indirizzo IP per il tuo controller.
// L’indirizzo IP dipenderà dalla rete locale:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1, 177);
// Inizializza la libreria del server Ethernet
// con l'indirizzo IP e la porta che si desidera utilizzare
// (la porta 80 è quella predefinita per HTTP):
EthernetServer server(80);
void setup() {
// Aprire le comunicazioni seriali e attendere l'apertura della porta:
Serial.begin(9600);
while (!Serial) {
; // attendere la connessione della porta seriale. Necessario solo per Leonardo
}
// avvia la connessione Ethernet e il server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// ascolta i client in entrata
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// una richiesta HTTP termina con una riga vuota
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// se si è giunti alla fine della riga (è stato ricevuto un carattere di nuova riga
// ) e la riga è vuota, la richiesta HTTP è terminata,
// quindi è possibile inviare una risposta
if (c == '\n' && currentLineIsBlank) {
// inviare un'intestazione di risposta HTTP standard
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
// aggiungere un tag meta refresh, in modo che il browser effettui un nuovo caricamento ogni 5 secondi:
client.println("<meta http-equiv=\"refresh\" content=\"5\">");
// visualizzare il valore di ciascun pin di ingresso analogico
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
break;
}
if (c == '\n') {
// stai iniziando una nuova riga
currentLineIsBlank = true;
}
else if (c != '\r') {
// è stato ricevuto un carattere sulla riga corrente
currentLineIsBlank = false;
}
}
}
// concedi al browser il tempo necessario per ricevere i dati
delay(1);
// chiudi la connessione:
client.stop();
Serial.println("client disconnected");
}
}
Questa applicazione crea un server web sulla porta 80 (riga 30) all'indirizzo IP della riga 25. L'indirizzo MAC alla riga 23 corrisponde all'indirizzo MAC specificato sulla scheda di rete dell'Arduino.
La funzione [setup] inizializza il server web:
- riga 34: inizializza la porta seriale su cui l'applicazione registrerà i log. Li seguiremo;
- riga 41: viene inizializzato il nodo TCP-IP (IP, porta);
- riga 42: il server della riga 30 viene avviato su questo nodo di rete;
- righe 43-44: viene registrato l'indirizzo IP del server web;
La funzione [loop] implementa il server web:
- riga 50: se un client si connette al server web, [server].available restituisce tale client, altrimenti restituisce null;
- riga 51: se il cliente non è null;
- riga 55: finché il client è connesso;
- riga 56: [client].available è vero se il client ha inviato dei caratteri. Questi vengono memorizzati in un buffer. [client].available è vero finché il buffer non è vuoto;
- riga 57: viene letto un carattere inviato dal client;
- riga 58: questo carattere viene visualizzato come eco sulla console di log;
- riga 62: nel protocollo HTTP, il client e il server si scambiano righe di testo.
- il client invia una richiesta HTTP al server web inviandogli una serie di righe di testo terminata da una riga vuota,
- il server risponde quindi al client inviandogli una risposta e chiudendo la connessione;
Riga 62: il server non esegue alcuna operazione con le intestazioni HTTP ricevute dal client. Si limita ad attendere la riga vuota: una riga contenente il solo carattere \n;
- righe 64-67: il server invia al cliente le righe di testo standard del protocollo HTTP. Esse terminano con una riga vuota (riga 67);
- a partire dalla riga 68, il server invia un documento al proprio client. Questo documento viene generato dinamicamente dal server ed è in formato HTML (righe 68-69);
- riga 71: una riga HTML specifica che richiede al browser client di aggiornare la pagina ogni 5 secondi. In questo modo il browser richiederà la stessa pagina ogni 5 secondi;
- righe 73-80: il server invia al browser client i valori dei 6 ingressi analogici dell’Arduino;
- riga 81: il documento HTML viene chiuso;
- riga 82: si esce dal ciclo while della riga 55;
- riga 97: la connessione con il client viene chiusa;
- riga 98: si registra l'evento nella console di log;
- riga 100: si torna all'inizio della funzione loop: il server riprenderà ad ascoltare i client. Abbiamo detto che il browser del client richiederà nuovamente la stessa pagina ogni 5 secondi. Il server sarà pronto a rispondergli di nuovo.
Modificate il codice alla riga 25 inserendo l’indirizzo IP del vostro Arduino, ad esempio:
Caricate il programma sull’Arduino. Avviate la console di log (Ctrl-M) (M maiuscola):
 |  |
- in [1], la console di log. Il server è stato avviato;
- in [2], con un browser, si richiede l'indirizzo IP dell'Arduino. Qui [192.168.2.2] viene tradotto per impostazione predefinita come [http://198.162.2.2:80];
- in [3], le informazioni inviate dal server web. Se si visualizza il codice sorgente della pagina nel browser, si ottiene:
Qui si riconoscono le righe di testo inviate dal server. Dal lato Arduino, la console dei log visualizza ciò che il client gli invia:
- righe 2-9: intestazioni standard HTTP;
- riga 10: la riga vuota che le conclude.
Studiate attentamente questo esempio. Vi aiuterà a comprendere la programmazione dell’Arduino utilizzato nel TP.
6.6. La libreria aJson
Nel TP da scrivere, gli Arduino scambiano righe di testo in formato jSON con i propri clienti. Per impostazione predefinita, l’Arduino IDE non include una libreria per gestire il jSON. Installeremo la libreria aJson disponibile su URL [https://github.com/interactive-matter/aJson].
 |  |
- in [1], scaricate la versione compressa dal repository GitHub;
- decomprimete la cartella e copiate la cartella [aJson-master] [2] nella cartella [<arduino>/libraries] [3] dove <arduino> è la cartella di installazione dell'IDE Arduino;
 |  |  |
- in [4], rinominare questa cartella in [aJson];
- in [5], il suo contenuto.
Ora avviate l'Arduino IDE:
 |
Verificate che nella sezione degli esempi siano ora presenti esempi relativi alla libreria aJson. Eseguite e studiate questi esempi.
6.7. Il tablet Android
Gli esempi sono stati testati con il tablet Samsung Galaxy Tab 2.
Per testare gli esempi su un tablet, è necessario innanzitutto installare il driver del tablet sul proprio computer di sviluppo. Il driver del tablet Samsung Galaxy Tab 2 è disponibile all'indirizzo URL [http://www.samsung.com/fr/support/usefulsoftware/KIES/]:
 |
Per testare gli esempi, dovrete connettere il tablet a una rete (probabilmente Wi-Fi) e conoscere il suo indirizzo IP su tale rete. Ecco come procedere (Samsung Galaxy Tab 2):
- accendete il tablet;
- cercate tra le applicazioni disponibili sul tablet (in alto a destra) quella denominata [paramètres] con l’icona di una ruota dentata;
- nella sezione a sinistra, attivate il Wi-Fi;
- nella sezione a destra, selezionate una rete Wi-Fi;
- una volta connessi alla rete, toccate brevemente la rete selezionata. Verrà visualizzato l’indirizzo IP del tablet. Annotatelo. Ne avrete bisogno;
Sempre nell’app [Paramètres],
- selezionate a sinistra l’opzione [Options de développement] (in fondo all’elenco delle opzioni);
- Verificate che a destra l'opzione [Débogage USB] sia selezionata.
Per tornare al menu, toccate nella barra di stato in basso l'icona al centro, quella che raffigura una casa. Sempre nella barra di stato in basso,
- l'icona più a sinistra è quella del "torna indietro": vi riporta alla schermata precedente;
- l’icona più a destra è quella della gestione delle attività. È possibile visualizzare e gestire tutte le attività eseguite in un determinato momento dal tablet;
Collegate il tablet al PC utilizzando il cavo USB in dotazione.
Inserite la chiavetta Wi-Fi in una delle porte USB del PC, quindi connettetevi alla stessa rete Wi-Fi del tablet. Fatto ciò, in una finestra DOS, digitare il comando [ipconfig]:
Il vostro PC dispone di due schede di rete e quindi di due indirizzi IP:
- quello della riga 9, che è quello del PC sulla rete cablata;
- quella della riga 17, che è quella del PC sulla rete Wi-Fi;
Prendete nota di queste due informazioni. Vi serviranno. Ora vi trovate nella seguente configurazione:
 |
Il tablet dovrà connettersi al vostro PC. Quest’ultimo è normalmente protetto da un firewall che impedisce a qualsiasi elemento esterno di stabilire una connessione con il PC. È quindi necessario disattivare il firewall. Farlo utilizzando l’opzione [Panneau de configuration\Système et sécurité\Pare-feu Windows]. A volte è necessario disattivare anche il firewall configurato dall’antivirus. Ciò dipende dal tipo di antivirus in uso.
Ora, sul vostro PC, verificate la connessione di rete con il tablet utilizzando il comando [ping 192.168.1.y], dove [192.168.1.y] è l'indirizzo IP del tablet. Dovreste ottenere qualcosa di simile a questo:
Le righe da 4 a 7 indicano che il tablet con indirizzo IP [192.168.1.y] ha risposto al comando [ping].
6.8. Installazione di un JDK
Si troverà l'URL [http://www.oracle.com/technetwork/java/javase/downloads/index.html] (giugno 2016), l'JDK più recente. D'ora in poi chiameremo <jdk-install> la cartella di installazione del JDK.
 |
6.9. Installazione del gestore di emulatori Genymotion
L'azienda [Genymotion] offre un emulatore Android dalle elevate prestazioni. È disponibile nelle versioni URL e [https://cloud.genymotion.com/page/launchpad/download/] (giugno 2016).
Per ottenere una versione per uso personale è necessario registrarsi. Scaricate il prodotto [Genymotion] con la macchina virtuale VirtualBox:
D'ora in poi chiameremo <genymotion-install> la cartella di installazione di [Genymotion]. Avviate [Genymotion]. Scaricate quindi un'immagine per tablet:
 |
- in [1], aggiungere il terminale virtuale descritto in [2];
 |
- in [3], configurare il terminale;
 |  |
- in [4-5], personalizzate il terminale in base al vostro ambiente;
- in [6], avviare il terminale virtuale;
Se tutto va bene, si otterrà la finestra dell'emulatore Android:
A volte l'emulatore Android non si avvia. Su un computer Windows, è possibile verificare i due punti seguenti:
- verificare che la macchina virtuale [Hyper-V] non sia installata. Se necessario, disinstallarla [1-2];
 |  |
- quindi, nella procedura guidata di configurazione [Centre Réseau et partage] [1]:
 |
 |  |
- in [3], selezionare la o le schede associate alla macchina virtuale Virtual Box;
 |
- verificare che in [6] il driver per VirtualBox sia spuntato. Ripetere l'operazione per tutte le schede associate alla macchina virtuale Virtual Box;
6.10. Installazione di Maven
Maven è uno strumento per la gestione delle dipendenze di un progetto Java e molto altro ancora. È disponibile su URL [http://maven.apache.org/download.cgi].
 |
Scaricate e decomprimete l'archivio. Chiameremo <maven-install> la cartella di installazione di Maven.
 |
- In [1], il file [conf / settings.xml] configura Maven;
In esso si trovano le seguenti righe:
<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
Il valore predefinito della riga 4, se come nel mio caso il vostro {user.home} presenta uno spazio nel percorso (ad esempio [C:\Users\Serge Tahé]), può causare problemi ad alcuni software. In tal caso, scriveremo qualcosa del tipo:
<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
<localRepository>D:\Programs\devjava\maven\.m2\repository</localRepository>
e, alla riga 7, si eviterà un percorso che contenga spazi.
6.11. Installazione di IDE Android Studio
IDE Android Studio Community Edition è disponibile su URL [https://developer.android.com/studio/index.html] (giugno 2016):
 |
Installare IDE e avviarlo. Seguendo la procedura [1-8], installare i componenti di SDK Manager utilizzati dagli esempi che seguiranno. Se decidete di installare componenti più recenti, probabilmente riceverete degli avvisi da Android Studio che indicano che la configurazione degli esempi fa riferimento a componenti di SDK che non esistono nel vostro ambiente. Potrete quindi seguire i suggerimenti forniti da IDE.
 |
 |
 |
- in [9], richiedete di visualizzare i dettagli dei pacchetti:
 |
- nel [11] sopra riportato, gli esempi hanno utilizzato il SDK Build-Tools 23.0.3;
- in [9-12] qui sotto, specificare la cartella in cui è stato installato il gestore di emulatori [Genymotion];
 |  |
- in [13-18], si configura il tipo predefinito dei progetti;
 |  |
- in [17], il valore predefinito proposto è normalmente corretto;
- in [18], assicurarsi di disporre di un JDK 1.8;
Di seguito, in [19-26], si disattiva il controllo ortografico che per impostazione predefinita è impostato per la lingua inglese;
 |  |
 |
- di seguito, in [27-28], scegliete il tipo di scorciatoie da tastiera che preferite. Potete mantenere quelle predefinite di IntelliJ oppure scegliere quelle di un altro IDE a cui siete più abituati;
 |
- di seguito, in [29-30], attivate la visualizzazione dei numeri di riga del codice;
 |
- di seguito, in [31-34], specificate come desiderate gestire il primo progetto all’avvio di IDE e successivamente i progetti successivi;
 |
Con Android 2.1 (maggio 2016), la tecnologia [Instant Run] a volte causa problemi. In questo documento l'abbiamo disabilitata:
 |  |
- in [3-4], tutto è stato disattivato;
6.12. Utilizzo degli esempi
I progetti Android Studio degli esempi sono disponibili all'indirizzo ICI|. Scaricateli.
 |
Gli esempi sono stati realizzati con gli elementi definiti in precedenza:
- JDK 1.8;
- Android SDK Platform 23 per l'esecuzione;
I seguenti strumenti:
 |
Se il vostro ambiente non corrisponde a quello precedente, dovrete modificare la configurazione dei progetti. Ciò può risultare piuttosto complesso. In un primo momento, è probabilmente più semplice ricreare un ambiente di lavoro analogo a quello sopra descritto.
Avviare Android Studio, quindi aprire il progetto [exemple-07], ad esempio:
 |  |
 |
- in [1-3], si apre il progetto [Exemple-07];
- in [4], si verifica il file [local.properties];
 |  |
- alla riga 11 sopra indicata, inserire il percorso di SDK Android Manager <sdk-manager-install>. È possibile individuarlo seguendo la procedura [1-4]:
 |
Tutti gli esempi presenti in questo documento sono progetti Gradle configurati tramite un file [build.gradle] [1-2]:
 |
Il file [build.gradle] dell'esempio 07 è il seguente:
buildscript {
repositories {
mavenCentral()
mavenLocal()
}
dependencies {
// sostituire con la versione attuale del plugin Android
classpath 'com.android.tools.build:gradle:2.1.0'
// A partire dalla versione 0.11 del plugin Gradle per Android, è necessario utilizzare android-apt >= 1.3
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
}
apply plugin: 'com.android.application'
apply plugin: 'android-apt'
def AAVersion = '4.0.0'
dependencies {
apt "org.androidannotations:androidannotations:$AAVersion"
compile "org.androidannotations:androidannotations-api:$AAVersion"
compile 'com.android.support:appcompat-v7:23.4.0'
compile 'com.android.support:design:23.4.0'
compile fileTree(dir: 'libs', include: ['*.jar'])
}
repositories {
jcenter()
}
apt {
arguments {
androidManifestFile variant.outputs[0].processResources.manifestFile
resourcePackageName android.defaultConfig.applicationId
}
}
android {
compileSdkVersion 23
buildToolsVersion "23.0.3"
defaultConfig {
applicationId "android.exemples"
minSdkVersion 15
targetSdkVersion 23
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_7
targetCompatibility JavaVersion.VERSION_1_7
}
}
A seconda dell’ambiente Android (SDK e strumenti) che avete configurato, potrebbe essere necessario modificare le versioni nelle righe 8, 21, 22, 38 e 39. Android Studio vi aiuta fornendo dei suggerimenti. La soluzione più semplice è seguire tali suggerimenti.
È possibile accedere agli elementi del file [build.gradle] anche in un altro modo:
 |  |
- le diverse schede di [3] riprendono i diversi valori del file [build.gradle]. È quindi possibile costruirlo in questo modo, il che consente di aggirare i problemi di sintassi del file [build.gradle];
Un altro punto da verificare è il file JDK utilizzato da IDE e [5]:
 |
In [6], verificare il file JDK.
Tutti gli esempi sono progetti Gradle con dipendenze da scaricare. Per farlo, si può procedere come segue:
 |   |
- in [5], si compila il progetto;
Una volta che il progetto non presenta più errori, è necessario creare una configurazione di esecuzione [1-8]:
 |  |
- in [8], è possibile specificare che si desidera utilizzare sempre lo stesso terminale per l'esecuzione. In genere, questa opzione è selezionata per evitare di dover specificare il terminale da utilizzare ad ogni nuova esecuzione. In questo caso, la lasciamo deselezionata proprio perché testeremo diversi dispositivi Android;
- una volta creata la configurazione di esecuzione, si avvia il gestore degli emulatori Android [1-3];
 |  |
- se l’emulatore Android non si avvia, verificare i punti indicati al paragrafo 6.11;
Per avviare l'applicazione sull'emulatore, procedere come segue [1-4]:
 |  |
- in [2], dovrebbe apparire l'emulatore che avete avviato in precedenza;
 |
- in [5], la schermata visualizzata dall'emulatore;
Collegate ora un tablet Android a una porta USB del PC ed eseguite l'applicazione sul tablet:
 |
- in [6], selezionate il tablet Android e provate l'applicazione.
In [7] sono presenti terminali virtuali predefiniti. Impareremo ad aggiungerne e a eliminarne.
 |
 |
Nello screenshot qui sopra, i terminali proposti funzionano tutti con API 22. Li eliminiamo tutti perché vogliamo lavorare con API 23. Seguiamo la procedura [2-3] per i terminali da eliminare.
 |
- in [4-5], si aggiunge un tablet;
 |
- in [6], si seleziona un API. Nell’esempio sopra riportato si seleziona il API 23 per Windows a 64 bit;
 |
- in [7], il riepilogo della configurazione effettuata;
- in [8], è possibile effettuare una configurazione più avanzata del terminale virtuale;
 |
Una volta completata la procedura guidata, il terminale creato appare in [9].
A questo punto, se si riavvia l'esecuzione di [Exemple-07], si ottiene la seguente finestra:
 |
- in [1] compare il nuovo terminale virtuale;
- in [2] è possibile crearne di nuovi;
Effettuate alcune prove per individuare il terminale virtuale più adatto alla vostra postazione. In questo documento, gli esempi sono stati testati principalmente con l’emulatore Genymotion.
Indipendentemente dal terminale virtuale scelto, i log vengono visualizzati nella finestra denominata [Logcat] [1-2]:
Controllate regolarmente questi log. È lì che verranno segnalate le eccezioni che hanno causato l’arresto anomalo del vostro programma.
È inoltre possibile eseguire il debug del programma con i consueti strumenti di debug:
 |  |
- in [2], si imposta un punto di interruzione cliccando una volta sulla colonna a sinistra della riga di destinazione. Un nuovo clic annulla il punto di interruzione;
 |
- in [3], al punto di interruzione:
- [F6], per eseguire la riga senza entrare nei metodi se la riga contiene chiamate a metodi,
- [F5], per eseguire la riga entrando nei metodi se la riga contiene chiamate a metodi,
- [F8], per proseguire fino al punto di interruzione successivo;
- [Ctrl-F2] per interrompere il debug;
6.13. Installazione del plugin Chrome [Advanced Rest Client]
In questo documento si utilizza il browser Chrome di Google (http://www.google.fr/intl/fr/chrome/browser/). A questo verrà aggiunta l’estensione [Advanced Rest Client] . È possibile procedere come segue:
- visitare il sito di [Google Web store] (https://chrome.google.com/webstore) con il browser Chrome;
- cercare l’applicazione [Advanced Rest Client]:
 |
- l’applicazione è quindi disponibile per il download:
 |
- per scaricarla, è necessario creare un account Google. [Google Web Store] richiede quindi la conferma [1]:
 |  |
- In [2], l’estensione aggiunta è disponibile nell’opzione [Applications] [3]. Questa opzione viene visualizzata su ogni nuova scheda che create (CTRL-T) nel browser.
6.14. Gestione del « » jSON in Java
In modo trasparente per lo sviluppatore, il framework [Spring MVC] utilizza la libreria jSON [Jackson]. Per illustrare cos’è il jSON (JavaScript Object Notation), presentiamo qui un programma che serializza oggetti in jSON ed esegue l'operazione inversa deserializzando le stringhe jSON prodotte per ricreare gli oggetti iniziali.
La libreria «Jackson» consente di costruire:
- la stringa jSON di un oggetto: new ObjectMapper().writeValueAsString(object);
- un oggetto a partire da una stringa jSON: new ObjectMapper().readValue(jsonString, Object.class).
Entrambi i metodi possono generare un IOException. Ecco un esempio.
 |
Il progetto sopra riportato è un progetto Maven con il seguente file [pom.xml]:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>istia.st.pam</groupId>
<artifactId>json</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.3.3</version>
</dependency>
</dependencies>
</project>
- righe 12-16: la dipendenza che include la libreria 'Jackson';
La classe [Personne] è la seguente:
package istia.st.json;
public class Personne {
// dati
private String nom;
private String prenom;
private int age;
// costruttori
public Personne() {
}
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prenom = prénom;
this.age = âge;
}
// firma
public String toString() {
return String.format("Personne[%s, %s, %d]", nom, prenom, age);
}
// getter e setter
...
}
La classe [Main] è la seguente:
package istia.st.json;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class Main {
// strumento di serializzazione/deserializzazione
static ObjectMapper mapper = new ObjectMapper();
public static void main(String[] args) throws IOException {
// creazione di una persona
Personne paul = new Personne("Denis", "Paul", 40);
// visualizzazione JSON
String json = mapper.writeValueAsString(paul);
System.out.println("Json=" + json);
// istanziazione di una persona a partire dal JSON
Personne p = mapper.readValue(json, Personne.class);
// visualizzazione di una persona
System.out.println("Personne=" + p);
// un array
Personne virginie = new Personne("Radot", "Virginie", 20);
Personne[] personnes = new Personne[]{paul, virginie};
// visualizzazione JSON
json = mapper.writeValueAsString(personnes);
System.out.println("Json personnes=" + json);
// dizionario
Map<String, Personne> hpersonnes = new HashMap<String, Personne>();
hpersonnes.put("1", paul);
hpersonnes.put("2", virginie);
// visualizzazione JSON
json = mapper.writeValueAsString(hpersonnes);
System.out.println("Json hpersonnes=" + json);
}
}
L'esecuzione di questa classe produce la seguente visualizzazione sullo schermo:
Da questo esempio si ricava quanto segue:
- l'oggetto [ObjectMapper] necessario per le trasformazioni jSON / Oggetto: riga 11;
- la trasformazione [Personne] --> jSON: riga 17;
- la trasformazione jSON --> [Personne]: riga 20;
- l'eccezione [IOException] generata da entrambi i metodi: riga 13.
6.15. Installazione di [WampServer]
[WampServer] è un pacchetto software per lo sviluppo in PHP / MySQL / Apache su un computer Windows. Lo useremo esclusivamente per SGBD e MySQL.
 |  |
- sul sito di [WampServer] [1], scegliere la versione adatta [2],
- il file eseguibile scaricato è un programma di installazione. Durante l'installazione vengono richieste diverse informazioni. Queste non riguardano MySQL. È quindi possibile ignorarle. Al termine dell’installazione viene visualizzata la finestra [3]. Si avvia [WampServer],
 |  |
- in [4]; l’icona di [WampServer] viene installata nella barra delle applicazioni in basso a destra dello schermo [4],
- quando si fa clic su di essa, viene visualizzato il menu [5]. Esso consente di gestire il server Apache e il SGBD MySQL. Per gestirlo, si utilizza l’opzione [PhpPmyAdmin];
- si ottiene quindi la finestra riportata di seguito,
Non forniremo molti dettagli sull’utilizzo di [PhpMyAdmin]. Nel documento mostriamo come utilizzarlo.