1. Introdução

1.1. Contexte

O PDF do documento pode ser encontrado |AQUI|.

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

Este documento é ao mesmo tempo um curso e um TD (Trabalho Dirigido) universitário. Ele é destinado a iniciantes. Utiliza as seguintes fontes:

Referências:

1. Introdução à linguagem Java (1998);

2. Utilização de um banco de dados relacional com o ecossistema Spring (2015);

Denotaremos essas referências, respectivamente, como [ref1] e [ref2]. A fonte [ref1] é antiga (2002), mas suficiente para este documento, no qual é utilizada apenas para a apresentação da sintaxe da linguagem Java e de suas operações básicas. O restante necessário para a elaboração do TD é apresentado neste documento em capítulos intitulados [Cours]. Esses capítulos provêm diretamente do [ref2] (2015) e, em alguns casos, foram simplificados.

O objetivo do documento é ensinar a linguagem Java sob uma perspectiva profissional. Por esse motivo, nos baseamos fortemente no framework Spring [http://spring.io/], amplamente utilizado no desenvolvimento JEE (Java Enterprise Edition). Logicamente, este curso deve ser seguido por um curso JEE. É o que ocorre na Istia (Universidade de Angers). O JEE é a principal fonte de empregos atualmente (novembro de 2015) para jovens desenvolvedores com nível de graduação de 5 anos. Existem muitas outras tecnologias além do Spring no mundo do JEE. O Spring tem a vantagem de ser compreensível e, sobretudo, de oferecer boas práticas de codificação reutilizáveis fora do ecossistema do Spring. É isso que explica sua escolha aqui.

Este TD é utilizado há mais de 10 anos e evoluiu junto com as tecnologias. Ele é seguido (pelo IstiA) por um TD, JEE e [Introduction à Java EE]. Este último, o TD, data de 2012 (estamos em 2015) e mereceria ser atualizado. Ele apresenta a ortodoxia JEE por meio do framework web JSF2 (Java Server Faces) e dos EJB3 (Enterprise Java Bean). Juntos, esses dois TD permitiram que muitos estudantes conseguissem estágios JEE em ESN (empresas de serviços digitais) e fossem contratados por essas empresas logo em seguida.

Não se encontrará neste documento uma apresentação formal de todas as facetas do Java. Ao longo dos anos, o comportamento dos desenvolvedores juniores diante de um problema evoluiu bastante. Atualmente, eles utilizam quase que sistematicamente a Internet para encontrar trechos de código que, quando combinados, formam um programa. Se lhes for oferecido um curso, eles o utilizam muito pouco e preferem, mais uma vez, recorrer à Internet. Inicialmente cético em relação a essa forma de trabalhar, fiquei, no entanto, surpreso com os resultados obtidos. Assim, alunos com dificuldades conseguiam produzir programas que funcionavam, enquanto que, sem a ajuda da Internet, provavelmente não teriam conseguido. Agora, baseio-me nessa forma de trabalhar.

Trechos de código não oferecem uma visão geral da arquitetura de uma solução, e um dos objetivos deste documento é justamente fornecer essa visão. Os alunos realizam o TD da mesma forma que o TP, de forma autônoma. Não há aula expositiva. Há um cronograma que indica o andamento esperado ao longo das sessões. Eles podem estar atrasados ou adiantados em relação a esse cronograma. Seu progresso é verificado por meio de uma série de validações que devem apresentar ao professor. Este está presente tanto para fornecer explicações quando solicitadas quanto para validar o trabalho dos alunos. Cada um segue seu próprio ritmo. Ao final das 36 horas destinadas a este TD, alguns terão feito 50% mais validações do que outros, mas todos — pelo menos esse é o objetivo — terão compreendido o que realizaram de forma autônoma. Este TD pode ser realizado sem o acompanhamento de um professor. É por isso que está disponível no [https://stahe.github.io].

Este documento não é adequado para quem procura um curso acadêmico sobre Java, algo em que o Java seja explicado de forma progressiva e estruturada e em que cada detalhe da sintaxe seja explicado e justificado. Trata-se, na verdade, de uma abordagem experimental proposta aqui. É provável que o aluno não compreenda tudo o que é apresentado no documento, mas provavelmente saberá reutilizar seu conteúdo de maneira adequada, e a compreensão dos detalhes virá com a experiência.

Este documento também não é um curso de algoritmos. O algoritmo do TD é básico e pode ser resolvido por qualquer iniciante que esteja cursando suas primeiras aulas de algoritmos. O documento está focado no ambiente de desenvolvimento profissional em Java, com suas inúmeras bibliotecas e frameworks, e na arquitetura do código. A maioria dos alunos que vejo passar apresenta deficiências em algoritmos, o que é posteriormente confirmado pelos orientadores de estágio. Portanto, sim, o domínio dos algoritmos é importante, mas não é o objetivo deste curso-TD.

Por fim, este documento (dezembro de 2015) não apresenta as últimas novidades do Java, especialmente os streams e as funções lambda. No entanto, utilizamos alguns elementos da versão mais recente do JDK, o JDK 1.8, e os códigos a seguir devem ser compilados por esse JDK.

1.2. Contenu

O capítulo 2 apresenta o tema do TD, um cálculo de resultados eleitorais. O problema é básico. O capítulo 2 solicita a implementação da solução em duas linguagens, C# e Java, que são muito semelhantes. A implementação é feita sem classes. O objetivo é apresentar a sintaxe do Java, suas instruções básicas e o IDE (Ambiente de Desenvolvimento Integrado) Eclipse, que serve para construir projetos em Java.

O capítulo 3 pede que se implemente a solução do TD em Java com classes. O objetivo é apresentar os conceitos de classes, herança, interfaces e classes genéricas. É introduzido o conceito de teste unitário JUnit.

O capítulo 4 apresenta os conceitos que servem de base para os capítulos seguintes:

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

O capítulo 5 apresenta o framework Spring por meio de quatro projetos.

O capítulo 6 apresenta o API JDBC, que é uma interface de acesso a bancos de dados.

O capítulo 7 implementa a camada [DAO] (Data Access Object) do TD com o API JDBC e o Spring.

O capítulo 8 implementa a camada [métier] do TD:

O capítulo 9 implementa a camada [ui] do TD com um aplicativo de console:

O capítulo 10 implementa a camada [ui] do TD com um aplicativo gráfico que utiliza a biblioteca de componentes Swing:

O capítulo 11 apresenta o gerenciamento de bancos de dados com o framework [Spring Data], um ramo do ecossistema Spring. Ele apresenta a especificação JPA (Java Persistence API), que permite que a camada [DAO] manipule objetos em vez de manipular SQL (Structured Query Language). A arquitetura em camadas evolui da seguinte forma:

O capítulo 12 aplica o capítulo 11 ao implementar o acesso ao banco de dados do TD com o [Spring Data].

O capítulo 13 mostra como disponibilizar um banco de dados na web com o [Spring MVC], que é outro ramo do ecossistema Spring. A arquitetura evolui para uma arquitetura cliente/servidor:

Os capítulos 14 e 15 transformam a aplicação do TD em uma aplicação cliente/servidor:

O capítulo 16 mostra como proteger o acesso a um aplicativo web com o [Spring Security], outro ramo do ecossistema Spring.

O capítulo 17 retoma o TD e protege o serviço web das eleições.

O capítulo 18 aborda o problema das solicitações entre domínios:

• em [1], um aplicativo web fornece páginas HTML com 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 as solicitações de [3] para [4] são chamadas de solicitações entre domínios. Devido às restrições de segurança implementadas pelos navegadores, sua configuração pode ser problemática. Analisaremos uma solução.

O capítulo 19 implementa as solicitações entre domínios no contexto de um aplicativo de eleições.

1.3. As ferramentas utilizadas

Os exemplos a seguir foram testados no seguinte ambiente:

• computador com Windows 10 Pro de 64 bits;
• JDK 1.8 (parágrafo 22.1);
• IDE Spring Tool Suite 3.6.3 (parágrafo 1);
• NetBeans 8.1 (parágrafo 22.4);
• navegador Chrome (outros navegadores não foram utilizados);
• extensão do Chrome [Advanced Rest Client] (parágrafo 1);
• WampServer, que inclui o SGBD, o MySQL e a ferramenta [PhpMyAdmin] para gerenciá-lo (parágrafo 22.7);

É importante utilizar o JDK 1.8. Alguns exemplos utilizam elementos desse JDK. A maioria dos exemplos são projetos Maven que podem ser abertos tanto pelo IDE Eclipse quanto pelo [https://www.eclipse.org/], IntellijIDEA Community Edition, [https://www.jetbrains.com/idea/download/] e NetBeans [https://netbeans.org/]. A seguir, as capturas de tela são da IDE Spring Tool Suite, uma variante do Eclipse.

1.4. Suporte

Os projetos Eclipse deste documento estão disponíveis no site [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 é do tipo Maven. Se, após o carregamento, eles apresentarem erros, execute o [Alt-F5] e siga o procedimento descrito no [9-10]. Os projetos Maven selecionados serão recompilados.