6. Anexos
Aqui explicamos como instalar as ferramentas utilizadas neste documento em máquinas com Windows 7 a 10. O leitor deve adaptar estas instruções ao seu próprio ambiente.
6.1. Instalação do IDE do Arduino
O site oficial do Arduino é [http://www.arduino.cc/]. É aqui que encontrará o IDE de desenvolvimento para Arduinos [http://arduino.cc/en/Main/Software]:
 |  |
O ficheiro descarregado [1] é um ficheiro ZIP que, uma vez extraído, cria a estrutura de diretórios [2]. Pode iniciar o IDE clicando duas vezes no ficheiro executável [3].
6.2. Instalação do controlador do Arduino
Para que o IDE comunique com um Arduino, este deve ser reconhecido pelo PC anfitrião. Para tal, siga estes passos:
- Ligue o Arduino a uma porta USB no computador anfitrião;
- O sistema tentará então encontrar o controlador para o novo dispositivo USB. Não o encontrará. Deve então especificar que o controlador se encontra no disco em <arduino>/drivers, onde <arduino> é a pasta de instalação do IDE do Arduino.
6.3. Testar o IDE
Para testar o IDE, siga estes passos:
- Inicie o IDE;
- ligue o Arduino ao PC através do cabo USB. Por enquanto, não inclua a placa de rede;
 |  |
- em [1], selecione o tipo de placa Arduino ligada à porta USB;
- em [2], especifique a porta USB à qual o Arduino está ligado. Para descobrir isso, desligue o Arduino e anote as portas. Volte a ligá-lo e verifique as portas novamente: a que foi adicionada é a porta do Arduino;
Execute alguns dos exemplos incluídos no IDE:
 |
O exemplo é carregado e apresentado:
 |
Os exemplos incluídos no IDE são muito didáticos e bem comentados. O código Arduino é escrito em C e consiste em duas partes distintas:
- uma função [setup] que é executada uma vez quando a aplicação é iniciada, quer seja quando é «carregada» do PC anfitrião para o Arduino, quer seja quando a aplicação já se encontra no Arduino e o botão [Reset] é premido. É aqui que se coloca o código de inicialização da aplicação;
- uma função [loop] que é executada continuamente (loop infinito). É aqui que se coloca o núcleo da aplicação.
Aqui,
- a função [setup] configura o pino 13 como saída;
- a função [loop] liga-o e desliga-o repetidamente: o LED acende e apaga a cada segundo.
 |
O programa apresentado é carregado no Arduino através do botão [1]. Depois de carregado, o programa é executado e o LED 13 começa a piscar indefinidamente.
6.4. Ligação de rede do Arduino
O(s) Arduino(s) e o PC anfitrião devem estar na mesma rede privada:
 |
Se houver apenas um Arduino, este pode ser ligado ao PC anfitrião utilizando um simples cabo RJ-45. Se houver mais do que um, o PC anfitrião e os Arduinos serão ligados à mesma rede através de um mini-hub.
O PC anfitrião e os Arduinos serão colocados na rede privada 192.168.2.x.
- Os endereços IP dos Arduinos são definidos pelo código-fonte. Vamos ver como;
- O endereço IP do computador anfitrião pode ser definido da seguinte forma:
- Vá para [Painel de Controlo\Rede e Internet\Centro de Rede e Partilha]:
 |
- Em [1], clique no link [Conexão de rede local]
 |  |
- Em [2], visualize as propriedades da ligação;
- Em [4], visualize as propriedades IPv4 [3] da ligação;
 |
- Em [5], atribua o endereço IP [192.168.2.1] ao computador anfitrião;
- em [6], atribua a máscara de sub-rede [255.255.255.0] à rede;
- confirme tudo em [7].
6.5. Testar uma aplicação de rede
Utilizando o IDE, carregue o exemplo [Exemplos / 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");
}
}
Esta aplicação cria um servidor web na porta 80 (linha 30) no endereço IP especificado na linha 25. O endereço MAC na linha 23 é o endereço MAC especificado na placa de rede do Arduino.
A função [setup] inicializa o servidor web:
- linha 34: inicializa a porta serial na qual a aplicação irá registar dados. Iremos monitorizar estes registos;
- linha 41: o nó TCP/IP (IP, porta) é inicializado;
- linha 42: o servidor da linha 30 é iniciado neste nó de rede;
- linhas 43–44: regista o endereço IP do servidor web;
A função [loop] implementa o servidor web:
- linha 50: se um cliente se ligar ao servidor web, [server].available devolve esse cliente; caso contrário, devolve null;
- linha 51: se o cliente não for nulo;
- linha 55: enquanto o cliente estiver ligado;
- linha 56: [client].available é verdadeiro se o cliente tiver enviado caracteres. Estes são armazenados num buffer. [client].available retorna verdadeiro enquanto este buffer não estiver vazio;
- linha 57: um caractere enviado pelo cliente é lido;
- linha 58: este caractere é exibido na consola de registo;
- linha 62: No protocolo HTTP, o cliente e o servidor trocam linhas de texto.
- O cliente envia um pedido HTTP ao servidor web, enviando uma série de linhas de texto que terminam com uma linha vazia;
- o servidor responde então ao cliente enviando uma resposta e encerrando a ligação;
Linha 62: O servidor não faz nada com os cabeçalhos HTTP que recebe do cliente. Ele simplesmente aguarda a linha vazia: uma linha contendo apenas o caractere \n;
- Linhas 64–67: O servidor envia ao cliente as linhas de texto padrão do protocolo HTTP. Estas terminam com uma linha em branco (linha 67);
- A partir da linha 68, o servidor envia um documento ao seu cliente. Este documento é gerado dinamicamente pelo servidor e está no formato HTML (linhas 68–69);
- linha 71: uma linha HTML especial que instrui o navegador do cliente a atualizar a página a cada 5 segundos. Assim, o navegador irá solicitar a mesma página a cada 5 segundos;
- Linhas 73–80: O servidor envia os valores das 6 entradas analógicas do Arduino para o navegador do cliente;
- linha 81: o documento HTML é fechado;
- linha 82: saímos do ciclo while da linha 55;
- linha 97: a ligação com o cliente é encerrada;
- linha 98: o evento é registado na consola de registo;
- linha 100: voltamos ao início da função de loop: o servidor retomará a escuta de clientes. Mencionámos que o navegador do cliente solicitaria a mesma página a cada 5 segundos. O servidor estará lá para responder novamente.
Modifique o código na linha 25 para incluir o endereço IP do seu Arduino, por exemplo:
Carregue o programa para o Arduino. Inicie a consola de registo (Ctrl-M) (M maiúsculo):
 |  |
- em [1], a consola de registo. O servidor foi iniciado;
- em [2], utilizando um navegador, solicitamos o endereço IP do Arduino. Aqui, [192.168.2.2] é traduzido por predefinição para [http://198.162.2.2:80];
- em [3], a informação enviada pelo servidor web. Se visualizar o código-fonte da página do navegador, obtém:
Aqui, podemos ver as linhas de texto enviadas pelo servidor. No lado do Arduino, a consola de registo exibe o que o cliente lhe envia:
- linhas 2–9: cabeçalhos HTTP padrão;
- linha 10: a linha vazia que as encerra.
Estude este exemplo com atenção. Ele irá ajudá-lo a compreender a programação do Arduino utilizada no laboratório.
6.6. A biblioteca aJson
Na tarefa de laboratório que irá realizar, os Arduinos trocam linhas de texto no formato JSON com os seus clientes. Por predefinição, o IDE do Arduino não inclui uma biblioteca para lidar com JSON. Iremos instalar a biblioteca aJson disponível em [https://github.com/interactive-matter/aJson].
 |  |
- Em [1], descarregue a versão compactada do repositório GitHub;
- descompacte a pasta e copie a pasta [aJson-master] [2] para a pasta [<arduino>/libraries] [3], onde <arduino> é a pasta de instalação do IDE do Arduino;
 |  |  |
- em [4], renomeie esta pasta para [aJson];
- em [5], o seu conteúdo.
Agora, inicie o Arduino IDE:
 |
Verifique se, nos exemplos, já tem exemplos para a biblioteca aJson. Execute e estude esses exemplos.
6.7. O tablet Android
Os exemplos foram testados com o Samsung Galaxy Tab 2.
Para testar os exemplos num tablet, deve primeiro instalar o controlador do tablet na sua máquina de desenvolvimento. O controlador para o Samsung Galaxy Tab 2 pode ser encontrado no URL [http://www.samsung.com/fr/support/usefulsoftware/KIES/]:
 |
Para testar os exemplos, terá de ligar o tablet a uma rede (provavelmente Wi-Fi) e saber o seu endereço IP nessa rede. Eis como proceder (Samsung Galaxy Tab 2):
- Ligue o seu tablet;
- Procure entre as aplicações disponíveis no tablet (canto superior direito) pela que se chama [Definições], com um ícone de engrenagem;
- na secção à esquerda, ative o Wi-Fi;
- na secção à direita, selecione uma rede Wi-Fi;
- Assim que estiver ligado à rede, toque brevemente na rede selecionada. O endereço IP do tablet será apresentado. Anote-o. Vai precisar dele;
Ainda no aplicativo [Configurações],
- selecione a opção [Opções do programador] à esquerda (na parte inferior das opções);
- Certifique-se de que a opção [Depuração USB] à direita está marcada.
Para voltar ao menu, toque no ícone do meio na barra de estado na parte inferior — aquele que se parece com uma casa. Ainda na barra de estado na parte inferior,
- o ícone na extrema esquerda é o botão Voltar: leva-o de volta ao ecrã anterior;
- o ícone na extrema direita é o gestor de tarefas. Pode visualizar e gerir todas as tarefas atualmente em execução no seu tablet;
Ligue o seu tablet ao PC utilizando o cabo USB incluído.
Ligue o adaptador Wi-Fi a uma das portas USB do PC e, em seguida, ligue-se à mesma rede Wi-Fi que o tablet. Depois de fazer isso, numa janela do DOS, digite o comando [ipconfig]:
O seu PC tem duas placas de rede e, por isso, dois endereços IP:
- o da linha 9, que é o endereço do PC na rede com fios;
- o da linha 17, que é o endereço do PC na rede Wi-Fi;
Anote estas duas informações. Vai precisar delas. Encontra-se agora na seguinte configuração:
 |
O tablet terá de se ligar ao seu PC. Normalmente, o seu PC está protegido por uma firewall que impede que qualquer dispositivo externo estabeleça uma ligação com ele. Por isso, terá de desativar a firewall. Faça-o através da opção [Painel de Controlo\Sistema e Segurança\Firewall do Windows]. Por vezes, também é necessário desativar a firewall configurada pelo seu software antivírus. Isto depende do seu programa antivírus.
Agora, no seu PC, verifique a ligação de rede com o tablet utilizando o comando [ping 192.168.1.y], em que [192.168.1.y] é o endereço IP do tablet. Deverá ver algo semelhante a isto:
As linhas 4–7 indicam que o endereço IP [192.168.1.y] respondeu ao comando [ping].
6.8. Instalação de um JDK
O JDK mais recente pode ser encontrado no URL [http://www.oracle.com/technetwork/java/javase/downloads/index.html] (junho de 2016). A partir daqui, referir-nos-emos à pasta de instalação do JDK como <jdk-install>.
 |
6.9. Instalação do gestor do emulador Genymotion
A empresa [Genymotion] oferece um emulador Android de alto desempenho. Está disponível no URL [https://cloud.genymotion.com/page/launchpad/download/] (junho de 2016).
Terá de se registar para obter uma versão para uso pessoal. Descarregue o produto [Genymotion] com a máquina virtual VirtualBox:
A partir de agora, referir-nos-emos à pasta de instalação do [Genymotion] como <genymotion-install>. Inicie o [Genymotion]. Em seguida, descarregue uma imagem para um tablet:
 |
- em [1], adicione o terminal virtual descrito em [2];
 |
- em [3], configure o terminal;
 |  |
- em [4-5], personalize o terminal para o seu ambiente;
- em [6], inicie o terminal virtual;
Se tudo correr bem, verá a janela do emulador Android:
Por vezes, o emulador Android não inicia. Num computador com Windows, pode verificar os dois pontos seguintes:
- Verifique se a máquina virtual [Hyper-V] não está instalada. Se necessário, desinstale-a [1-2];
 |  |
- depois, no assistente de configuração [Centro de Rede e Partilha] [1]:
 |
 |  |
- em [3], selecione o(s) adaptador(es) de rede associado(s) à máquina virtual do VirtualBox;
 |
- verifique se, em [6], o controlador do VirtualBox está marcado. Repita este passo para todos os adaptadores de rede associados à máquina virtual do VirtualBox;
6.10. Instalação do Maven
O Maven é uma ferramenta para gerir dependências num projeto Java e muito mais. Está disponível no URL [http://maven.apache.org/download.cgi].
 |
Descarregue e descompacte o arquivo. Iremos referir-nos à pasta de instalação do Maven como <maven-install>.
 |
- Em [1], o ficheiro [conf/settings.xml] configura o Maven;
Contém as seguintes linhas:
<!-- localRepository
| The path to the local repository maven will use to store artifacts.
|
| Default: ${user.home}/.m2/repository
<localRepository>/path/to/local/repo</localRepository>
-->
O valor padrão na linha 4, se — como no meu caso — o seu caminho {user.home} contiver um espaço (por exemplo, [C:\Users\Serge Tahé]), pode causar problemas com determinado software. Nesse caso, deve escrever algo como:
<!-- 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 na linha 7, evitaremos um caminho que contenha espaços.
6.11. Instalação do IDE Android Studio
O IDE Android Studio Community Edition está disponível em [https://developer.android.com/studio/index.html] (junho de 2016):
 |
Instale o IDE e, em seguida, inicie-o. Siga os passos [1-8] para instalar os componentes do SDK Manager utilizados pelos exemplos que se seguem. Se decidir instalar componentes mais recentes, provavelmente receberá avisos do Android Studio a indicar que a configuração do exemplo faz referência a componentes do SDK que não existem no seu ambiente. Pode então seguir as sugestões fornecidas pelo IDE.
 |
 |
 |
- Em [9], consulte os detalhes do pacote:
 |
- No [11] acima, os exemplos utilizaram o SDK Build-Tools 23.0.3;
- nos [9-12] abaixo, especifique a pasta onde instalou o gestor do emulador [Genymotion];
 |  |
- Em [13-18], configure o tipo de projeto padrão;
 |  |
- em [17], o valor padrão geralmente está correto;
- em [18], certifique-se de que tem o JDK 1.8;
Abaixo, em [19-26], desative a verificação ortográfica, que está definida para inglês por predefinição;
 |  |
 |
- abaixo, em [27-28], escolha o tipo de atalhos de teclado que deseja. Pode manter as configurações predefinidas do IntelliJ ou escolher as de outro IDE com o qual esteja mais habituado;
 |
- Abaixo, em [29-30], ative os números de linha no código;
 |
- abaixo, em [31-34], especifique como pretende lidar com o primeiro projeto ao iniciar o IDE e com os projetos subsequentes;
 |
Com o Android 2.1 (maio de 2016), a funcionalidade [Instant Run] causa, por vezes, problemas. Neste documento, desativámo-la:
 |  |
- em [3-4], tudo foi desativado;
6.12. Utilizando os exemplos
Os projetos do Android Studio para os exemplos estão disponíveis AQUI|. Faça o download.
 |
Os exemplos foram criados utilizando os componentes definidos anteriormente:
- JDK 1.8;
- Android SDK Platform 23 para tempo de execução;
As seguintes ferramentas SDK:
 |
Se o seu ambiente não corresponder ao descrito acima, terá de alterar a configuração do projeto. Isto pode ser bastante moroso. Inicialmente, é provavelmente mais fácil configurar um ambiente de trabalho semelhante ao descrito acima.
Inicie o Android Studio e, em seguida, abra o projeto [example-07], por exemplo:
 |  |
 |
- Em [1-3], abra o projeto [Example-07];
- Em [4], verifique o ficheiro [local.properties];
 |  |
- na linha 11 acima, introduza a localização do Android SDK Manager <sdk-manager-install>. Pode encontrá-la seguindo os passos [1-4]:
 |
Todos os exemplos neste documento são projetos Gradle configurados por um ficheiro [build.gradle] [1-2]:
 |
O ficheiro [build.gradle] para o Exemplo 07 é o seguinte:
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
}
}
Dependendo do ambiente Android (SDK e ferramentas) que tiver configurado, poderá ser necessário alterar as versões nas linhas 8, 21, 22, 38 e 39. O Android Studio ajuda, apresentando sugestões. A abordagem mais fácil é seguir essas sugestões.
Os elementos do ficheiro [build.gradle] podem ser acedidos de outra forma:
 |  |
- as várias separadores em [3] refletem os diferentes valores no ficheiro [build.gradle]. Pode, portanto, configurá-lo desta forma, o que lhe permite evitar problemas de sintaxe no ficheiro [build.gradle];
Outro ponto a verificar é o JDK utilizado pelo IDE [5]:
 |
Em [6], verifique o JDK.
Todos os exemplos são projetos Gradle com dependências que precisam de ser descarregadas. Para tal, proceda da seguinte forma:
 |   |
- Em [5], compile o projeto;
Assim que o projeto estiver sem erros, deve criar uma configuração de execução [1-8]:
 |  |
- Em [8], pode especificar que pretende utilizar sempre o mesmo terminal para a execução. Geralmente, esta opção é marcada para evitar ter de especificar o terminal a utilizar em cada nova execução. Aqui, deixamos esta opção desmarcada porque vamos testar diferentes dispositivos Android;
- Depois de criada a configuração de execução, inicie o Gestor do Emulador Android [1-3];
 |  |
- se o emulador Android não iniciar, verifique os pontos mencionados na secção 6.11;
Para iniciar a aplicação no emulador, proceda da seguinte forma [1-4]:
 |  |
- em [2], deverá ver o emulador que iniciou anteriormente;
 |
- em [5], a vista exibida pelo emulador;
Agora, ligue um tablet Android a uma porta USB do PC e execute a aplicação nele:
 |
- Em [6], selecione o tablet Android e teste a aplicação.
Em [7], temos terminais virtuais predefinidos. Vamos aprender a adicioná-los e removê-los.
 |
 |
Na captura de ecrã acima, todos os dispositivos listados estão a utilizar a API 22. Vamos removê-los todos porque queremos utilizar a API 23. Seguimos o procedimento [2-3] para remover os dispositivos.
 |
- Em [4-5], adicionamos um tablet;
 |
- em [6], selecionamos uma API. Acima, selecionamos a API 23 para o Windows de 64 bits;
 |
- Em [7], é apresentado o resumo da configuração;
- Em [8], é possível realizar uma configuração mais avançada do terminal virtual;
 |
Assim que o assistente estiver concluído, o terminal criado aparece em [9].
Depois de fazer isto, se voltar a executar [Exemplo-07], verá agora a seguinte janela:
 |
- em [1], o novo terminal virtual aparece;
- em [2], pode criar novos;
Experimente para determinar o terminal virtual mais adequado ao seu sistema. Neste documento, os exemplos foram testados principalmente com o emulador Genymotion.
Independentemente do terminal virtual escolhido, os registos são apresentados na janela denominada [Logcat] [1-2]:
Verifique estes registos regularmente. É aqui que serão relatadas as exceções que causaram a falha do seu programa.
Também pode depurar o seu programa utilizando ferramentas de depuração padrão:
 |  |
- em [2], defina um ponto de interrupção clicando uma vez na coluna à esquerda da linha de destino. Clicar novamente remove o ponto de interrupção;
 |
- em [3], no ponto de interrupção, prima:
- [F6] para executar a linha sem entrar nos métodos, se a linha contiver chamadas de método,
- [F5], para executar a linha entrando nos métodos, se a linha contiver chamadas de método,
- [F8] para avançar para o ponto de interrupção seguinte;
- [Ctrl-F2] para parar a depuração;
6.13. Instalação do plugin do Chrome [Advanced Rest Client]
Neste documento, utilizamos o navegador Chrome da Google (http://www.google.fr/intl/fr/chrome/browser/). Iremos adicionar-lhe a extensão [ Advanced Rest Client]. Eis como o fazer:
- Aceda à [Google Web Store] (https://chrome.google.com/webstore) utilizando o navegador Chrome;
- procure a aplicação [Advanced Rest Client]:
 |
- A aplicação fica então disponível para download:
 |
- Para o obter, terá de criar uma conta Google. A [Google Web Store] irá então solicitar uma confirmação [1]:
 |  |
- em [2], a extensão adicionada está disponível na opção [Aplicações] [3]. Esta opção aparece em cada nova guia que criar (CTRL-T) no navegador.
6.14. Gestão de j os JSON em Java
De forma transparente para o programador, a estrutura [Spring MVC] utiliza a biblioteca JSON [Jackson]. Para ilustrar o que é JSON (JavaScript Object Notation), apresentamos aqui um programa que serializa objetos em JSON e faz o inverso, deserializando as cadeias de caracteres JSON geradas para recriar os objetos originais.
A biblioteca «Jackson» permite-lhe construir:
- a cadeia JSON de um objeto: new ObjectMapper().writeValueAsString(object);
- um objeto a partir de uma string JSON: new ObjectMapper().readValue(jsonString, Object.class).
Ambos os métodos podem lançar uma IOException. Aqui está um exemplo.
 |
O projeto acima é um projeto Maven com o seguinte ficheiro [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>
- linhas 12–16: a dependência que inclui a biblioteca «Jackson»;
A classe [Person] é a seguinte:
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
...
}
A classe [Main] é a seguinte:
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);
}
}
A execução desta classe produz a seguinte saída no ecrã:
Pontos-chave do exemplo:
- o objeto [ObjectMapper] necessário para as transformações JSON/Object: linha 11;
- a transformação [Person] --> JSON: linha 17;
- a transformação de JSON para [Person]: linha 20;
- a [IOException] lançada por ambos os métodos: linha 13.
6.15. Instalação do [ WampServer]
O [WampServer] é um pacote de software para desenvolvimento em PHP / MySQL / Apache numa máquina Windows. Iremos utilizá-lo exclusivamente para o SGBD MySQL.
 |  |
- No site do [WampServer] [1], escolha a versão adequada [2],
- O executável descarregado é um instalador. Ser-lhe-ão solicitadas várias informações durante a instalação. Estas não dizem respeito ao MySQL, pelo que pode ignorá-las. A janela [3] aparece no final da instalação. Inicie o [WampServer],
 |  |
- em [4], o ícone [WampServer] aparece na barra de tarefas, no canto inferior direito do ecrã [4],
- ao clicar nele, aparece o menu [5]. Este permite-lhe gerir o servidor Apache e o SGBD MySQL. Para gerir este último, utilize a opção [PhpMyAdmin],
- que abre a janela apresentada abaixo,
Forneceremos alguns detalhes sobre a utilização do [PhpMyAdmin]. Demonstramos como utilizá-lo no documento.