1. Introdução

1.1. Contexto

O PDF do documento pode ser encontrado |AQUI|.

Os exemplos do documento estão disponíveis |AQUI|.

Este documento serve tanto como aula como tutorial universitário (TD). Destina-se a principiantes. Utiliza as seguintes fontes:

Referências:

Referir-nos-emos a estas fontes como [ref1] e [ref2], respetivamente. A fonte [ref1] está desatualizada (2002), mas é suficiente para este documento, onde é utilizada apenas para a apresentação da sintaxe da linguagem Java e das operações básicas. O restante do material necessário para concluir a tarefa é apresentado neste documento nos capítulos intitulados [Curso]. Estes capítulos foram retirados diretamente de [ref2] (2015) e foram simplificados em alguns casos.

O objetivo deste documento é ensinar a linguagem Java de uma perspetiva profissional. Por esta razão, baseamo-nos fortemente no framework Spring [http://spring.io/], que é amplamente utilizado no desenvolvimento JEE (Java Enterprise Edition). Logicamente, este curso deve ser seguido por um curso de JEE. É o que acontece na Istia (Universidade de Angers). O JEE é atualmente (novembro de 2015) a principal fonte de emprego para jovens programadores com mestrado. Existem muitas outras tecnologias além do Spring no mundo JEE. O Spring tem a vantagem de ser fácil de compreender e, acima de tudo, de fornecer melhores práticas de codificação que podem ser reutilizadas fora do ecossistema Spring. Isto explica porque foi escolhido aqui.

Este laboratório está em uso há mais de 10 anos e tem evoluído com as tecnologias. É seguido (na IstiA) por um laboratório de JEE [Introdução ao Java EE]. Este último laboratório data de 2012 (estamos agora em 2015) e precisa de uma atualização. Apresenta o padrão JEE através do framework web JSF2 (Java Server Faces) e do EJB3 (Enterprise Java Bean). Em conjunto, estes dois tutoriais permitiram a muitos estudantes garantir estágios em JEE em empresas de serviços digitais (ESN) e serem contratados nessas empresas imediatamente a seguir.

Não encontrará neste documento uma apresentação formal de todos os aspetos do Java. Ao longo dos anos, a forma como os programadores juniores abordam um problema mudou significativamente. Hoje em dia, recorrem quase sempre à Internet para encontrar trechos de código que, quando reunidos, formam um programa. Se lhes oferecemos um curso, utilizam-no muito pouco e preferem voltar à Internet. Embora inicialmente estivesse cético em relação a esta abordagem, fiquei, no entanto, surpreendido com os resultados. Os alunos com mais dificuldades conseguiram produzir programas funcionais, enquanto que, sem a ajuda da Internet, provavelmente não teriam conseguido. Agora confio nesta abordagem.

Os trechos de código não oferecem uma visão geral da arquitetura de uma solução, e um dos objetivos deste documento é proporcionar essa visão geral. Os alunos realizam este tutorial como um exercício prático, trabalhando de forma independente. Não há aula expositiva. Existe um cronograma que descreve o progresso esperado ao longo das sessões. Eles podem estar atrasados ou adiantados em relação a esse cronograma. O seu progresso é verificado através de uma série de pontos de verificação que devem apresentar ao instrutor. O instrutor está presente tanto para fornecer explicações quando solicitado como para validar o seu trabalho. Todos trabalham ao seu próprio ritmo. No final das 36 horas atribuídas a este laboratório, alguns terão concluído 50% mais validações do que outros, mas todos — pelo menos esse é o objetivo — terão compreendido o que fizeram por conta própria. Este laboratório pode ser concluído sem a orientação de um professor. É por isso que está disponível em [https://stahe.github.io].

Este documento não é adequado para quem procura um curso académico sobre Java — algo que explique Java de forma passo a passo e estruturada, onde cada detalhe da sintaxe é explicado e justificado. Em vez disso, o que aqui se propõe é uma abordagem experimental. É provável que o aluno não compreenda tudo o que é apresentado no documento, mas provavelmente será capaz de dar bom uso ao seu conteúdo, e a compreensão dos detalhes virá com a experiência.

Este documento também não é um curso sobre algoritmos. O algoritmo do exercício é básico e pode ser resolvido por qualquer principiante a frequentar os seus primeiros cursos de algoritmos. O documento centra-se no ambiente profissional de desenvolvimento Java, com as suas inúmeras bibliotecas e frameworks, bem como na arquitetura do código. A maioria dos alunos que vejo tem lacunas em algoritmos, o que é posteriormente confirmado pelos seus orientadores de estágio. Portanto, sim, o domínio dos algoritmos é importante, mas não é o foco deste tutorial.

Por fim, este documento (dezembro de 2015) não abrange as funcionalidades mais recentes do Java, nomeadamente streams e funções lambda. No entanto, utiliza alguns elementos do JDK mais recente, o JDK 1.8, e o código que se segue deve ser compilado utilizando este JDK.

1.2. Índice

O Capítulo 2 apresenta o tema do tutorial: o cálculo de resultados eleitorais. O problema é simples. O Capítulo 2 pede-lhe que implemente a solução utilizando duas linguagens muito semelhantes, C# e Java. A implementação é feita sem classes. O objetivo é apresentar a sintaxe Java, as suas instruções básicas e o IDE (Ambiente de Desenvolvimento Integrado) Eclipse utilizado para construir projetos Java.

O Capítulo 3 pede-lhe que implemente a solução da tarefa em Java utilizando classes. O objetivo é apresentar os conceitos de classes, herança, interfaces e classes genéricas. É apresentado o conceito de testes unitários JUnit.

O Capítulo 4 apresenta os conceitos subjacentes aos capítulos seguintes:

arquiteturas em camadas;
programação por interfaces;
a utilização do Spring para implementar os dois conceitos anteriores;

O Capítulo 5 apresenta o framework Spring através de quatro projetos.

O Capítulo 6 apresenta a API JDBC, que é uma interface de acesso a bases de dados.

O Capítulo 7 implementa a camada [DAO] (Data Access Object) do projeto do curso utilizando a API JDBC e o Spring.

O Capítulo 8 implementa a camada [de negócios] do projeto do curso:

O Capítulo 9 implementa a camada [UI] do TD utilizando uma aplicação de consola:

O Capítulo 10 implementa a camada [UI] do tutorial utilizando uma aplicação gráfica que aproveita a biblioteca de componentes Swing:

O Capítulo 11 aborda a gestão de bases de dados utilizando o framework [Spring Data], um componente do ecossistema Spring. Apresenta a especificação JPA (Java Persistence API), que permite à camada [DAO] manipular objetos em vez de SQL (Structured Query Language). A arquitetura em camadas evolui da seguinte forma:

O Capítulo 12 aplica os conceitos do Capítulo 11, implementando o acesso à base de dados para o tutorial utilizando o [Spring Data].

O Capítulo 13 mostra como expor uma base de dados na Web utilizando o [Spring MVC], outro ramo do ecossistema Spring. A arquitetura evolui para uma arquitetura cliente/servidor:

Os capítulos 14 e 15 transformam a aplicação tutorial numa aplicação cliente/servidor:

O Capítulo 16 mostra como proteger o acesso a uma aplicação web utilizando o [Spring Security], outro ramo do ecossistema Spring.

O Capítulo 17 retoma o tutorial e protege o serviço web eleitoral.

O Capítulo 18 aborda a questão dos pedidos entre domínios:

Em [1], uma aplicação web fornece páginas HTML/JavaScript;
em [2], o navegador executa o JavaScript incorporado nas páginas HTML para consultar o serviço web seguro [3-4];

Seja D1 = http://machine1:port1 o domínio do servidor [1] e D4 = http://machine4:port4 o domínio do servidor [4]. Se os servidores [1] e [4] não estiverem no mesmo domínio [D1≠D4], então os pedidos de [3] para [4] são denominados pedidos entre domínios. Devido às restrições de segurança implementadas pelos navegadores, a sua configuração pode ser problemática. Iremos examinar uma solução.

O Capítulo 19 implementa pedidos entre domínios utilizando a aplicação de eleições.

1.3. Ferramentas utilizadas

Os exemplos a seguir foram testados no seguinte ambiente:

Equipamento com Windows 10 Pro de 64 bits;
JDK 1.8 (Secção 22.1);
Spring Tool Suite 3.6.3 IDE (Secção 1);
NetBeans 8.1 (secção 22.4);
Navegador Chrome (não foram utilizados outros navegadores);
Extensão do Chrome [Advanced Rest Client] (secção 1);
WampServer, que inclui o SGBD MySQL e a ferramenta [PhpMyAdmin] para o gerir (secção 22.7);

É importante utilizar o JDK 1.8. Alguns exemplos utilizam componentes deste JDK. A maioria dos exemplos são projetos Maven que podem ser abertos utilizando qualquer um dos seguintes IDEs: Eclipse [https://www.eclipse.org/], IntelliJ IDEA Community Edition [https://www.jetbrains.com/idea/download/] e NetBeans [https://netbeans.org/]. A seguir, as capturas de ecrã são do Spring Tool Suite IDE, uma variante do Eclipse.

1.4. Suporte

Os projetos Eclipse neste documento estão disponíveis em [https://tahe.developpez.com/tutoriels-cours/intro-java-spring/serge-tahe-introduction-au-langage-java-et-a-l-ecosysteme-spring/].

Para importar os projetos de um capítulo, proceda no Eclipse conforme indicado em [1-8]:

A maioria dos projetos são projetos Maven. Se ocorrerem erros após o carregamento, prima [Alt-F5] e siga o procedimento descrito em [9-10]. Os projetos Maven selecionados serão recompilados.