6. Anexos
Apresentamos aqui como instalar as ferramentas utilizadas neste documento em computadores com Windows 7 a 10. O leitor deverá adaptar os passos ao seu próprio ambiente.
6.1. Instalação do IDE Arduino
O site oficial do Arduino é [http://www.arduino.cc/]. É aí que se encontra o IDE de desenvolvimento para os Arduinos [http://arduino.cc/en/Main/Software]:
 |  |
O ficheiro descarregado [1] é um ficheiro zip que, uma vez descompactado, resulta na estrutura de pastas [2]. É possível executar o IDE clicando duas vezes no ficheiro executável [3].
6.2. Instalação do controlador (driver) do Arduino
Para que o IDE possa comunicar com um Arduino, este último tem de ser reconhecido pelo PC anfitrião. Para tal, pode-se proceder da seguinte forma:
- ligar o Arduino a uma porta USB do computador anfitrião;
- o sistema irá então tentar encontrar o controlador do novo dispositivo USB. Não o irá encontrar. Indique então que o controlador se encontra no disco, na localização <arduino>/drivers, onde <arduino> é a pasta de instalação do Arduino IDE.
6.3. Testes do IDE
Para testar o IDE, pode-se proceder da seguinte forma:
- iniciar o IDE;
- ligar o Arduino ao PC através do cabo USB. Por enquanto, não inclua a placa de rede;
 |  |
- no [1], selecione o tipo da placa Arduino ligada à porta USB;
- em [2], indique a porta USB à qual o Arduino está ligado. Para saber qual é, desligue o Arduino e anote as portas. Volte a ligá-lo e verifique novamente as portas: a que foi adicionada é a do Arduino;
Execute alguns dos exemplos incluídos no IDE:
 |
O exemplo é carregado e apresentado:
 |
Os exemplos que acompanham o IDE são muito didáticos e muito bem comentados. Um código Arduino é escrito em linguagem C e é composto por duas partes bem distintas:
- uma função [setup] que é executada uma única vez no arranque da aplicação, quer quando esta é «carregada " do PC anfitrião para o Arduino, ou quando a aplicação já se encontra no Arduino e se carrega no botão [Reset]. É aqui que se coloca o código de inicialização da aplicação;
- uma função [loop] que se executa continuamente (laço infinito). É aqui que se coloca o núcleo da aplicação.
Aqui,
- a função [setup] configura o pino n.º 13 como saída;
- a função [loop] acende-o e apaga-o repetidamente: o LED acende-se e apaga-se a cada segundo.
1  |
O programa apresentado é transferido (carregado) para o Arduino através do botão [1]. Uma vez transferido, é executado e o LED n.º 13 começa a piscar indefinidamente.
6.4. Ligação de rede do Arduino
O Arduino ou os Arduinos e o anfitrião PC devem estar na mesma rede privada:
 |
Se houver apenas um Arduino, este pode ser ligado ao PC anfitrião através de um simples cabo RJ 45. Se houver mais do que um, o host PC e os Arduinos serão colocados na mesma rede através de um mini-hub.
Colocaremos o host PC e os Arduinos na rede privada 192.168.2.x.
- O endereço IP dos Arduinos é definido pelo código-fonte. Veremos como;
- a morada IP do computador anfitrião pode ser definida da seguinte forma:
- escolha a opção [Panneau de configuration\Réseau et Internet\Centre Réseau et partage]:
 |
- em [1], siga o link [Connexion au réseau local]
 |  |
- em [2], visualizar as propriedades da ligação;
- em [4], visualizar as propriedades IP v4 [3] da ligação;
 |
- em [5], atribuir o endereço IP [192.168.2.1] ao computador anfitrião;
- em [6], atribuir a máscara [255.255.255.0] à rede;
- confirme tudo em [7].
6.5. Teste de uma aplicação de rede
Com o IDE, carregue o exemplo [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
*/
#incluir <SPI.h>
#incluir <Ethernet.h>
// Introduza abaixo um endereço MAC e um endereço IP para o seu controlador.
// O endereço IP dependerá da sua rede local:
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1, 177);
// Inicialize a biblioteca do servidor Ethernet
// com o endereço IP e a porta que pretende utilizar
// (a porta 80 é a predefinida para HTTP):
EthernetServer server(80);
void setup() {
// Abrir as comunicações seriais e aguardar que a porta se abra:
Serial.begin(9600);
while (!Serial) {
; // aguardar a ligação da porta série. Necessário apenas para o Leonardo
}
// iniciar a ligação Ethernet e o servidor:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
}
void loop() {
// aguardar clientes que se liguem
EthernetClient client = server.available();
if (client) {
Serial.println("new client");
// um pedido HTTP termina com uma linha em branco
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// se chegou ao fim da linha (recebeu um caractere de nova linha
// ) e a linha estiver em branco, a solicitação HTTP terminou,
// pelo que pode enviar uma resposta
if (c == '\n' && currentLineIsBlank) {
// enviar um cabeçalho de resposta HTTP padrão
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>");
// adicionar uma tag meta refresh, para que o navegador atualize a página a cada 5 segundos:
client.println("<meta http-equiv=\"refresh\" content=\"5\">");
// emitir o valor de cada pino de entrada analógica
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') {
// está a iniciar uma nova linha
currentLineIsBlank = true;
}
else if (c != '\r') {
// recebeu um caractere na linha atual
currentLineIsBlank = false;
}
}
}
// dá tempo ao navegador para receber os dados
delay(1);
// fechar a ligação:
client.stop();
Serial.println("client disconnected");
}
}
Esta aplicação cria um servidor web na porta 80 (linha 30) no endereço IP da linha 25. O endereço MAC da linha 23 é o endereço MAC indicado na placa de rede do Arduino.
A função [setup] inicializa o servidor web:
- linha 34: inicializa a porta série na qual a aplicação irá registar os logs. Iremos acompanhar esses 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-se 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 null;
- 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 é verdadeiro enquanto este buffer não estiver vazio;
- linha 57: lê-se um carácter enviado pelo cliente;
- linha 58: este carácter é exibido na consola de registos;
- linha 62: no protocolo HTTP, o cliente e o servidor trocam linhas de texto.
- o cliente envia um pedido HTTP ao servidor web, enviando-lhe uma série de linhas de texto terminadas por uma linha vazia,
- o servidor responde então ao cliente, enviando-lhe uma resposta e encerrando a ligação;
Linha 62: o servidor não faz nada com os cabeçalhos HTTP que recebe do cliente. Limita-se a aguardar a linha vazia: uma linha que contém apenas o carácter \n;
- linhas 64-67: o servidor envia ao cliente as linhas de texto padrão do protocolo HTTP. Estas terminam com uma linha vazia (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 específica que solicita ao navegador do cliente que atualize 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 ao navegador do cliente os valores das 6 entradas analógicas do Arduino;
- linha 81: o documento HTML é fechado;
- linha 82: sai-se do ciclo while da linha 55;
- linha 97: a ligação com o cliente é encerrada;
- linha 98: regista-se o evento na consola de registos;
- linha 100: volta-se ao início da função loop: o servidor volta a ficar à escuta dos clientes. Dissemos que o navegador do cliente iria solicitar novamente a mesma página a cada 5 segundos. O servidor estará lá para lhe responder novamente.
Altere o código na linha 25 para inserir o endereço IP do seu Arduino, por exemplo:
Carregue o programa para o Arduino. Inicie a consola de registos (Ctrl-M) (M maiúscula):
 |  |
- em [1], a consola de registos. O servidor foi iniciado;
- em [2], utilizando um navegador, acedemos ao endereço IP do Arduino. Aqui, [192.168.2.2] é traduzido por predefinição como [http://198.162.2.2:80];
- em [3], as informações enviadas pelo servidor web. Se visualizarmos o código-fonte da página no navegador, obtemos:
Reconhecem-se aqui as linhas de texto enviadas pelo servidor. No lado do Arduino, a consola de registos apresenta o que o cliente lhe envia:
- linhas 2-9: cabeçalhos HTTP padrão;
- linha 10: a linha vazia que as encerra.
Estude bem este exemplo. Ele irá ajudá-lo a compreender a programação do Arduino utilizada no TP.
6.6. A biblioteca aJson
No TP a ser escrito, os Arduinos trocam linhas de texto no formato jSON com os seus clientes. Por predefinição, o Arduino IDE não inclui uma biblioteca para gerir o jSON. Vamos instalar a biblioteca aJson disponível no URL [https://github.com/interactive-matter/aJson].
 |  |
- no [1], descarregue a versão compactada do repositório do GitHub;
- descompacte a pasta e copie a pasta [aJson-master] [2] para a pasta [<arduino>/libraries] [3], onde <arduino> é a pasta de instalação doIDE Arduino;
 |  |  |
- em [4], renomeie esta pasta para [aJson];
- em [5], o seu conteúdo.
Agora, inicie o Arduino IDE:
 |
Verifique se, na secção de exemplos, já dispõe de exemplos para a biblioteca aJson. Execute e analise esses exemplos.
6.7. O tablet Android
Os exemplos foram testados com o tablet Samsung Galaxy Tab 2.
Para testar os exemplos com um tablet, deve primeiro instalar o controlador do mesmo no seu computador de desenvolvimento. O controlador do tablet Samsung Galaxy Tab 2 pode ser encontrado em 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 (no canto superior direito) aquela chamada [paramètres] com um ícone de roda dentada;
- na secção à esquerda, ative o Wi-Fi;
- na secção à direita, selecione uma rede Wi-Fi;
- assim que estiver ligado à rede, toque rapidamente na rede selecionada. Será apresentado o endereço IP do tablet. Anote-o. Vai precisar dele;
Ainda na aplicação [Paramètres],
- selecione à esquerda a opção [Options de développement] (na parte inferior das opções);
- Verifique se a opção [Débogage USB], à direita, está marcada.
Para voltar ao menu, toque na barra de estado na parte inferior no ícone do meio, o que representa uma casa. Ainda na barra de estado na parte inferior,
- o ícone mais à esquerda é o de voltar atrás: regressa à vista anterior;
- o ícone mais à direita é o da gestão de tarefas. Pode ver e gerir todas as tarefas executadas num determinado momento pelo seu tablet;
Ligue o seu tablet ao seu PC com o cabo USB que o acompanha.
Instale a chave Wi-Fi numa das portas USB do PC e, em seguida, ligue-se à mesma rede Wi-Fi que o tablet. Feito isto, numa janela DOS, introduza o comando [ipconfig]:
O seu PC tem duas placas de rede e, por isso, dois endereços IP:
- a da linha 9, que corresponde ao PC na rede com fios;
- a da linha 17, que é a 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. Este está normalmente protegido por uma firewall que impede qualquer elemento externo de estabelecer uma ligação com o PC. Por isso, terá de desativar a firewall. Faça-o com a opção [Panneau de configuration\Système et sécurité\Pare-feu Windows]. Por vezes, é também necessário desativar o firewall implementado pelo antivírus. Isso depende do seu antivírus.
Agora, no seu PC, verifique a ligação de rede com o tablet através do comando [ping 192.168.1.y], em que [192.168.1.y] é o endereço IP do tablet. Deve obter algo semelhante a isto:
As linhas 4 a 7 indicam que o tablet com o endereço IP [192.168.1.y] respondeu ao comando [ping].
6.8. Instalação de um JDK
Encontram-se no URL [http://www.oracle.com/technetwork/java/javase/downloads/index.html] (junho de 2016) o JDK mais recente. A partir de agora, designaremos por <jdk-install> a pasta de instalação do JDK.
 |
6.9. Instalação do gestor de emuladores Genymotion
A empresa [Genymotion] disponibiliza um emulador Android de alto desempenho. Este está disponível na versão 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, chamaremos de <genymotion-install> a pasta de instalação do [Genymotion]. Inicie o [Genymotion]. Em seguida, descarregue uma imagem para um tablet:
 |
- no [1], adicione o terminal virtual descrito no [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, surge a janela do emulador Android:
Por vezes, o emulador Android não é iniciado. 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]);
 |  |
- e, em seguida, no assistente de configuração [Centre Réseau et partage] [1]:
 |
 |  |
- no [3], selecione o(s) cartão(ões) associado(s) à máquina virtual VirtualBox;
 |
- verifique se, em [6], o controlador para VirtualBox está devidamente marcado. Repita o procedimento para todas as placas associadas à máquina virtual VirtualBox;
6.10. Instalação do Maven
O Maven é uma ferramenta de gestão de dependências de um projeto Java e muito mais. Está disponível no URL [http://maven.apache.org/download.cgi].
 |
Descarregue e descompacte o arquivo. Denominaremos <maven-install> a pasta de instalação do Maven.
 |
- No [1], o ficheiro [conf / settings.xml] configura o Maven;
Nele encontram-se 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 predefinido da linha 4, se, tal como no meu caso, o seu {user.home} tiver um espaço no seu caminho (por exemplo, [C:\Users\Serge Tahé]), pode causar problemas a alguns programas. Nesse caso, escreveremos 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, evite um caminho que contenha espaços.
6.11. Instalação do IDE Android Studio
O Android Studio Community Edition está disponível no IDE URL [https://developer.android.com/studio/index.html] (junho de 2016):
 |
Instale o IDE e, em seguida, inicie-o. Seguindo o procedimento [1-8], instale os componentes do SDK Manager utilizados nos exemplos que se seguem. Se decidir instalar componentes mais recentes, provavelmente receberá avisos do Android Studio a indicar que a configuração dos exemplos faz referência a componentes do SDK que não existem no seu ambiente. Nesse caso, poderá seguir as sugestões fornecidas pelo IDE.
 |
 |
 |
- no [9], solicite a visualização dos detalhes dos pacotes:
 |
- No [11] acima, os exemplos utilizaram o SDK Build-Tools 23.0.3;
- no [9-12] abaixo, indique a pasta onde instalou o gestor de emuladores [Genymotion];
 |  |
- no [13-18], configura-se o tipo predefinido dos projetos;
 |  |
- no [17], o valor proposto por predefinição é normalmente o correto;
- em [18], certifique-se de que tem um JDK 1.8;
Abaixo, em [19-26], desativa-se a correção ortográfica, que, por predefinição, está configurada para a língua inglesa;
 |  |
 |
- abaixo, em [27-28], escolha o tipo de atalhos de teclado que desejar. Pode manter o predefinido do IntelliJ ou escolher o de outro IDE com o qual esteja mais habituado;
 |
- abaixo, em [29-30], ative a exibição dos números de linha do código;
 |
- abaixo, em [31-34], indique como pretende gerir o primeiro projeto ao iniciar o IDE e, em seguida, os projetos seguintes;
 |
Com o Android 2.1 (maio de 2016), a tecnologia [Instant Run] apresenta, por vezes, problemas. Neste documento, desativámo-la:
 |  |
- em [3-4], tudo foi desativado;
6.12. Utilização dos exemplos
Os projetos do Android Studio dos exemplos estão disponíveis em ICI|. Descarregue-os.
 |
Os exemplos foram criados com os elementos definidos anteriormente:
- JDK 1.8;
- Plataforma Android SDK 23 para execução;
As seguintes ferramentas do SDK:
 |
Se o seu ambiente não corresponder ao anterior, terá de alterar a configuração dos projetos. Isto pode ser bastante trabalhoso. Numa primeira fase, é provavelmente mais fácil recriar um ambiente de trabalho semelhante ao acima descrito.
Inicie o Android Studio e, em seguida, abra o projeto [exemple-07], por exemplo:
 |  |
 |
- no [1-3], abre-se o projeto [Exemple-07];
- no [4], verifica-se o ficheiro [local.properties];
 |  |
- na linha 11 acima, introduza a localização do SDK Android Manager <sdk-manager-install>. Pode encontrá-la seguindo o procedimento [1-4]:
 |
Todos os exemplos deste documento são projetos Gradle configurados por um ficheiro [build.gradle] [1-2]:
 |
O ficheiro [build.gradle] do exemplo 07 é o seguinte:
buildscript {
repositories {
mavenCentral()
mavenLocal()
}
dependencies {
// substituir pela versão atual do plugin do Android
classpath 'com.android.tools.build:gradle:2.1.0'
// Desde a versão 0.11 do plugin Gradle para Android, é necessário utilizar o 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 criou, poderá ser necessário alterar as versões nas linhas 8, 21, 22, 38 e 39. O Android Studio ajuda-o, apresentando sugestões. O mais simples é seguir essas sugestões.
Os elementos do ficheiro [build.gradle] podem ser acedidos de outra forma:
 |  |
- os diferentes separadores do ficheiro [3] reproduzem os diferentes valores do ficheiro [build.gradle]. É, portanto, possível construir este ficheiro desta forma, o que permite contornar os problemas de sintaxe do ficheiro [build.gradle];
Outro ponto a verificar é o ficheiro JDK utilizado pelo IDE e pelo [5]:
 |
No [6], verifique o JDK.
Todos os exemplos são projetos Gradle com dependências a descarregar. Para o fazer, pode proceder da seguinte forma:
 |   |
- no [5], compila-se o projeto;
Assim que o projeto estiver sem erros, é necessário criar uma configuração de execução [1-8]:
 |  |
- em [8], é possível indicar que se pretende utilizar sempre o mesmo terminal para a execução. Em geral, esta opção é marcada para evitar ter de especificar o terminal a utilizar em cada nova execução. Aqui, deixamo-la desmarcada porque, precisamente, vamos testar diferentes dispositivos Android;
- assim que a configuração de execução estiver criada, iniciamos o gestor de emuladores Android [1-3];
 |  |
- se o emulador Android não iniciar, verifique os pontos mencionados no parágrafo 6.11;
Para iniciar a aplicação no emulador, proceda da seguinte forma [1-4]:
 |  |
- em [2], deverá ver aparecer o emulador que iniciou anteriormente;
 |
- em [5], a imagem apresentada pelo emulador;
Ligue agora um tablet Android a uma porta USB do PC e execute a aplicação nesse tablet:
 |
- No [6], selecione o tablet Android e teste a aplicação.
No [7], temos terminais virtuais predefinidos. Vamos aprender a adicionar e a eliminar terminais.
 |
 |
Na captura de ecrã acima, os terminais apresentados funcionam todos com o API 22. Vamos eliminá-los todos, pois queremos trabalhar com o API 23. Seguimos o procedimento [2-3] para os terminais a eliminar.
 |
- no [4-5], adicionamos um tablet;
 |
- no [6], seleciona-se um API. Acima, selecionamos o API 23 para um Windows de 64 bits;
 |
- em [7], o resumo da configuração efetuada;
- em [8], é possível efetuar uma configuração mais avançada do terminal virtual;
 |
Assim que o assistente terminar, o terminal criado aparece em [9].
Feito isto, se reiniciarmos a execução de [Exemple-07], obtemos agora a seguinte janela:
 |
- em [1], surge o novo terminal virtual;
- no [2], é possível criar novos terminais;
Faça alguns testes para determinar o terminal virtual mais adequado ao seu computador. 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]:
Consulte regularmente estes registos. É aí que serão indicadas as exceções que provocaram a falha do seu programa.
Também pode depurar o seu programa com as ferramentas habituais de depuração:
 |  |
- no [2], coloca-se um ponto de paragem clicando uma vez na coluna à esquerda da linha em questão. Um novo clique anula o ponto de paragem;
 |
- em [3], no ponto de paragem, execute:
- [F6], para executar a linha sem entrar nos métodos, caso a linha contenha chamadas de métodos,
- [F5], para executar a linha entrando nos métodos, caso a linha contenha chamadas de métodos,
- [F8], para continuar até ao próximo ponto de paragem;
- [Ctrl-F2] para interromper a depuração;
6.13. Instalação da extensão do Chrome [Advanced Rest Client]
Neste documento, utiliza-se o navegador Chrome da Google (http://www.google.fr/intl/fr/chrome/browser/). Iremos adicionar-lhe a extensão [Advanced Rest Client] . Pode proceder da seguinte forma:
- aceder ao site do [Google Web store] (https://chrome.google.com/webstore) com o navegador Chrome;
- procure a aplicação [Advanced Rest Client]:
 |
- a aplicação fica então disponível para download:
 |
- Para a obter, terá de criar uma conta Google. A aplicação [Google Web Store] solicita, em seguida, a confirmação [1]:
 |  |
- Em [2], a extensão adicionada está disponível na opção [Applications] [3]. Esta opção é apresentada em cada novo separador que criar (CTRL-T) no navegador.
6.14. Gestão do jSON em Java
De forma transparente para o programador, o framework [Spring MVC] utiliza a biblioteca jSON [Jackson]. Para ilustrar o que é o jSON (JavaScript Object Notation), apresentamos aqui um programa que serializa objetos em jSON e faz o inverso, deserializando as cadeias jSON produzidas para recriar os objetos iniciais.
A biblioteca «Jackson» permite construir:
- a cadeia jSON de um objeto: new ObjectMapper().writeValueAsString(object);
- um objeto a partir de uma cadeia jSON: new ObjectMapper().readValue(jsonString, Object.class).
Ambos os métodos podem lançar um IOException. Eis 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 [Personne] é a seguinte:
package istia.st.json;
public class Personne {
// dados
private String nom;
private String prenom;
private int age;
// construtores
public Personne() {
}
public Personne(String nom, String prénom, int âge) {
this.nom = nom;
this.prenom = prénom;
this.age = âge;
}
// assinatura
public String toString() {
return String.format("Personne[%s, %s, %d]", nom, prenom, age);
}
// getters e 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 {
// a ferramenta de serialização/deserialização
static ObjectMapper mapper = new ObjectMapper();
public static void main(String[] args) throws IOException {
// criação de uma pessoa
Personne paul = new Personne("Denis", "Paul", 40);
// exibição de JSON
String json = mapper.writeValueAsString(paul);
System.out.println("Json=" + json);
// instanciação de Pessoa a partir do JSON
Personne p = mapper.readValue(json, Personne.class);
// exibição de uma pessoa
System.out.println("Personne=" + p);
// uma tabela
Personne virginie = new Personne("Radot", "Virginie", 20);
Personne[] personnes = new Personne[]{paul, virginie};
// exibição de JSON
json = mapper.writeValueAsString(personnes);
System.out.println("Json personnes=" + json);
// dicionário
Map<String, Personne> hpersonnes = new HashMap<String, Personne>();
hpersonnes.put("1", paul);
hpersonnes.put("2", virginie);
// exibição de JSON
json = mapper.writeValueAsString(hpersonnes);
System.out.println("Json hpersonnes=" + json);
}
}
A execução desta classe produz a seguinte saída no ecrã:
Do exemplo, destaca-se o seguinte:
- o objeto [ObjectMapper] necessário para as transformações jSON / Objeto: linha 11;
- a transformação [Personne] --> jSON: linha 17;
- a transformação jSON --> [Personne]: linha 20;
- a exceção [IOException] lançada pelos dois métodos: linha 13.
6.15. Instalação do [WampServer]
O [WampServer] é um conjunto de software para desenvolver em PHP / MySQL / Apache numa máquina Windows. Iremos utilizá-lo exclusivamente para o SGBD e o MySQL.
 |  |
- no site do [WampServer] [1], escolha a versão adequada [2],
- o ficheiro executável descarregado é um programa de instalação. São solicitadas várias informações durante a instalação. Estas não dizem respeito ao MySQL. Por isso, podem ser ignoradas. A janela [3] é apresentada no final da instalação. Inicie o [WampServer],
 |  |
- no [4], o ícone do [WampServer] é instalado na barra de tarefas, na parte inferior direita do ecrã [4],
- ao clicar nele, é apresentado o menu [5]. Este permite gerir o servidor Apache e o SGBD MySQL. Para gerir este último, utiliza-se a opção [PhpPmyAdmin],
- aparece então a janela abaixo,
Não entraremos em muitos detalhes sobre a utilização do [PhpMyAdmin]. No documento, mostramos como utilizá-lo.