6. Appendici
Qui spieghiamo come installare gli strumenti utilizzati in questo documento su macchine con Windows da 7 a 10. Il lettore dovrebbe adattare queste istruzioni al proprio ambiente.
6.1. Installazione dell'IDE Arduino
Il sito web ufficiale di Arduino è [http://www.arduino.cc/]. Qui troverai l'IDE di sviluppo per Arduino [http://arduino.cc/en/Main/Software]:
 |  |
Il file scaricato [1] è un file ZIP che, una volta estratto, crea la struttura di directory [2]. È possibile avviare l'IDE facendo doppio clic sul file eseguibile [3].
6.2. Installazione del driver Arduino
Affinché l'IDE possa comunicare con un Arduino, quest'ultimo deve essere riconosciuto dal PC host. A tal fine, procedere come segue:
- Collegare l'Arduino a una porta USB del computer host;
- Il sistema tenterà quindi di trovare il driver per il nuovo dispositivo USB. Non lo troverà. È quindi necessario specificare che il driver si trova sul disco in <arduino>/drivers, dove <arduino> è la cartella di installazione dell'IDE di Arduino.
6.3. Test dell'IDE
Per testare l'IDE, segui questi passaggi:
- Avvia l'IDE;
- collegare Arduino al PC tramite il cavo USB. Per ora, non includere la scheda di rete;
 |  |
- in [1], seleziona il tipo di scheda Arduino collegata alla porta USB;
- in [2], specificare la porta USB a cui è collegato l'Arduino. Per scoprirlo, scollegare l'Arduino e prendere nota delle porte. Ricollegarlo e controllare nuovamente le porte: quella che è stata aggiunta è la porta dell'Arduino;
Esegui alcuni degli esempi inclusi nell'IDE:
 |
L'esempio viene caricato e visualizzato:
 |
Gli esempi inclusi nell'IDE sono molto istruttivi e ben commentati. Il codice Arduino è scritto in C e si compone di due parti distinte:
- una funzione [setup] che viene eseguita una volta all'avvio dell'applicazione, sia quando viene "caricata" dal PC host su Arduino, sia quando l'applicazione è già presente su Arduino e viene premuto 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 13 come uscita;
- la funzione [loop] lo accende e lo spegne ripetutamente: il LED si accende e si spegne ogni secondo.
 |
Il programma visualizzato viene caricato su Arduino utilizzando il pulsante [1]. Una volta caricato, il programma viene eseguito e il LED 13 inizia a lampeggiare all'infinito.
6.4. Connessione di rete di Arduino
Gli Arduino e il PC host devono trovarsi sulla stessa rete privata:
 |
Se c'è un solo Arduino, può essere collegato al PC host utilizzando un semplice cavo RJ-45. Se ce ne sono più di uno, il PC host e gli Arduino saranno collegati alla stessa rete tramite un mini-hub.
Il PC host e gli Arduino saranno inseriti nella rete privata 192.168.2.x.
- Gli indirizzi IP degli Arduino sono impostati dal codice sorgente. Vedremo come;
- L'indirizzo IP del computer host può essere impostato come segue:
- Vai su [Pannello di controllo\Rete e Internet\Centro connessioni di rete e condivisione]:
 |
- In [1], segui il link [Connessione alla rete locale]
 |  |
- In [2], visualizzare le proprietà della connessione;
- In [4], visualizza le proprietà IPv4 [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 tutto in [7].
6.5. Test di un'applicazione di rete
Utilizzando l'IDE, caricare l'esempio [Esempi / 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>
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1, 177);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// listen for incoming clients
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
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>");
// add a meta refresh tag, so the browser pulls again every 5 seconds:
client.println("<meta http-equiv=\"refresh\" content=\"5\">");
// output the value of each analog input pin
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') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println("client disconnected");
}
}
Questa applicazione crea un server web sulla porta 80 (riga 30) all'indirizzo IP specificato alla riga 25. L'indirizzo MAC alla riga 23 è l'indirizzo MAC specificato sulla scheda di rete di Arduino.
La funzione [setup] inizializza il server web:
- riga 34: inizializza la porta seriale su cui l'applicazione registrerà i dati. Monitoreremo questi log;
- 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: registra 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 quel client; altrimenti, restituisce null;
- riga 51: se il client 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 restituisce vero finché questo buffer non è vuoto;
- riga 57: viene letto un carattere inviato dal client;
- riga 58: questo carattere viene visualizzato nella 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 inviando una serie di righe di testo che terminano con una riga vuota;
- il server risponde quindi al client inviando una risposta e chiudendo la connessione;
Riga 62: il server non fa nulla con le intestazioni HTTP che riceve dal client. Si limita ad attendere la riga vuota: una riga contenente solo il carattere \n;
- Righe 64–67: Il server invia al client 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 è generato dinamicamente dal server ed è in formato HTML (righe 68–69);
- riga 71: una riga HTML speciale che indica al browser del 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 i valori dei 6 ingressi analogici di Arduino al browser del client;
- riga 81: il documento HTML viene chiuso;
- riga 82: usciamo dal ciclo while della riga 55;
- riga 97: la connessione con il client viene chiusa;
- riga 98: l'evento viene registrato nella console di log;
- riga 100: torniamo all'inizio della funzione loop: il server riprenderà ad ascoltare i client. Abbiamo detto che il browser del client richiederebbe la stessa pagina ogni 5 secondi. Il server sarà pronto a rispondere di nuovo.
Modifica il codice alla riga 25 per includere l'indirizzo IP del tuo Arduino, ad esempio:
Carica il programma su Arduino. Avvia la console di log (Ctrl-M) (M maiuscola):
 |  |
- in [1], la console di log. Il server è stato avviato;
- in [2], utilizzando un browser, richiediamo l'indirizzo IP di Arduino. Qui, [192.168.2.2] viene tradotto per impostazione predefinita in [http://198.162.2.2:80];
- in [3], le informazioni inviate dal server web. Se si visualizza il codice sorgente della pagina del browser, si ottiene:
Qui possiamo vedere le righe di testo inviate dal server. Sul lato Arduino, la console di log visualizza ciò che il client gli invia:
- righe 2–9: intestazioni HTTP standard;
- riga 10: la riga vuota che le conclude.
Studia attentamente questo esempio. Ti aiuterà a comprendere la programmazione Arduino utilizzata nel laboratorio.
6.6. La libreria aJson
Nel compito di laboratorio che scriverai, gli Arduino scambiano righe di testo in formato JSON con i loro client. Per impostazione predefinita, l'IDE di Arduino non include una libreria per la gestione di JSON. Installeremo la libreria aJson disponibile all'indirizzo [https://github.com/interactive-matter/aJson].
 |  |
- In [1], scarica 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 di Arduino;
 |  |  |
- in [4], rinominare questa cartella in [aJson];
- in [5], il suo contenuto.
Ora, avvia l'IDE di Arduino:
 |
Verifica che nella sezione degli esempi siano ora presenti esempi per la libreria aJson. Esegui e studia questi esempi.
6.7. Il tablet Android
Gli esempi sono stati testati con il Samsung Galaxy Tab 2.
Per testare gli esempi su un tablet, devi prima installare il driver del tablet sul tuo computer di sviluppo. Il driver per il Samsung Galaxy Tab 2 è disponibile all'URL [http://www.samsung.com/fr/support/usefulsoftware/KIES/]:
 |
Per testare gli esempi, dovrai collegare il tablet a una rete (probabilmente Wi-Fi) e conoscere il suo indirizzo IP su quella rete. Ecco come procedere (Samsung Galaxy Tab 2):
- Accendi il tablet;
- Cerca tra le app disponibili sul tablet (in alto a destra) quella chiamata [Impostazioni] con l'icona di un ingranaggio;
- nella sezione a sinistra, attiva il Wi-Fi;
- nella sezione a destra, seleziona una rete Wi-Fi;
- Una volta connesso alla rete, tocca brevemente la rete selezionata. Verrà visualizzato l'indirizzo IP del tablet. Annotalo. Ti servirà;
Sempre nell'app [Impostazioni],
- seleziona l'opzione [Opzioni sviluppatore] a sinistra (in fondo alle opzioni);
- Assicurati che l'opzione [Debug USB] sulla destra sia selezionata.
Per tornare al menu, tocca l'icona centrale nella barra di stato in basso, quella che sembra una casa. Sempre nella barra di stato in basso,
- l'icona all'estrema sinistra è il pulsante Indietro: ti riporta alla schermata precedente;
- l'icona all'estrema destra è il gestore delle attività. Puoi visualizzare e gestire tutte le attività attualmente in esecuzione sul tuo tablet;
Collega il tablet al PC utilizzando il cavo USB in dotazione.
Inserisci la chiavetta Wi-Fi in una delle porte USB del PC, quindi connettiti alla stessa rete Wi-Fi del tablet. Una volta fatto ciò, in una finestra DOS, digita il comando [ipconfig]:
Il tuo PC ha due schede di rete e quindi due indirizzi IP:
- quello alla riga 9, che è l'indirizzo del PC sulla rete cablata;
- quello alla riga 17, che è l'indirizzo del PC sulla rete Wi-Fi;
Prendi nota di queste due informazioni. Ti serviranno. Ora ti trovi nella seguente configurazione:
 |
Il tablet dovrà connettersi al tuo PC. Il tuo PC è normalmente protetto da un firewall che impedisce a qualsiasi dispositivo esterno di stabilire una connessione con esso. Dovrai quindi disattivare il firewall. Fallo utilizzando l'opzione [Pannello di controllo\Sistema e sicurezza\Windows Firewall]. A volte è necessario disattivare anche il firewall configurato dal tuo software antivirus. Questo dipende dal tuo programma antivirus.
Ora, sul PC, verifica 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. Dovresti vedere qualcosa di simile a questo:
Le righe 4–7 indicano che l'indirizzo IP [192.168.1.y] ha risposto al comando [ping].
6.8. Installazione di un JDK
L'ultima versione del JDK è disponibile all'URL [http://www.oracle.com/technetwork/java/javase/downloads/index.html] (giugno 2016). D'ora in poi ci riferiremo alla cartella di installazione del JDK come <jdk-install>.
 |
6.9. Installazione del gestore dell'emulatore Genymotion
L'azienda [Genymotion] offre un emulatore Android ad alte prestazioni. È disponibile all'indirizzo [https://cloud.genymotion.com/page/launchpad/download/] (giugno 2016).
Per ottenere una versione per uso personale è necessario registrarsi. Scaricare il prodotto [Genymotion] con la macchina virtuale VirtualBox:
D'ora in poi ci riferiremo alla cartella di installazione di [Genymotion] come <genymotion-install>. Avviare [Genymotion]. Quindi scaricare un'immagine per un tablet:
 |
- in [1], aggiungere il terminale virtuale descritto in [2];
 |
- in [3], configurare il terminale;
 |  |
- in [4-5], personalizza il terminale in base al tuo ambiente;
- in [6], avvia il terminale virtuale;
Se tutto va bene, vedrai la finestra dell'emulatore Android:
A volte, l'emulatore Android non si avvia. Su un computer Windows, puoi verificare i seguenti due punti:
- Verifica che la macchina virtuale [Hyper-V] non sia installata. Se necessario, disinstallala [1-2];
 |  |
- quindi nella procedura guidata di configurazione [Centro connessioni di rete e condivisione] [1]:
 |
 |  |
- in [3], selezionare le schede di rete associate alla macchina virtuale VirtualBox;
 |
- verificare che in [6] sia selezionato il driver per VirtualBox. Ripetere questo passaggio per tutte le schede di rete associate alla macchina virtuale VirtualBox;
6.10. Installazione di Maven
Maven è uno strumento per la gestione delle dipendenze in un progetto Java e non solo. È disponibile all'URL [http://maven.apache.org/download.cgi].
 |
Scarica e decomprimi l'archivio. Ci riferiremo alla cartella di installazione di Maven come <maven-install>.
 |
- In [1], il file [conf/settings.xml] configura Maven;
Contiene 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 alla riga 4, se — come nel mio caso — il percorso {user.home} contiene uno spazio (ad esempio, [C:\Users\Serge Tahé]), potrebbe causare problemi con alcuni software. In tal caso, dovresti scrivere 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, eviteremo un percorso che contenga spazi.
6.11. Installazione dell'IDE Android Studio
L'IDE Android Studio Community Edition è disponibile all'indirizzo [https://developer.android.com/studio/index.html] (giugno 2016):
 |
Installa l'IDE e poi avvialo. Segui i passaggi [1-8] per installare i componenti di SDK Manager utilizzati dagli esempi che seguono. Se decidi di installare componenti più recenti, probabilmente riceverai avvisi da Android Studio che indicano che la configurazione dell'esempio fa riferimento a componenti SDK che non esistono nel tuo ambiente. Puoi quindi seguire i suggerimenti forniti dall'IDE.
 |
 |
 |
- In [9], visualizza i dettagli del pacchetto:
 |
- Nel punto [11] sopra, gli esempi utilizzavano SDK Build-Tools 23.0.3;
- nei [9-12] riportati di seguito, specificare la cartella in cui è stato installato il gestore dell'emulatore [Genymotion];
 |  |
- Nei punti [13-18], configurare il tipo di progetto predefinito;
 |  |
- in [17], il valore predefinito è solitamente corretto;
- in [18], assicurarsi di disporre di JDK 1.8;
Di seguito, nei punti [19-26], disattiva il controllo ortografico, che è impostato di default sull'inglese;
 |  |
 |
- di seguito, in [27-28], scegli il tipo di scorciatoie da tastiera che preferisci. Puoi mantenere le impostazioni predefinite di IntelliJ oppure scegliere quelle di un altro IDE a cui sei più abituato;
 |
- Di seguito, in [29-30], abilita i numeri di riga nel codice;
 |
- di seguito, nei campi [31-34], specifica come desideri gestire il primo progetto all'avvio dell'IDE e i progetti successivi;
 |
Con Android 2.1 (maggio 2016), la funzione [Instant Run] a volte causa problemi. In questo documento l'abbiamo disabilitata:
 |  |
- in [3-4], tutto è stato disabilitato;
6.12. Utilizzo degli esempi
I progetti Android Studio relativi agli esempi sono disponibili QUI|. Scaricateli.
 |
Gli esempi sono stati realizzati utilizzando i componenti definiti in precedenza:
- JDK 1.8;
- Android SDK Platform 23 per il runtime;
I seguenti strumenti SDK:
 |
Se il tuo ambiente non corrisponde a quello descritto sopra, dovrai modificare la configurazione del progetto. Questa operazione può risultare piuttosto noiosa. Inizialmente, è probabilmente più semplice configurare un ambiente di lavoro simile a quello descritto sopra.
Avvia Android Studio e poi apri il progetto [example-07], ad esempio:
 |  |
 |
- In [1-3], aprire il progetto [Example-07];
- In [4], controllare il file [local.properties];
 |  |
- alla riga 11 sopra, inserisci il percorso di Android SDK Manager <sdk-manager-install>. Puoi trovarlo seguendo i passaggi [1-4]:
 |
Tutti gli esempi in questo documento sono progetti Gradle configurati tramite un file [build.gradle] [1-2]:
 |
Il file [build.gradle] per l'Esempio 07 è il seguente:
buildscript {
repositories {
mavenCentral()
mavenLocal()
}
dependencies {
// replace with the current version of the Android plugin
classpath 'com.android.tools.build:gradle:2.1.0'
// Since Android's Gradle plugin 0.11, you have to use 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 hai configurato, potrebbe essere necessario modificare le versioni nelle righe 8, 21, 22, 38 e 39. Android Studio ti aiuta fornendo dei suggerimenti. L'approccio più semplice è seguire questi suggerimenti.
È possibile accedere agli elementi del file [build.gradle] in un altro modo:
 |  |
- le varie schede in [3] riflettono i diversi valori presenti nel file [build.gradle]. È quindi possibile configurarlo in questo modo, evitando così problemi di sintassi nel file [build.gradle];
Un altro punto da verificare è il JDK utilizzato dall'IDE [5]:
 |
In [6], controllare il JDK.
Tutti gli esempi sono progetti Gradle con dipendenze che devono essere scaricate. Per farlo, procedere come segue:
 |   |
- In [5], 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. Generalmente, questa opzione è selezionata per evitare di dover specificare il terminale da utilizzare per ogni nuova esecuzione. In questo caso, la lasciamo deselezionata perché testeremo diversi dispositivi Android;
- Una volta creata la configurazione di esecuzione, avviare l'Android Emulator Manager [1-3];
 |  |
- se l'emulatore Android non si avvia, controllare i punti menzionati nella sezione 6.11;
Per avviare l'applicazione sull'emulatore, procedere come segue [1-4]:
 |  |
- al punto [2], dovresti vedere l'emulatore che hai avviato in precedenza;
 |
- in [5], la schermata visualizzata dall'emulatore;
Ora collega un tablet Android a una porta USB del PC ed esegui l'applicazione su di esso:
 |
- In [6], selezionare il tablet Android e testare l'applicazione.
In [7] sono disponibili terminali virtuali predefiniti. Impareremo come aggiungerli e rimuoverli.
 |
 |
Nello screenshot qui sopra, tutti i dispositivi elencati utilizzano l'API 22. Li stiamo rimuovendo tutti perché vogliamo utilizzare l'API 23. Seguiamo la procedura [2-3] per rimuovere i dispositivi.
 |
- In [4-5], aggiungiamo un tablet;
 |
- in [6], selezioniamo un'API. Sopra, selezioniamo l'API 23 per Windows a 64 bit;
 |
- In [7] viene visualizzato il riepilogo della configurazione;
- In [8] è possibile eseguire una configurazione più avanzata del terminale virtuale;
 |
Una volta completata la procedura guidata, il terminale creato appare in [9].
Una volta fatto ciò, se riesegui [Esempio-07], vedrai ora la seguente finestra:
 |
- in [1] appare il nuovo terminale virtuale;
- in [2], è possibile crearne di nuovi;
Prova a individuare il terminale virtuale più adatto al tuo sistema. 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]:
Controlla regolarmente questi log. È qui che verranno segnalate le eccezioni che hanno causato il crash del tuo programma.
Puoi anche eseguire il debug del tuo programma utilizzando strumenti di debug standard:
 |  |
- in [2], impostare un punto di interruzione cliccando una volta sulla colonna a sinistra della riga desiderata. Cliccando di nuovo si rimuove il punto di interruzione;
 |
- in [3], al punto di interruzione, premere:
- [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 passare al punto di interruzione successivo;
- [Ctrl-F2] per interrompere il debug;
6.13. Installazione del plugin Chrome [Advanced Rest Client]
In questo documento utilizziamo il browser Chrome di Google (http://www.google.fr/intl/fr/chrome/browser/). Aggiungeremo l'estensione [ Advanced Rest Client]. Ecco come procedere:
- Accedere al [Google Web Store] (https://chrome.google.com/webstore) utilizzando il browser Chrome;
- cerca l'app [Advanced Rest Client]:
 |
- L'app è quindi disponibile per il download:
 |
- per scaricarla, dovrai creare un account Google. Il [Google Web Store] ti chiederà quindi una conferma [1]:
 |  |
- in [2], l'estensione aggiunta è disponibile nell'opzione [Applicazioni] [3]. Questa opzione appare su ogni nuova scheda che crei (CTRL-T) nel browser.
6.14. Gestione di oggetti 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 gli oggetti in JSON ed esegue l'operazione inversa deserializzando le stringhe JSON generate per ricreare gli oggetti originali.
La libreria 'Jackson' consente di costruire:
- la stringa JSON di un oggetto: new ObjectMapper().writeValueAsString(object);
- un oggetto da una stringa JSON: new ObjectMapper().readValue(jsonString, Object.class).
Entrambi i metodi possono generare un'eccezione 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 [Person] è la seguente:
package istia.st.json;
public class Personne {
// data
private String nom;
private String prenom;
private int age;
// manufacturers
public Personne() {
}
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prenom = prénom;
this.age = âge;
}
// signature
public String toString() {
return String.format("Personne[%s, %s, %d]", nom, prenom, age);
}
// getters and setters
...
}
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 {
// the serialization / deserialization tool
static ObjectMapper mapper = new ObjectMapper();
public static void main(String[] args) throws IOException {
// creation of a person
Personne paul = new Personne("Denis", "Paul", 40);
// json display
String json = mapper.writeValueAsString(paul);
System.out.println("Json=" + json);
// person instantiation from Json
Personne p = mapper.readValue(json, Personne.class);
// person display
System.out.println("Personne=" + p);
// a picture
Personne virginie = new Personne("Radot", "Virginie", 20);
Personne[] personnes = new Personne[]{paul, virginie};
// json display
json = mapper.writeValueAsString(personnes);
System.out.println("Json personnes=" + json);
// dictionary
Map<String, Personne> hpersonnes = new HashMap<String, Personne>();
hpersonnes.put("1", paul);
hpersonnes.put("2", virginie);
// json display
json = mapper.writeValueAsString(hpersonnes);
System.out.println("Json hpersonnes=" + json);
}
}
L'esecuzione di questa classe produce il seguente output sullo schermo:
Punti chiave dell'esempio:
- l'oggetto [ObjectMapper] necessario per le trasformazioni JSON/Object: riga 11;
- la trasformazione [Person] --> JSON: riga 17;
- la trasformazione da JSON a [Person]: riga 20;
- l'eccezione [IOException] generata da entrambi i metodi: riga 13.
6.15. Installazione di [ WampServer]
[WampServer] è una suite di software per lo sviluppo in PHP / MySQL / Apache su un computer Windows. Lo useremo esclusivamente per il DBMS MySQL.
 |  |
- Sul sito web di [WampServer] [1], scegli la versione appropriata [2],
- Il file eseguibile scaricato è un programma di installazione. Durante l'installazione ti verranno richieste diverse informazioni. Queste non riguardano MySQL, quindi puoi ignorarle. Al termine dell'installazione appare la finestra [3]. Avvia [WampServer],
 |  |
- in [4], l'icona [WampServer] appare nella barra delle applicazioni in basso a destra dello schermo [4],
- quando si fa clic su di essa, appare il menu [5]. Consente di gestire il server Apache e il DBMS MySQL. Per gestire quest'ultimo, utilizzare l'opzione [PhpMyAdmin],
- che apre la finestra mostrata di seguito,
Forniremo alcuni dettagli sull'utilizzo di [PhpMyAdmin]. Nel documento mostriamo come utilizzarlo.