Programacao Cliente Servidor PDF

PROGRAMAÇÃO SERVIDOR
EM SISTEMAS WEB
autor
JOÃO PAULO CASATI
1ª edição
SESES
rio de janeiro 2016
Conselho editorial regiane burger, roberto paes e paola gil de almeida
Autor do original joão paulo casati
Projeto editorial roberto paes
Coordenação de produção paola gil de almeida, paula r. de a. machado e aline

karina rabello
Projeto gráfico paulo vitor bastos
Diagramação bfs media
Revisão linguística bfs media
Revisão de conteúdo eduardo luiz pareto
Imagem de capa timofeev vladimir | shutterstock.com
Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida
por quaisquer meios (eletrônico ou mecânico, incluindo fotocópia e gravação) ou arquivada em
qualquer sistema ou banco de dados sem permissão escrita da Editora. Copyright seses, 2016.
Dados Internacionais de Catalogação na Publicação (cip)
C334p Casati, João Paulo

Programação servidor em sistemas web /João Paulo Casati.
Rio de Janeiro: SESES, 2016.
120 p: il.
isbn: 978-85-5548-334-9
1.Sites na web. 2. Sites da web - desenvolvimento. 3. Sites da web –

programação. I. SESES. II. Estácio.
cdd 005
Diretoria de Ensino — Fábrica de Conhecimento

Rua do Bispo, 83, bloco F, Campus João Uchôa
Rio Comprido — Rio de Janeiro — rj — cep 20261-063
Sumário
Prefácio 5
1. A Criação de Aplicativos para WEB 7

1.1 A sintaxe da linguagem Java 9
1.2 O ambiente servidor 17
1.3 IDEs para desenvolvimento web 18
1.4 Desenvolvimento web com NetBeans 20
2. Tecnologias de Sistemas e Bancos de Dados 27
2.1 Servlets Java 28

2.2 JavaServer Pages (JSP) 32
2.3 Recebendo parâmetros 34
2.4 A API JDBC 37
2.5 Gerenciando JavaDB com NetBeans 38
3. Sessões e o Modelo MVC 51
3.1 Gerenciamento de sessão e login 52

3.2 O modelo MVC 57
3.3 Aplicação com MVC 59
4. Modelagem Comportamental e JPA 71
4.1 Tipos genéricos 72

4.2 Anotações em Java 74
4.3 Java Enterprise Edition (JEE) 75
4.4 Object-Relational Mapping (ORM) 76
4.5 Java Persistence API (JPA) 78
4.6 JPA na prática 83
5. Objetos Distribuídos, MDB e Web Services 93
5.1 Objetos distribuídos e sistemas corporativos 94

5.2 Comportamento assíncrono com MDB 96
5.3 XML, Web Services e SOAP 98
5.4 Criação de web services anotados 99
5.5 Consumindo Web Service Java 105
Prefácio
Prezados(as) alunos(as),
Sejam bem-vindos a esta disciplina. A programação das rotinas que são exe-
cutadas do lado servidor em um sistema web é uma tarefa que exige conheci-
mento de diversas tecnologias e métodos de programação, assim como conhe-
cimento de arquiteturas de desenvolvimento, interação com bancos de dados e
engenharia de software. Nesta disciplina serão abordadas as tecnologias neces-
sárias para se desenvolver a base dos sistemas web, a aplicação do lado servidor.
As rotinas mais importantes e vitais de um sistema devem seguir uma ar-
quitetura de desenvolvimento que garanta manutenibilidade, organização, de-
sempenho e produtividade e aliado às tecnologias, o padrão de arquitetura de
desenvolvimento web mais aceito e utilizado também é apresentado neste livro.
A grande maioria das tecnologias, linguagens e padrões apresentados aqui
são baseados na linguagem de programação Java, a mais popular entre os de-
senvolvedores de sistemas de informação complexos para web. Juntamente
com a linguagem e os padrões e tecnologias adotados para o desenvolvimen-
to web, boas práticas e inovações são também abordadas no decorrer do livro,
trazendo a aquisição de um conhecimento essencial, aprofundado e atualiza-
do para que você, aluno, possa ter uma experiência de aprendizado completa
quanto ao desenvolvimento de sistemas para a plataforma web.
Como objetivos a serem alcançados por esta disciplina, pode-se citar o
aprendizado de tecnologias importantes para o desenvolvedor, assim como
uma visão prática da programação, permitindo a você aluno iniciar no desen-
volvimento de sistemas para a web.
Bons estudos!
5
1
A Criação de
Aplicativos para
WEB
1. A criação de aplicativos para web
Neste primeiro capítulo são abordados os temas iniciais necessários para que
se possa progredir nesta disciplina de programação para o lado servidor dos
sistemas web.
Pela base tecnológica abordada neste livro ser a linguagem Java, este capí-
tulo inicia com uma revisão de sua sintaxe (criação de classes, manipulação de
objetos, estruturas, palavras reservadas etc.). Esta revisão é importante, pois o
conhecimento acerca da linguagem é utilizado no decorrer do livro.
Uma visão geral do ambiente servidor no qual a aplicação será pro-
cessada também é apresentado, assim como uma parte muito impor-
tante para a prática do desenvolvimento de software: as IDEs (Integrated
Development Environment, que em português significa Ambiente de
Desenvolvimento Integrado).
Uma visão mais prática e detalhada é feita na IDE NetBeans, a qual é utili-
zada no decorrer deste livro para apresentação de exemplos e estudos de caso.
Inicia-se agora uma busca por um conhecimento fascinante!
Bons estudos!
OBJETIVOS
Este capítulo trará ao aluno os conhecimentos necessários para adentrar no mundo da pro-
gramação do lado servidor em sistemas web baseados na tecnologia Java, muito difundida
no mercado.
Ao final deste primeiro capítulo, o aluno:
• Estará apto a programar na linguagem Java;
• Conhecerá o ambiente do servidor e os principais softwares utilizados;
• Saberá do que se tratam e como as IDEs podem auxiliar no desenvolvimento de software,
inclusive para a web;
• Conhecerá a IDE NetBeans, uma das mais utilizadas e poderosas do mercado; e
• Aprenderá a iniciar projetos de sistemas web utilizando o NetBeans.
8• capítulo 1
1.1 A sintaxe da linguagem Java
Programar em Java para desenvolver sistemas de informação não é uma ta-

refa trivial, é necessário conhecimento em orientação a objetos e também da
sintaxe da linguagem, que possui muitos recursos.
Outra dificuldade de se desenvolver softwares em Java é que esta linguagem
está em constante aperfeiçoamento, portanto, é necessário que se mantenha
sempre atualizado para que se possa usufruir de todos os recursos que vêm sen-
do empregados à linguagem.
A execução de código Java se dá por meio de uma máquina virtual, a JVM
(Java Virtual Machine). Existem várias máquinas virtuais que interpretam códi-
go Java, mas a JVM adotada como padrão é provida pela Oracle.
Um dos grandes motivos pelo qual a linguagem Java se popularizou é sua
independência de plataforma. Por ser interpretada por uma máquina virtual,
o Java pode ser executado em diversos sistemas operacionais, desde que este
tenha uma implementação da máquina virtual.
Os arquivos de código fonte em Java possuem a extensão. java. Para sua exe-
cução, estes são compilados para bytecodes (codificação intermediária entre a
linguagem de máquina e o código-fonte, ilegíveis por seres humanos). A JVM
interpreta os bytecodes gerados e executa as instruções. Este procedimento tor-
na o Java uma espécie de linguagem compilada e interpretada (CAELUM, 2016).
A criação de classes, objetos, manipulação de dados, tipos de variáveis, mé-
todos, entre outros termos relativos à sintaxe da linguagem são apresentados
aqui em forma de exemplo, mas antes, algumas considerações sobre as estru-
turas de repetição, condicionais, comparações e tipos de dados.
Os tipos de dados adotados pelo Java podem ser primitivos, que são alo-
cados estaticamente em memória ou abstratos, alocados dinamicamente
(ASCENCIO; ARAÚJO, 2010). Os tipos primitivos do Java são apresentados na
tabela 1.1.
TIPO BITS VALORES

boolean 1 true ou false
byte 8 -128 a +128
char 16 ‘\u0000’ a ‘\uFFFF’
short 16 -32768 a +32767
-2147483648 a
int 32
+2147483647
capítulo 1 •9
TIPO BITS VALORES
-9223372036854775808
long 64 a
+9223372036854775807
float 32 10-38 a 10+38
double 64 10-308 a 10+308
Tabela 1.1 – Tipos primitivos do Java seguidos do número de bits que ocupam em memória
e os valores que podem ser assumidos por cada tipo.
Os tipos abstratos, em Java, são definidos por classes. Algumas classes são
nativas da linguagem e muito utilizadas, como:
• Integer: números inteiros;
• Double: números reais;
• String: Cadeias de caracteres (texto);
• Entre muitas outras.
Há uma recomendação para a utilização de tipos abstratos em programação

de sistemas de informação, pois estes dão margem a um melhor gerenciamen-
to da memória utilizada pelo programa. Outra vantagem dos tipos abstratos é
que estes possuem métodos para manipulação dos dados, que auxiliam o pro-
gramador e aumentam a produtividade.
Antes de adentrar em exemplos com código, é importante saber:
• O método System.out.println imprime valores na saída do sistema, ge-
ralmente utilizado para exibir dados ao usuário quando a programação é feita
em terminal;
• Existem dois modos de adicionar comentários nos códigos em Java, o pri-
meiro é utilizando duas barras (//) antes de uma frase, este modo marca como
comentário apenas a própria linha. Outro modo é marcar o início (/*) e o fim (*/)
do comentário que pode ocupar várias linhas.
• As variáveis do Java são fortemente tipadas, isto significa que uma variável
deve ter seu tipo definido ao ser declarada;
• Um programa em Java é uma classe e sua execução inicia-se do método
main (que significa “principal” em português).
• Os operadores de incremento e decremento em Java são muito utilizados
(++ para incremento e -- para decremento). Quando utilizados antes da variável,
a operação ocorre antes de seu uso em expressões matemáticas, quando utiliza-
do depois da variável, a expressão matemática é efetuada antes da operação de
incremento/decremento (vide listagem 1.1);
10 • capítulo 1
Um exemplo do uso de variáveis primitivas em Java é dado na listagem 1.1,
que possui o código-fonte e a saída de sua execução logo abaixo.
public static void main (String[] args) {

int i = 5;
int j = 7;
System.out.println(i * j);
i++;
System.out.println(i * j);
double k = (i * (j - 1) / ++j);
System.out.println(k);
System.out.println(i + j);
}
SAÍDA:
35
42
4.0
14
Listagem 1.1 – Uso de variáveis primitivas em Java.
A primeira tarefa para a criação de programas em Java é a criação de uma

classe. A figura 1.1 exibe a modelagem de uma classe utilizando a linguagem
UML (BOOCH; RUMBAUGH; JACOBSON, 2005). Pode-se observar três divisões
na modelagem da classe:
• A primeira indica o nome da classe;
• A segunda indica os atributos da classe;
• A terceira indica os métodos da classe.
Figura 1.1 – Classe Java representada pela UML.
capítulo 1 • 11
O código-fonte referente a criação da classe apresentada na figura 1.1, de
forma simples, é exibido na listagem 1.2.
public class Pessoa {
String nome;
int idade;
String documento;
void andar(int metros) {

// Faz a pessoa andar
}
void andar(String frase) {

// Faz a pessoa falar
}
Listagem 1.2 – Código de uma classe em Java.
Os operadores lógicos são utilizados para a comparação entre variáveis e/ou

valores. Se esta comparação for verdadeira, então retorna o valor booleano true,
se for falsa, retorna false. Este retorno é usado em diversos momentos, veremos
alguns mais à frente (DEITEL; DEITEL, 2010).
Os operadores lógicos mais utilizados em Java são apresentados na
tabela 1.2. Operadores comparativos também são apresentados, juntamente
com dois métodos da classe String que servem para a comparação entre textos
(SIERRA; BATES, 2010).
ESTRUTURA DESCRIÇÃO
Igual: retorna verdadeiro (true) se os dois lados da comparação
==
forem iguais.
Diferente: retorna true se os dois lados da comparação forem
!=
diferentes.
! Negação: Altera o estado de true para false e vice-versa.
Maior: retorna true se o lado esquerdo da comparação for maior
>
que o direito.
12 • capítulo 1
Maior ou igual: retorna true se o lado esquerdo da comparação
>=
for maior ou igual ao direito.
Menor: retorna true se o lado esquerdo da comparação for
<
menor que o direito.
Menor ou igual: retorna true se o lado esquerdo da comparação
<=
for menor ou igual ao direito.
&& E: retorna true apenas se os dois lados forem verdadeiros.
|| OU: retorna true se ao menos um dos lados forem verdadeiros.
String.equals Retorna true se os textos comparados forem exatamente iguais.
Retorna true se os textos comparados forem iguais ignorando
String.equalsIgnoreCase
maiúsculas e minúsculas.
Tabela 1.2 – Operadores utilizados para comparações.
A listagem 1.3 traz exemplos de uso dos operadores apresentados na

tabela 1.2, assim como o resultado da execução do código.
public static void main(String []args) {
System.out.println(7 > 8);

System.out.println(7 <= 8);
System.out.println((7 < 8) && (8 < 9));
System.out.println((7 > 8) || (8 < 9));
System.out.println(8 == 10);
System.out.println(8 != 10);
System.out.println(!(5 == 5));
String texto1 = "teste";

String texto2 = "Teste";
boolean comparacao1;
boolean comparacao2;
comparacao1 = texto1.equals(texto2);
comparacao2 = texto1.equalsIgnoreCase(texto2);
System.out.println(comparacao1);
System.out.println(comparacao2);
capítulo 1 • 13
SAÍDA (para cada estrutura):
false
true
true
true
false
true
false
false
true
Listagem 1.3 – Operadores lógicos, comparativos e comparação de textos.
Ao analisar o código e a saída do programa da Listagem 3 pode-se entender

como são retornados os resultados das operações utilizadas. Estes resultados
são muito utilizados em estruturas de repetição e estruturas condicionais.
As estruturas de repetição do Java são utilizadas para automatizar tarefas e
iterações do sistema com os dados. As estruturas são apresentadas na tabela 1.3.
Define todos os parâmetros logo no início
da estrutura, como a inicialização da variável
for de contagem, a condição de parada e o
incremento/decremento a ser efetuado em
cada iteração.
Define o critério de parada, mas a inicializa-
while ção da variável e o incremento são definidos
em local definido pelo programador.
Parecido com o while, mas checa se o crité-
do, while rio de parada foi satisfeito após a execução
da iteração.
Tabela 1.3 – Estruturas de repetição utilizadas no Java.
A listagem 1.4 traz um exemplo de uso de cada uma das estruturas exibidas
na tabela 1.3, assim como o resultado (saída) da execução do código.
14 • capítulo 1
// for contando de 1 a 10
for(int i=0; i<10; i++) {
System.out.println(i+1);
}
// while contando de 1 a 10
int j = 1;
while(j<=10) {
System.out.println(j);
j++;
}
// do, while contando de 1 a 10

int k = 1;
do {
System.out.println(k);
k++;
} while(k<=10);
SAÍDA (para cada estrutura):

1
2
3
4
5
6
7
8
9
10
Listagem 1.4 – Estruturas de repetição do Java.
capítulo 1 • 15
CONCEITO
As APIs (Application Programming Interfaces) são como bibliotecas de código que podem
ser reutilizados em diversas aplicações. É comum encontrar uma API que resolva ou facilite
a resolução de um problema específico sem ter que desenvolver código complexo para isto.
Finalizando esta revisão da sintaxe básica do Java, tem-se as estruturas con-

dicionais. A mais utilizada é a if, else e um exemplo da utilização esta estrutura
é dado na listagem 1.5.
int idade = 21;
if(idade >= 18) {

System.out.println("Pode dirigir");
} else {
System.out.println("Não pode dirigir");
}
if(true) {
System.out.println("Verdadeiro!");
}
SAÍDA:
Pode dirigir
Verdadeiro!
Listagem 1.5 – Estrutura condicional if, else.
Pode-se observar no código-fonte da listagem 1.5 que sempre que a condi-

ção entre os parênteses que seguem a palavra if retorna verdadeiro, o código
entre as chaves após o if é executado.
16 • capítulo 1
O uso do else é opcional e o código entre as chaves após o else é executa-
do sempre que a condição dentro dos parênteses do if retorna falso. É possível
também aninhar as estruturas condicionais if uma na outra utilizando: else if
(condição).
Apesar desta revisão da sintaxe do Java ser básica, mais conceitos de progra-
mação e da linguagem Java vão sendo explicados aos poucos durante este livro.
1.2 O ambiente servidor
Geralmente se nomeia servidor uma máquina que é utilizada para hospedagem

de serviços que podem ser oferecidos via rede. O fato de se dar este nome à uma
máquina física (hardware) não muda o fato de haverem também softwares que
são chamados de servidores. Mas afinal, o que é um servidor?
O nome “servidor” pode ser dado a soluções completas de serviços de in-
formática, como por exemplo um computador ligado à rede com um software
responsável por hospedar páginas de internet e que possibilita o acesso a estas
páginas por clientes.
Este nome também pode ser dado a partes desta solução, alguns exem-
plos são:
• Computador utilizado para hospedar algum serviço;
• Máquina voltada a hospedar serviços (não necessariamente
um computador);
• Software que provê mecanismos de se oferecer serviços de informática;
• Entre outros.
Apesar de existirem uma infinidade de soluções deste tipo para uso com a
internet, como o foco desta disciplina é ensinar a programação do lado servidor
de sistemas web, aqui são apresentados mais detalhadamente dois dos princi-
pais softwares utilizados para este fim, em se tratando de tecnologias baseadas
na linguagem Java:
• Apache Tomcat; • Glassfish.
O Apache Tomcat é considerado um contêiner de servlets, em outras pala-

vras, ele suporta basicamente a API JEE e é suficiente para o desenvolvimen-
to das aplicações web com as tecnologias que são apresentadas na disciplina
(ZAMBON, 2007).
capítulo 1 • 17
O Glassfish é um servidor de aplicação, trazendo mais recursos como
EJB (Enterprise JavaBeans), além de também suportar os recursos básicos
suportados pelo Tomcat.
A aplicação em Java para web, quando compilada, gera um pacote WAR
(Web application ARchive) contendo toda a aplicação desenvolvida. Este paco-
te é transferido para o servidor (em local específico no Tomcat ou Glassfish),
que fazem a implantação do projeto e disponibilizam seu uso (CAELUM, 2016).
Neste livro é utilizado um ambiente de desenvolvimento que possui integra-
ção tanto com o Glassfish quanto com o Tomcat, o que facilita muito a implan-
tação, depuração e testes dos aplicativos.
1.3 IDEs para desenvolvimento web
Construir programas e executá-los não requer, na maioria das tecnologias,

muitos recursos auxiliares. Porém, quando projetos ficam grandes e com-
plexos, é necessário ter um auxílio na organização de todos os arquivos que
são desenvolvidos.
Um outro fator de preocupação recorrente em projetos de desenvolvimento
de software é a produtividade. Não é recomendado desenvolver grandes proje-
tos de sistemas sem utilizar recursos de softwares de apoio (um simples bloco
de notas não dará conta do recado).
Existem softwares voltados a prover um ambiente de desenvolvimento ideal
para que os projetos de sistemas possam ser desenvolvidos de uma forma mais
organizada e mais produtiva. Estes softwares são chamados de IDE (Integrated
Development Environment), que em português quer dizer Ambiente de
Desenvolvimento Integrado.
Estes ambientes possuem uma grande diversidade de recursos e, além da-
queles que são nativos dos IDEs, a comunidade de desenvolvimento de software
desenvolve plug-ins para que novos recursos possam ser integrados.
Existem muitos IDEs que suportam o desenvolvimento de aplicações Java,
porém, os mais conhecidos e utilizados para desenvolvimento de sistemas
web são:
• NetBeans; • Eclipse; • IntelliJ.
Neste livro, a IDE utilizada é o NetBeans na versão 8.1 completa. Este IDE
possui muitos recursos nativos para desenvolvimento de sistemas e no decorrer
18 • capítulo 1
dos capítulos serão apresentados aqueles pertinentes ao desenvolvimento de
sistemas web.
Para a utilização deste IDE é necessário baixa-lo no sítio oficial: http://www.
netbeans.org, é gratuito. A figura 1.2 exibe a tela de download do IDE indicando
a versão utilizada neste livro.
Figura 1.2 – Página de download do NetBeans (NETBEANS, 2016).
Após a instalação ser efetuada, é só executar o programa e a tela inicial do

IDE será aberta. A figura 1.3 exibe o layout do IDE NetBeans em sua tela inicial.
Figura 1.3 – IDE NetBeans e suas divisões.
capítulo 1 • 19
É importante salientar alguns botões do IDE NetBeans que são utilizados
cotidianamente. A figura 1.4 exibe os botões do menu numerados, o que cada
um faz é explicado na sequência.
Figura 1.4 – Botões úteis do IDE NetBeans.
As funções de cada botão apresentado na figura 1.4:

1. Botão utilizado para selecionar em qual navegador web o sistema será
testado (dependendo do navegador padrão da máquina, o ícone do botão
pode mudar);
2. Botão utilizado para testar o programa. Ao clicar, os arquivos do siste-
ma são salvos, o sistema é recompilado, o servidor (selecionado no momento
da criação do projeto) é executado, o navegador é aberto já no endereço onde o
sistema está rodando;
3. Faz a mesma função que o botão (2), porém permite a depuração do
código: é possível marcar linhas de parada e acompanhar passo-a-passo a exe-
cução do código e valores de variáveis.
Apesar de possuir muitos recursos, que podem ser utilizados para o desen-
volvimento de uma gama de aplicações de diferentes plataformas, o objetivo é
apresentar o NetBeans para uso no desenvolvimento de aplicações web, o que
é feito a seguir.
1.4 Desenvolvimento web com NetBeans
Cada aplicação web que é desenvolvida utilizando o NetBeans, é tratada como

um projeto. Na criação de projetos existem diversos tipos de aplicação e nesta
seção é apresentado em forma de passo-a-passo como criar um projeto de sis-
tema web.
Primeiramente, é necessário clicar em: Arquivo -> Novo Projeto no menu su-
perior e então a janela de criação de projeto do NetBeans irá aparecer (figura 1.5).
20 • capítulo 1
Figura 1.5 – Janela de seleção de tipo de projeto a ser criado no NetBeans.
Para criar um projeto de sistema web, selecione no menu da esquerda Java

Web e após, selecione no menu da direita Aplicação Web. Desta maneira, um
projeto web vazio (apenas com a estrutura montada do projeto) será criado.
Após esta seleção, clicar em Próximo. Caso seja o primeiro projeto web, é ne-
cessário aguardar a ativação do módulo pelo NetBeans.
Figura 1.6 – Janela de definição do nome e localização do projeto a ser criado no NetBeans.
capítulo 1 • 21
A próxima etapa da criação é exibida na figura 1.6. Nesta etapa é necessário
definir um nome para o projeto, além da localização dos arquivos no computa-
dor (pasta do projeto). Neste primeiro projeto pode ser colocado o nome Teste.
Em localização do projeto, escolher uma pasta na qual seus projetos web serão
alocados. Em pasta do projeto é exibido o caminho completo do projeto que
está sendo criado. Após estas definições, clicar em Próximo.
Na terceira janela de criação de projeto (figura 1.7) são definidas as proprie-
dades de servidor, como qual servidor será utilizado pelo NetBeans para a exe-
cução do projeto localmente e qual a versão do Java EE.
CURIOSIDADE
Utilizar uma versão mais nova do JEE possibilitará a utilização de outros recursos, que não
modificarão de forma significativa o desenvolvimento dos exemplos contidos neste livro.
Para este projeto, o servidor Apache Tomcat é selecionado, assim como a

versão 5 do Java EE. O caminho do contexto pode permanecer relativo ao pro-
jeto, portanto, inalterado. Após estas seleções, clicar em Finalizar. O servidor
selecionado pode ser trocado após a criação do projeto, podendo ser escolhido
para os testes locais o Glassfish, que possui mais recursos.
Figura 1.7 – Janela de definição de dados sobre o servidor e versão do JEE referentes ao
projeto a ser criado no NetBeans.
22 • capítulo 1
Finalizando a criação do novo projeto, uma estrutura pré-definida e padro-
nizada é criada pelo NetBeans, tornando mais fácil a organização do código e
dos arquivos de configuração. Esta estrutura pode ser conferida na divisão da
esquerda do IDE, a figura 1.8 apresenta a estrutura criada.
Figura 1.8 – Estrutura de projeto web do NetBeans.
Na estrutura, cada item tem uma função bem definida, são ela:
• Páginas web: neste local são armazenadas as páginas do sistema (arqui-
vos jsp). Alguns arquivos de configuração XML também ficam nesta pasta (web.
xml e context.xml);
• Pacotes de códigos-fonte: local onde as classes Java são organizadas.
Estas classes incluem também os Servlets;
• Bibliotecas: aqui são adicionadas bibliotecas e APIs que podem ser utili-
zadas no desenvolvimento do projeto;
• Arquivos de configuração: como o próprio nome diz, local onde são con-
centrados arquivos de configuração do projeto.
CURIOSIDADE
A estrutura do projeto exibida nesta seção é nativa do IDE NetBeans, porém, ao utilizar uma
ferramenta de automatização de compilação como o Maven, o NetBeans passa a utilizar a
estrutura padronizada pela ferramenta em questão.
Mais detalhes sobre os arquivos e definições dos projetos web são apresen-
tados no decorrer do livro, assim que forem surgindo as necessidades.
capítulo 1 • 23
ATIVIDADES
01. Analise o código-fonte abaixo e escreva a sua saída.
String txt = "Hello World!";

int a = 10;
int b = 20;
int c = a + b;
int k = 5;
if((c > a) && (c > b)) {

for (int i=0; i<3; i++) {
System.out.println(i);
}
}
while(k > 2) {
if(txt.equals("hello world!")) {
System.out.println("Ola Mundo!");
} else {
System.out.println("Hello World!");
}
k--;
}
02. Cite três vantagens de se utilizar um IDE como o NetBeans para o desenvolvimento de
sistemas web.
REFLEXÃO
A preparação para o aprendizado em desenvolvimento de aplicações web está feita. Uma
revisão da linguagem de programação aplicada na disciplina, a explanação do ambiente ser-
vidor, informações sobre o ambiente de desenvolvimento a ser utilizado e sobre a criação de
um projeto “vazio” pronto para iniciar os trabalhos de programação foram passados neste
24 • capítulo 1
capítulo, conhecimento suficiente para prosseguir com os estudos e começar a desenvolver
sistemas para web. O primeiro capítulo serve também como referência e o mesmo deve ser
consultado sempre que necessário.
LEITURA
Para o aprendizado de programação em Java, o livro da série Use a Cabeça escrito por Kathy
Sierra e Bert Bates é altamente recomendado por seu caráter didático e bem-humorado.
SIERRA, Kathy; BATES, Bert. Use a Cabeça! Java. 2. ed. Rio de Janeiro: Alta Books,
2010. (Use a Cabeça!).
REFERÊNCIAS BIBLIOGRÁFICAS
ASCENCIO, Ana Fernanda Gomes; ARAÚJO, Graziela Santos de. Estruturas de Dados: algoritmos,
análise da complexidade e implementações em JAVA e C/C++. São Paulo: Pearson Prentice Hall,
2010.
BOOCH, Grady; RUMBAUGH, James; JACOBSON, Ivar. UML: Guia do Usuário. 2. ed. Rio de Janeiro:
Campus, 2005.
CAELUM. Java e Orientação Objetos. 2016. Disponível em: <https://www.caelum.com.br/download/
caelum-java-objetos-fj11.pdf>. Acesso em: 01 mar. 2016.
DEITEL, Paul; DEITEL, Harvey. Java: Como Programar. 8. ed. São Paulo: Pearson, 2010.
NETBEANS. Netbeans IDE. Disponível em: <https://netbeans.org/>. Acesso em: 18 mar. 2016.
SIERRA, Kathy; BATES, Bert. Use a Cabeça! Java. 2. ed. Rio de Janeiro: Alta Books, 2010. (Use a
Cabeça!).
ZAMBON, Giulio; SEKLER, Michael. Beginning JSP, JSF, Tomcat Web Development: From Novice
to Professional. United States Of America: Apress, 2007.
capítulo 1 • 25
26 • capítulo 1
2
Tecnologias de
Sistemas e Bancos
de Dados
2. Tecnologias de Sistemas e Bancos de
Dados
Este capítulo inicia de vez a programação do lado servidor para o desenvolvi-

mento de sistemas web. Logo no começo, duas das tecnologias mais importan-
tes para este fim são apresentadas: Servlet e JSP.
Após adquirido conhecimento destas tecnologias, a integração dos siste-
mas web com bancos de dados é abordada. Uma breve explicação de como fun-
ciona a API JDBC e uma explicação no formato de um tutorial sobre como criar
e manipular bancos de dados Java DB diretamente do NetBeans.
É muito importante a assimilação do conteúdo deste capítulo, pois concei-
tos aqui explicados são utilizados durante todo o livro, em exemplos e na expli-
cação de outros conceitos.
OBJETIVOS
Ao final deste capítulo, o aluno poderá trabalhar com interfaces web em Java utilizan-
do servlets e JSPs, criando e manipulando bancos de dados (Java DB) diretamente do
IDE NetBeans.
2.1 Servlets Java
Para iniciar o entendimento desta tecnologia, vamos começar com a seguinte

pergunta: o que são servlets?
Os Servlets são classes Java que podem receber e enviar requisições de diver-
sos tipos, normalmente utilizadas em sistemas web para o processamento de
requisições HTTP. Um contêiner de servlets é utilizado para fazer este proces-
samento, como por exemplo, o Apache Tomcat. O Glassfish também possui um
contêiner de servlets embutido.
Por se tratar de uma classe Java, a linguagem de programação utilizada no
desenvolvimento dos servlets é puramente Java. Um exemplo de servlet é apre-
sentado na listagem 2.1.
28 • capítulo 2
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Teste extends HttpServlet {

protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("Resultado da Servlet");
} finally {
out.close();
}
}
@Override
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
protected void doPost(HttpServletRequest request,
processRequest(request, response);
}
@Override
public String getServletInfo() {
return "Descrição";
}
}
Listagem 2.1 – Exemplo de código de um servlet Java.
capítulo 2 • 29
Ao observar o código do servlet na Listagem 6 pode-se atentar para diversas
particularidades, como:
• A importação de bibliotecas utilizadas para o processamento
das requisições;
• A herança (extends) entre a classe criada (servlet) e a classe HttpServlet;
• O método processRequest que faz o processamento do servlet em questão;
• A criação de um PrinterWriter chamado out que é utilizado para impres-
são de valores quando o processamento do servlet é efetuado;
• O método doGet que é disparado quando a URL do servlet é acessada;
• O método doPost que é disparado quando uma requisição POST é efetua-
da por meio de um formulário, por exemplo;
• O método getServletInfo que retorna uma descrição do servlet.
É possível criar, a partir de um servlet, uma página visual em HTML. Para

isto, é necessário utilizar o PrinterWriter que irá imprimir na tela as tags HTML
e seus conteúdos. Um exemplo de utilização de servlet para a criação de uma
página HTML é dado na listagem 2.2.
…
try {
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet Teste</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Este é um teste!!!</h1>");
out.println("<h2>Servlet Rodando: Tomcat</h2>");
out.println("</body>");
out.println("</html>");
} finally {
out.close();
}
...
30 • capítulo 2
Saída:
<!DOCTYPE html>
<html>
<head>
<title>Servlet Teste</title>
</head>
<body>
<h1>Este é um teste!!!</h1>
<h2>Servlet Rodando: Tomcat</h2>
</body>
</html>
Listagem 2.2 – Criando uma página HTML a partir de um servlet Java.
A saída do servlet é o código Java processado pelo contêiner de servlet, neste

caso, o Tomcat. Esta saída é interpretada pelo navegador e exibe uma página
em HTML, como na figura 2.1 que demonstra a página gerada pelo código apre-
sentado na listagem 2.2.
Figura 2.1 – Servlet rodando em um navegador web.
Dentro do arquivo de configuração da aplicação “web.xml” é definido um

local para que o servlet possa ser acessado pela aplicação web. A listagem 2.3
traz a configuração do servlet apresentado na listagem 2.2, que será acessado
na raiz do projeto (pasta “/”).
capítulo 2 • 31
<servlet>
<servlet-name>Dados</servlet-name>
<servlet-class>Dados</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Dados</servlet-name>
<url-pattern>/Dados</url-pattern>
</servlet-mapping>
Listagem 2.3 – Definindo um servlet no arquivo “web.xml”.
No NetBeans, ao criar um servlet, o endereço de acesso do mesmo deve ser

informado na tela de criação e então o IDE gera automaticamente a configura-
ção no “web.xml”.
Criar interfaces com servlet não é algo muito comum em desenvolvimento
de sistemas web pelo fato de que é mais complicado escrever código Java que
imprima tags HTML do que as próprias tags.
Pensando nisto, são desenvolvidas as JSPs, explicadas na seção seguinte
deste livro.
2.2 JavaServer Pages (JSP)
As JavaServer Pages (JSPs) são uma extensão dos servlet (DEITEL; DEITEL,
2010). Esta extensão facilita o desenvolvimento de interfaces para sistemas web
programados em Java, misturando a programação em linguagem Java com as
tags HTML/XHTML.
Esta mistura é feita da seguinte forma:
• O código HTML é escrito livremente no arquivo JSP;
• O código Java é escrito dentro de marcadores: <% código aqui %>;
• Existem tags próprias do JSP para facilitar acesso a alguns recursos;
• Classes Java que forem utilizadas nas páginas devem ser devidamen-
te importadas.
As páginas JSP também são processadas no lado servidor, pelo contêiner

servlet, gerando como saída um código HTML que é interpretado pelo nave-
gador (BASHAM; SIERRA; BATES, 2010). Um exemplo básico de página JSP e o
código HTML gerado é dado na listagem 2.4.
32 • capítulo 2
<%@page contentType="text/html"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>Título do JSP</title>
</head>
<body>
<h2>Contar até 10:</h2>
<% for(int i=0; i<10; i++) { %>
<p><% out.print(i+1); %></p>
<% } %>
</body>
</html>
Saída:
<!DOCTYPE html>
<html>
<head>
<title>Título do JSP</title>
</head>
<body>
<h2>Contar até 10:</h2>
<p>1</p>
<p>2</p>
<p>3</p>
<p>4</p>
<p>5</p>
<p>6</p>
<p>7</p>
<p>8</p>
<p>9</p>
<p>10</p>
</body>
</html>
Listagem 2.4 – Criando uma página JSP básica.
capítulo 2 • 33
Ao observar o código JSP da listagem 2.4, nota-se os marcadores <% e %>
atuando dentro do código HTML. O código que é colocado dentro destes mar-
cadores é Java. Neste exemplo, uma estrutura de repetição é utilizada para re-
petir dez vezes uma linha de código HTML, esta técnica é muito utilizada para
preenchimento de dados tabulares, onde se repete a linha enquanto existirem
dados a serem exibidos.
Facilita-se muito a criação de páginas dinâmicas para a internet utilizan-
do JSP ao invés de servlet. Porém, os servlet são muito utilizados na camada
de controle do software, explicada em momento oportuno (BASHAM; SIERRA;
BATES, 2010).
Para o desenvolvimento de páginas dinâmicas é necessário que se leia parâ-
metros advindos de formulários, este tema é abordado a seguir.
2.3 Recebendo parâmetros
Tanto servlet quanto JSPs têm o poder de receber parâmetros advindos de for-
mulários ou até mesmo de outras formas. Nesta seção são apresentados os
métodos que são utilizados para o recebimento dos parâmetros advindos de
formulários web e que serão posteriormente processados.
O formulário utilizado nos exemplos é apresentado na listagem 2.5.
<form name="form1" method="post" action="______">

<label>Nome:</label>
<input type="text" name="nome"/>
<label>Idade:</label>
<input type="text" name="idade"/>
<input type="submit" value="Enviar"/>
</form>
Listagem 2.5 – Formulário web para passagem de parâmetros.
A propriedade action do formulário não está preenchida na listagem 2.5

pois este mesmo formulário será utilizado para enviar dados a um servlet e a
uma página JSP.
Imaginando que no action do formulário esteja o caminho para o servlet
Dados, ao ser submetido, o formulário envia os dados dos campos nome e ida-
de para o servlet Dados, que os recebe e imprime em tela. A listagem 2.6 traz o
código do Servlet que recebe os dados do formulário.
34 • capítulo 2
try {
String nome;
String idade;
nome = request.getParameter("nome");
idade = request.getParameter("idade");
out.print("<p>Nome: " + nome + "</p>");

out.print("<p>Idade: " + idade + "</p>");
} finally {
out.close();
}
Listagem 2.6 – Servlet Dados recebendo parâmetros do formulário.
Observa-se que o método getParameter utiliza o nome do campo do formu-

lário para buscar o valor na requisição enviada ao servlet e o atribui a uma va-
riável. Após isto, o dado pode ser processado utilizando programação em Java,
como por exemplo ser salvo em um banco de dados. Neste caso, o dado está
sendo exibido no formato HTML.
CURIOSIDADE
O método getParameter sempre retorna uma String. Caso seja necessário utilizar outro
tipo de dado, como números e datas, é necessário que seja feita uma conversão (CAELUM,
2016).
No próximo exemplo (listagem 2.7), imaginemos que o action do formulário

estava preenchido com “dados.jsp”, ou seja, enviando os dados do formulário
para uma página JSP.
capítulo 2 • 35
<%
String nome;
String idade;
nome = request.getParameter("nome");
idade = request.getParameter("idade");
%>
<!DOCTYPE html>
<html>
<head>
<title>Dados</title>
</head>
<body>
<p>Nome: <%=nome%></p>
<p>Idade: <%=idade%></p>
</body>
</html>
Listagem 2.7 – Página dados.jsp recebendo parâmetros do formulário.
Na listagem 2.7, logo no início do código, os parâmetros nome e idade são

atribuídos a variáveis, que posteriormente serão utilizadas na página.
O uso das variáveis na página JSP exibida na listagem 2.7 é apenas para im-
pressão. Esta impressão é feita de uma forma mais enxuta que anteriormente
(utilizando o método out.print), trata-se de uma facilidade incluída no JSP para
a impressão de conteúdo armazenado em variáveis Java.
Os exemplos exibidos aqui foram todos utilizando o método POST, porém,
se os parâmetros fossem enviados utilizando o método GET o seu recebimento
tanto pelo servlet quanto pela página JSP seria da mesma forma.
LEITURA
O JSP permite o uso de tags próprias que livram o programador de utilizar código Java na
página em diversas ocasiões, tornando-a mais natural. Uma boa explicação de uso das ta-
glibs (bibliotecas de tags) é dada na apostila de Java para Desenvolvimento Web da Caelum,
disponível gratuitamente no endereço:
https://www.caelum.com.br/apostila-java-web/
36 • capítulo 2
Mais detalhes e recursos dos JSPs e servlets são apresentados conforme ne-
cessidade durante os exemplos práticos do livro. Na próxima seção inicia-se o
aprendizado do uso de bancos de dados nas aplicações web.
2.4 A API JDBC
A JDBC (Java DataBase Connectivity) é uma API (Application Programming

Interface) que implementa diversas funcionalidades que facilitam a conexão e
com diferentes bancos de dados (ORACLE, 2016).
O envio de instruções SQL para os bancos de dados relacionais também é
feito por meio da JDBC, que possui métodos que possibilitam tal troca de infor-
mação entre a aplicação e o banco de dados.
CURIOSIDADE
Em muitas aplicações é possível que se necessite a troca do sistema gerenciador de banco
de dados em algum momento. Ao utilizar a JDBC, esta troca é feita de uma maneira mais
simples, pois o tratamento entre a aplicação e os diversos bancos de dados que a JDBC
suporta é praticamente o mesmo.
Para efetuar a conexão com o sistema gerenciador de banco de dados

(SGBD), é necessário que se utilize um driver específico. Este driver é uma bi-
blioteca Java que deve ser inserida no projeto para que a conexão e a troca de
informações possam ocorrer. Neste livro, o SGBD utilizado nos exemplos é o
Java DB.
Para adicionar um driver no projeto em desenvolvimento utilizando o
NetBeans, clica-se com o botão direito na pasta do projeto “Bibliotecas” e se-
leciona-se “Adicionar biblioteca...”. Uma tela com as bibliotecas nativas do
NetBeans aparecerá (figura 2.2). Escolhe-se uma das bibliotecas referente ao
driver do SGBD que se pretende utilizar e clica-se em “Adicionar Biblioteca”.
Nota-se também que é possível criar novas bibliotecas, que podem ser baixadas
da internet e adicionadas ao NetBeans.
capítulo 2 • 37
Figura 2.2 – Tela de escolha de biblioteca para adicionar à projeto.
Um SGBD muito utilizado para aplicações web é o MySQL. Para se fazer uma
conexão é necessário apenas que a biblioteca do driver seja inserida no projeto
em questão. Uma classe é utilizada para fazer a conexão com o banco de dados
e então as APIs de manipulação dos dados podem ser utilizadas para fazer as
operações SQL da aplicação para o SGBD.
2.5 Gerenciando JavaDB com NetBeans
O Java DB é um servidor de banco de dados. O IDE NetBeans possui toda uma

infraestrutura para que se possa trabalhar com este banco de dados, como fazer
a criação de tabelas, conexão e gerenciamentos em geral (NETBEANS, 2016).
De acordo com NetBeans (2016), o Java DB é suportado pela Apache Derby e
encapsulado junto ao servidor de aplicações Glassfish, assim como na própria
JDK (a partir da versão 6). Isto faz com que seja facilmente adotado como um
padrão para desenvolvimento em Java, principalmente em se tratando de apli-
cações para web.
Nesta seção é mostrado um passo-a-passo de como configurar um projeto
NetBeans para trabalhar com o Java DB, desde sua configuração até a criação de
tabelas e envio de instruções SQL, baseado no tutorial fornecido pela própria
NetBeans (2016).
38 • capítulo 2
Inicializaremos criando um novo projeto chamado: “DBTeste”. Seguir as ins-
truções dadas no primeiro capítulo sobre como criar um projeto web no NetBeans,
mas neste caso, o servidor a ser escolhido para rodar a aplicação será o Glassfish.
Após a criação do projeto, a estrutura deste deve ser como a exibida na figura 2.3.
Figura 2.3 – Estrutura do projeto BSTeste recém-criado.
É necessário checar se o serviço do Java DB está configurado no NetBeans.

Para isto, o primeiro passo é clicar na aba “Serviços” e checar se consta o Java
DB aninhado à Bancos de Dados, assim como exibido na figura 2.4.
Figura 2.4 – Serviço do Java DB instalado no NetBeans.
capítulo 2 • 39
Deve-se checar também se a configuração está correta. A figura 2.5 exibe
a janela que aparece ao clicar com o botão direito em “Java DB” e selecionar
“Propriedades...”.
Figura 2.5 – Janela de “Propriedades” do Java DB.
Se na janela de propriedades estiver o caminho correto da JDK e o caminho

correto da pasta do usuário com a devida pasta do Java DB, então a configura-
ção está correta.
O próximo passo é estabelecer a conexão com o servidor Java DB. Para isto, é ne-
cessário primeiramente iniciar o serviço, que é feito clicando com o botão direito
em “Java DB” e selecionando “Iniciar Servidor”, como apresentado na figura 2.6.
Figura 2.6 – Iniciando o serviço do Java DB.
40 • capítulo 2
O resultado da inicialização do serviço pode ser observado na aba inferior
“Saída”, onde deve-se conter algo como o resultado apresentado na listagem 2.8.
Wed Mar 16 21:36:47 BRT 2016 : DRDA_SecurityInstalled.I
Wed Mar 16 21:36:48 BRT 2016 : Apache Derby Servidor de Rede -

10.10.1.3 - (1557168) iniciado e pronto para aceitar conexões na porta
1527 em {3}
Listagem 2.8 – Saída da inicialização do serviço do Java DB.
É importante que a seguinte frase faça parte da saída: “...iniciado e pronto

para aceitar conexões...”, assim como exibido na listagem 2.8. Isto significa que
o servidor está pronto para ser utilizado.
A próxima etapa é criar o banco de dados que será utilizado para armazenar
as informações da aplicação. Para a criação do banco de dados, clicar com o
botão direito em “Java DB” e selecionar “Criar Banco de Dados...”.
Na janela que se abre (figura 2.7), preencher com informações pertinentes:
• Nome do Banco de dados: será o nome do seu banco, geralmente relacio-
nado ao nome do projeto ou da aplicação, mas em sistemas grandes pode ser
um nome relacionado aos tipos de dados que serão armazenados neste banco;
• Nome do usuário: usuário do banco de dados (SGBDs implementam res-
trições de acesso por usuários);
• Senha: senha para o usuário selecionado anteriormente;
Figura 2.7 – Conectando-se ao serviço do Java DB.
capítulo 2 • 41
Nos campos de usuário e senha, utilizar “nbuser”, usuário padrão criado
pelo NetBeans. O nome do banco de dados pode ser “clientes”, pois se trata de
um cadastro de informações de clientes neste exemplo.
Nota-se que, após criado, o banco de dados aparece aninhado à Java DB na
aba Serviços, como exibido na figura 2.8. O nó de conexão também é criado,
logo abaixo de “Drivers”.
Figura 2.8 – Banco de dados criado em Java DB.
Para manipular o banco de dados, é necessário se conectar a ele. Para

efetuar a conexão, clique com o botão direito no nó de conexão (jdbc:derby:
//localhost:1527/clientes [nbuser em NBUSER]) e clique em “Conectar”. Pode-
se também renomear o nó de conexão para algo que seja mais agradável, como
por exemplo: “BD de Clientes”.
Após efetuada a conexão, pode-se observar adicionar tabelas no nó NBUSER,
referente ao banco de dados que foi criado. A figura 2.9 exibe a situação da aba
serviços após a conexão, lembrando que o nó de conexão foi renomeado.
42 • capítulo 2
Figura 2.9 – Conectado ao banco de dados.
Para este exemplo será criada uma tabela de clientes com os seguintes dados:
• Documento: um campo texto utilizado como chave primária da tabela,
identificando unicamente os clientes;
• Nome: um campo texto que armazenará o nome do cliente;
• Endereço: um campo texto que armazenará o endereço do cliente;
• Telefone: um campo texto que armazenará o telefone do cliente;.
Geralmente utiliza-se campos texto mesmo para numéricos para colunas

que não efetuarão operações aritméticas.
Para criar uma tabela, clicar com o botão direito na pasta de tabelas em
NBUSER, como exibido na figura 2.10.
capítulo 2 • 43
Uma janela (figura 2.11) é exibida sobre a tabela a ser criada. Inicialmente,
sem nenhuma coluna, mas isto pode ser resolvido clicando no botão
“Adicionar coluna”.
Ao clicar em “Adicionar coluna”, uma nova janela é aberta. Nesta janela, são
definidas as propriedades de uma coluna a ser inserida na tabela, como nome
da coluna, tipo de dado, tamanho e restrições.
44 • capítulo 2
No caso da inserção da coluna “documento”, que é a chave primária da tabe-
la, os dados são exibidos na figura 2.12.
Figura 2.12 – Adicionando a coluna “documento”.
Adicionando as demais colunas, o resultado da tabela é exibido na figura

2.13 com todas as colunas anteriormente descritas já adicionadas.
Figura 2.13 – Tabela “cliente” com todas as colunas adicionadas.
Após criada a tabela, a aba “Serviços” é exibida conforme figura 2.14, onde
pode-se observar a tabela “cliente” e suas colunas devidamente aninhadas.
capítulo 2 • 45
Figura 2.14 – Tabela “cliente” e suas colunas na aba “Serviços”.
No próximo passo é testada a inserção de dados na tabela cliente por meio de

instrução SQL. Serão adicionados dois clientes conforme descrito na listagem 2.9.
INSERT INTO cliente

(documento, nome, endereco, telefone)
VALUES
(‘40401010’, ‘João’, ‘Rua 7 de setembro, 5050’, ‘3333-3333’),
(‘50502020’, ‘Paulo’, ‘Rua 13 de maio, 10557’, ‘2101-2101’);
Listagem 2.9 – Comando SQL para a inserção de clientes.
46 • capítulo 2
Para a execução do comando deve-se abrir a janela de comandos SQL para
o banco de dados. Esta janela abre-se ao clicar com o botão direito na tabela e
selecionar “Executar comando...”.
O resultado da execução do comando aparece na saída e na figura 2.15 po-
de-se observar a janela de comando sendo utilizada para inserir dois registros
(duas linhas) na tabela “cliente”.
Figura 2.15 – Inserindo dados na tabela por meio de comando SQL.
Para checar se os dados foram corretamente inseridos, clica-se com o botão

direito na tabela e seleciona-se “Exibir Dados...”. A janela de comandos é aberta
já com um comando SQL de seleção de todos os dados da tabela preenchido e,
este comando é automaticamente executado, exibindo a tabela dos dados logo
abaixo, assim como exibido na figura 2.16.
capítulo 2 • 47
Figura 2.16 – Consulta de dados de tabelas Java DB com NetBeans.
Ainda é possível executar consultas mais elaboradas por meio dos coman-
dos SQL, além de fazer alterações na tabela e executar outros comandos como
UPDATE e DELETE (NETBEANS, 2016).
ATIVIDADES
01. Qual tipo de biblioteca é imprescindível para um projeto web do NetBeans ter a capaci-
dade de se comunicar com determinado sistema gerenciador de banco de dados (SGBD)?
02. Qual a diferença de se criar uma página web utilizando um servlet e um JSP?
03. Um servlet que processa requisições HTTP deve ser filho (herdar) de qual classe Java?
04. Qual a aba do NetBeans utilizada para gerenciamento de servidores de bancos de dados?
48 • capítulo 2
REFLEXÃO
Os servlets e as JSPs são amplamente utilizados em desenvolvimento de sistemas web com
Java e, por este motivo, foram apresentadas neste capítulo de forma prática.
Quase a totalidade dos sistemas web fazem uso de persistência de dados de alguma
forma, a mais utilizada é o uso de sistemas gerenciadores de bacos de dados (SGBDs).
Para facilitar o desenvolvimento e o uso destes sistemas integrando-os de forma prática,
uma explicação em forma de tutorial de como manipular o banco de dados por meio do IDE
NetBeans foi apresentada neste capítulo, capacitando o aluno a construir de forma dinâmica
os sistemas para internet.
A manipulação dos dados por meio da aplicação é explicada mais à frente no livro, tam-
bém por meio de exemplos práticos.
LEITURA
O livro da série Use a Cabeça sobre servlets e JSP é muito completo e didático para progra-
madores que desejam se aprofundar em desenvolvimento web com Java. Leitura indispen-
sável para pessoas que desejam prestar provas de certificação na área.
BASHAM, Bryan; SIERRA, Kathy; BATES, Bert. Use a cabeça! Servlets & JSP. Rio de
Janeiro: Alta Books, 2010. (Use a cabeça!).
BASHAM, Bryan; SIERRA, Kathy; BATES, Bert. Use a cabeça! Servlets & JSP. Rio de Janeiro: Alta
Books, 2010. (Use a cabeça!).
CAELUM. Java para desenvolvimento web. Disponível em: <https://www.caelum.com.br/apostila-
java-web/>. Acesso em: 13 mar. 2016.
NETBEANS. Trabalhando com o Banco de Dados Java DB (Derby). Disponível em: <https://
netbeans.org/kb/docs/ide/java-db_pt_BR.html>. Acesso em: 13 mar. 2016.
ORACLE. JDBC Overview. Disponível em: <http://www.oracle.com/technetwork/java/
overview-141217.html>. Acesso em: 21 mar. 2016.
capítulo 2 • 49
50 • capítulo 2
3
Sessões e
o Modelo MVC
3. Sessões e o modelo MVC
No início deste capítulo é apresentada a tecnologia de sessões. Trata-se de um
mecanismo muito utilizado em diversos tipos de aplicação. Um exemplo do
uso deste recurso também é apresentado e trata-se de gerenciamento de login
em sistemas web, uma das funcionalidades mais utilizadas em sistemas que
requerem controle de acesso de usuários.
Após as sessões, o modelo MVC é o tema deste capítulo. Apresentado de forma teó-
rica e prática, inclusive com um exemplo prático de como as camadas se comuni-
cam em um padrão de estrutura de projeto, este tema é imprescindível para um
bom desenvolvimento de sistema para internet, em outras palavras, para desen-
volver sistemas organizados, funcionais e que sejam fáceis de se dar manutenção.
OBJETIVOS
Ao final deste capítulo, o aluno poderá:
• Trabalhar com sessões em sistemas web;
• Implementar controle de acesso de usuários;
• Desenvolver sistemas que seguem um padrão de desenvolvimento;
• Desenvolver sistemas que seguem o padrão MVC.
3.1 Gerenciamento de sessão e login
Todos os usuários de internet alguma vez já se depararam com um sistema de

segurança de alguma aplicação que necessitasse de um nome de usuário e uma
senha para que se pudesse ter acesso à certas funcionalidades de uma aplica-
ção, ou a um perfil próprio de usuário.
Na maioria das vezes, esse tipo de verificação é feito utilizando uma tecno-
logia chamada: sessão.
Uma sessão é gravada no lado servidor e permanece válida até uma destas
aconteça uma destas:
• O tempo de inatividade configurado seja atingido;
• A sessão seja invalidada de propósito por meio de um método;
• O navegador do usuário seja fechado.
52 • capítulo 3
Ao iniciar uma sessão, é configurado um tempo de inatividade máximo para
que, se o usuário se mantiver inativo (não trocar dados com o servidor) durante
o tempo configurado, a sessão é automaticamente invalidada.
Existe também um método que pode ser acionado sempre que o programa-
dor desejar que a sessão seja invalidade, como por exemplo, a ação do botão
“sair” nos sistemas, que invalida a sessão no momento em que são clicados.
A sessão é mantida mesmo com a navegação para diferentes páginas, desde
que no mesmo sistema web. Algumas aplicações comuns de sessão em siste-
mas de internet são:
• Carrinhos de compras;
• Gerenciamento de perfil de usuário;
• Controle de acesso a funcionalidades;
• Controle de acesso a dados;
• Persistência de dados informados em formulários de mais de uma página.
Um exemplo de gerenciamento de login é dado a seguir, utilizando-se do

gerenciamento de sessão em Java. Como as sessões podem ser manipuladas
tanto por servlets quanto por JSPs, o exemplo engloba as duas tecnologias.
A figura 3.1 exibe o esquema do exemplo a ser apresentado.
Figura 3.1 – Esquema do exemplo de gerenciamento de login utilizando sessão.
CURIOSIDADE
Login é o nome dado a parte de um sistema que checa um nome de usuário e uma senha
para dar acesso a quem está navegando. O nome login também é dado algumas vezes ape-
nas ao nome de usuário utilizado para entrar em um sistema.
O nome de usuário ou login geralmente é um código único ou um e-mail.
capítulo 3 • 53
Observando a figura 3.1, conclui-se o passo-a-passo do exemplo:
• Usuário acessa a página “login.jsp”, que possui um formulário com dois
campos: login e senha.
• Ao enviar os dados de login e senha, um servlet chamado “Verifica” irá
recebe os dados e checa se o usuário teria a permissão para acesso à página
“sistema.jsp”.
• Se o usuário tiver acesso, o servlet grava os dados do usuário na sessão,
indicando que este tem acesso e o redireciona para a página “sistema.jsp”.
• Se o usuário não tiver permissão, o servlet o redireciona novamente para
a página login.jsp com uma variável sendo passada por GET indicando que o
usuário digitado não tem permissão.
• Quando o usuário é redirecionado novamente para a página “login.jsp”,
uma mensagem é exibida conforme a variável enviada pelo servlet;
• Quando o usuário é redirecionado para a página “sistema.jsp”, uma men-
sagem de boas-vindas é exibida caso a sessão ainda esteja válida, isto serve para
evitar acessos indevidos diretamente pelo endereço da página “sistema.jsp”.
A listagem 3.1 exibe o código do formulário existente na página “login.jsp”
<h1>Sistema de Login</h1>
<form method="post" action="Verifica">
Login:
<input type="text" name="login"/>
Senha:
<input type="password" name="senha"/>
<br/>
<input type="submit" value="Entrar"/>
</form>
Listagem 3.1 – Formulário para envio de dados para o servlet de verificação.
O código do servlet, quando recebe os dados do formulário, é exibido na

listagem 3.2 e com o auxílio das marcações, é explicado logo em seguida.
54 • capítulo 3
//MARCAÇÃO 1
String login = request.getParameter("login");
String senha = request.getParameter("senha");
//MARCAÇÃO 2
HttpSession sessao = request.getSession();
//MARCAÇÃO 3
if(login.equals("joao") && senha.equals("aabb")) {
//MARCAÇÃO 4
sessao.setAttribute("permissao", "sim");
sessao.setAttribute("usuario", login);
//MARCAÇÃO 5
response.sendRedirect("sistema.jsp");
} else {
//MARCAÇÃO 6
sessao.invalidate();
//MARCAÇÃO 7
response.sendRedirect("login.jsp?permissao=nao");
Listagem 3.2 – Servlet “Verifica” checando a permissão do usuário para acesso ao sistema.
A explicação dos trechos de código marcados na listagem 3.2 segue:

• Marcação 1: o servlet está recebendo os dados advindos do formulário;
• Marcação 2: A sessão é atribuída a uma variável chamada “sessao” para
que possa ser manipulada;
• Marcação 3: Uma estrutura condicional está checando a permissão do
usuário de acessar ou não o sistema;
• Marcação 4: Caso o usuário tenha permissão, dois dados são salvos na
sessão, o primeiro indicando que a permissão foi concedida e o segundo indi-
cando o nome do usuário, que agora encontra-se logado no sistema;
• Marcação 5: O servlet redireciona o usuário para a área do sistema em que
é necessária a permissão;
• Marcação 6: Caso o usuário não tenha permissão, a sessão é invalidada;
• Marcação 7: O servlet redireciona o usuário para a página de login no-
vamente, com a passagem de um parâmetro chamado “permissão” e o valor
capítulo 3 • 55
“nao”, para que este parâmetro possa ser checado na JSP e possa emitir um
alerta ao usuário que a permissão não foi concedida.
O código da página “sistema.jsp”, que deve ser exibida apenas em caso de

permissão concedida ao usuário, é apresentado na listagem 3.3.
<%
<%
//MARCAÇÃO 1
String p = (String)
session.getAttribute("permissao");
String login = (String)
session.getAttribute("login");
//MARCAÇÃO 2
if(p.equals("sim")) {
%>
<!DOCTYPE html>
<html>
<head>
<title>Sistema Restrito</title>
</head>
<body>
<p>Acesso ao sistema concedido para:

<%=login%>
</p>
</body>
</html>
<%
} else {
//MARCAÇÃO 4
response.sendRedirect("login.jsp?permissao=nao");
}
%>
Listagem 3.3 – Página “sistema.jsp” exibindo dados ao usuário com permissão de acesso.
56 • capítulo 3
As marcações feitas no código da listagem 3.3 significam:
• Marcação 1: atribuindo os valores dos atributos da sessão em variáveis do
tipo String;
• Marcação 2: verificando se o valor atribuído para “permissão” é igual a
“sim” e se for, a página é exibida;
• Marcação 3: Exibindo o login do usuário que obteve a permissão para
acesso à página;
• Marcação 4: Redirecionando o usuário para a página de login novamente,
caso o valor do atributo de permissão da sessão não seja igual a “sim”.
Analisando o código da listagem 3.3, observa-se que nas páginas JSP a va-
riável de sessão (chamada session) não precisa ser instanciada, isto é feito de
forma automática e transparente, diferentemente dos servlets.
Após a execução deste exemplo é possível estendê-lo para diversas outras
funcionalidades que necessitem de sessão para seu funcionamento.
3.2 O modelo MVC
Muito difundido e utilizado na grande maioria dos sistemas web em desenvol-

vidos em diferentes plataformas e tecnologias, o modelo MVC (Model-View-
Controller e em português Modelo-Visão-Controle) visa separar o sistema em
diferentes camadas para que a aplicação fique mais organizada melhorando
assim a clareza do código e a manutenibilidade do sistema (BASHAM; SIERRA;
BATES, 2010).
Na prática, as funções das três partes do modelo MVC são:
• Modelo: lógica de negócios, classes Java que implementam a lógica
da aplicação;
• Visão: páginas web (JSP) que são acessadas pelos usuários, também utili-
zadas para exibição/digitação de conteúdo;
• Controle: servlets Java que recebem os parâmetros da camada de visão,
processam e atribuem os dados ao modelo. Funcionam também de maneira in-
versa, requerendo dados do modelo, processando e enviando-os para a camada
de visão para serem exibidas ao usuário.
Hoje em dia, desenvolver aplicações web utilizando o modelo de desenvolvi-

mento MVC é quase que um padrão. Existem duas versões deste modelo:
• MVC I; • MVC II.
capítulo 3 • 57
A grande diferença entre as duas, segundo Javapoint (2016) versões é que
no MVC I os controles eram feitos por páginas JSP e ficavam espalhados por
estas, descentralizados. No modelo MVC II existe uma camada implementada
via servlet que faz a conexão entre as páginas JSP e as classes Java do modelo
(lógica de negócios).
O servlet implementado no modelo MVC II chamado utiliza-se do padrão
de projeto front controller (ECKSTEIN, 2007), que é um único servlet que fil-
tra requisições e responde com redirecionamento entre as diferentes páginas
(MEDEIROS, 2016).
A figura 3.2 exibe o esquema MVC básico e suas partes.
Figura 3.2 – Modelo MVC básico para desenvolvimento web em Java.
CURIOSIDADE
O modelo MVC é implementado em diversos frameworks de desenvolvimento web com Java,
como:
• Spring MVC;
• JSF;
• Struts.
O modelo MVC II é apresentado na figura 3.3, onde pode-se observar a re-

quisição sendo feita para o servlet de controle, que se comunica com as demais
partes do projeto.
58 • capítulo 3
Figura 3.3 – Modelo MVC II, adaptado de Javapoint (2016).
Como vantagens de se utilizar MVC II, citadas por Javapoint (2016), têm-se:
• Maior facilidade de manutenção;
• Controle de navegação centralizado;
• Maior facilidade de crescimento do sistema;
• Maior facilidade para execução de testes;
• Melhor separação entre diferentes conceitos.
A grande desvantagem do MVC II apontada por diversos autores é a dificul-

dade e a complexidade no desenvolvimento do servlet de controle.
Os DAOs (Data Access Object ou Objeto de Acesso a Dados em português)
também são utilizados em conjunto com a arquitetura MVC. Tratam-se de clas-
ses que possuem métodos de acesso ao banco de dados e serão vistos com mais
detalhes no capítulo 4.
No exemplo de aplicação apresentado na seção a seguir, a estrutura de um
projeto seguindo o modelo MVC é criada em um passo-a-passo.
3.3 Aplicação com MVC
Nesta seção uma aplicação web MVC é criada partindo da estaca zero em um
passo-a-passo bem simples de ser seguindo. Primeiramente, um novo projeto
web é criado no NetBeans, seguindo os passos explicados no capítulo 1. Os da-
dos para criação do projeto são exibidos na tabela 3.1, dados que não constem
na tabela não necessitam ser alterados.
capítulo 3 • 59
NOME DO PROJETO WEBMVC
Servidor Glassfish
Versão do Java EE Java EE 5
Tabela 3.1 – Dados para criação do projeto web com MVC.
Após a criação do projeto, confirmar se a estrutura do projeto é semelhante

à apresentada na figura 3.4.
Figura 3.4 – Estrutura inicial do projeto web.
Observa-se na figura 3.4 que, em destaque, encontra-se um <pacote de-

fault>. Este pacote faz parte da estrutura de códigos-fonte do projeto e o default
só existe pois ainda não foram criados pacotes para organizarmos os códigos-
fonte da aplicação.
Nesta aplicação existirão ao menos três tipos de classes Java (sem contar as
páginas JSP que são alocadas com outra estrutura). Estes tipos são:
• Classes do Modelo;
• Classes do Controle;
• Classes de DAO.
Para cada tipo de classe é criado um pacote diferente. O padrão para a cria-
ção de pacotes de código-fonte em Java é utilizar o domínio da empresa desen-
volvedora ou dona do software ao contrário, isto facilita a organização das clas-
ses e posterior busca, além de evitar conflitos de classes com nomes iguais.
60 • capítulo 3
Para os pacotes a serem criados neste exemplo, suponha que a empresa de-
senvolvedora se chama Aluno S/A e o domínio desta empresa é alunosa.com.br.
Deste modo, o nome do pacote a ser criado para a camada de modelo da aplica-
ção é exibido na figura 3.5. Para adicionar pacotes, clicar com o botão direito na
pasta de código-fonte, selecionar “Novo” e depois “Pacote Java”.
Figura 3.5 – Janela de criação de um pacote Java.
Para dar continuidade no desenvolvimento do projeto, criar os pacotes para

controle e DAO também. O resultado da criação de todos os pacotes na estrutu-
ra do projeto é exibido na figura 3.6.
capítulo 3 • 61
Figura 3.6 – Estrutura do projeto com os pacotes de código-fonte criados.
Para a criação de classes nas camadas modelo e DAO, clicar com o botão
direito no pacote em questão e selecionar “Novo” e depois “Classe Java”. Para
a criação de servlets na camada controle, selecionar “Novo” e depois “Servlet”.
Neste exemplo será feito um cadastro de clientes simples, mas sem detalhes
da persistência de dados, que é tema do capítulo 4.
Inicialmente, é essencial a criação do modelo do sistema, que são as classes
que modelam a lógica da aplicação. Neste sistema, a lógica é dada pelo diagra-
ma de classes apresentado na figura 3.7.
Figura 3.7 – Classe modelo do projeto.
Por se tratar de um projeto didático e simples, o modelo conterá apenas

uma classe. Na figura 3.7 é mostrada a classe Cliente e seus atributos para que
sirva de base à construção da classe propriamente dita (código) no projeto.
62 • capítulo 3
Na figura 3.8 é exibida a tela de criação da classe e a estrutura do projeto
com a camada de modelo selecionada.
Figura 3.8 – Criação da classe de modelo no projeto.
A listagem 3.4 exibe o código completo da classe “Cliente.java”.
package br.com.alunosa.modelo;
public class Cliente {
private String documento;

private String nome;
private String endereco;
private String telefone;
public String getDocumento() {

return documento;
}
public void setDocumento(String documento) {

this.documento = documento;
}
public String getNome() {

return nome;
capítulo 3 • 63
}
public void setNome(String nome) {

this.nome = nome;
}
public String getEndereco() {

return endereco;
}
public void setEndereco(String endereco) {

this.endereco = endereco;
}
public String getTelefone() {

return telefone;
}
public void setTelefone(String telefone) {

this.telefone = telefone;
}
}
Listagem 3.4 – Código completo da classe “Cliente.java”.
Nota-se no início do código da classe na Listagem 18 que o pacote ao qual

pertence à classe é definido, indicando que esta classe faz parte da camada de
modelo da aplicação.
No próximo passo, a página JSP é criada. Esta página contém o formulário
para introdução dos dados do cliente. A página JSP faz parte da camada visão e
é alocada na pasta “Páginas Web” do projeto.
Ao criar um projeto com o NetBeans, uma página JSP é criada automatica-
mente: “index.jsp”. Esta página será utilizada para o cadastro do cliente e seu
código completo é exibido na listagem 2.5.
<!DOCTYPE html>
64 • capítulo 3
<html>
<head>
<title>Cadastrar Cliente</title>
</head>
<body>
<h1>Cadastrar Cliente</h1>
<form method="post" action="SalvarCliente">
<label>Documento: </label>
<input type="text" name="documento"/>
<br/>
<label>Nome: </label>
<input type="text" name="nome"/>
<br/>
<label>Endereço: </label>
<input type="text" name="endereco"/>
<br/>
<label>Telefone: </label>
<input type="text" name="telefone"/>
<br/>
<input type="submit" value="Salvar"/>
</form>
</body>
</html>
A figura 3.9 exibe a página JSP rodando no navegador, quando executado o

servidor Glassfish pelo NetBeans.
Figura 3.9 – Página “index.jsp” no navegador.
capítulo 3 • 65
Como pode-se observar na Listagem 19, a ação do formulário envia os dados
via POST para o servlet “SalvarCliente”. Antes da criação do servlet, é necessário
criar a classe DAO para o cliente.
Os DAOs são tema para o próximo capítulo, portanto, criar a classe
“ClienteDAO” e deixá-la vazia para que possamos ver a atuação do modelo MVC
no projeto, mas sem detalhar a persistência dos dados. O código da classe DAO
é exibido na listagem 3.6.
package br.com.alunosa.dao;
import br.com.alunosa.modelo.Cliente;
public class ClienteDAO {
public boolean salvar (Cliente c) {

/* Detalhes da persistência
do objeto no banco de dados */
return true;
}
}
Listagem 3.6 – Código completo da classe “ClienteDAO”.
Após a criação do DAO e do modelo, cria-se o servlet da camada de controle.

O código do servlet é exibido na listagem 3.7 e explicado posteriormente.
// MARCAÇÃO 1
package br.com.alunosa.controle;
// MARCAÇÃO 2
import br.com.alunosa.dao.ClienteDAO;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
66 • capítulo 3
import javax.servlet.http.HttpServletResponse;
public class SalvarCliente extends HttpServlet {
protected void processRequest(

HttpServletRequest request,
response.setContentType
("text/html;charset=UTF-8");
try (PrintWriter out =
response.getWriter()) {
// MARCAÇÃO 3
String documento =
request.getParameter("documento");
String nome =
request.getParameter("nome");
String endereco =
request.getParameter("endereco");
String telefone =
request.getParameter("telefone");
// MARCAÇÃO 4
Cliente cliente = new Cliente();
// MARCAÇÃO 5
cliente.setDocumento(documento);
cliente.setNome(nome);
cliente.setEndereco(endereco);
cliente.setTelefone(telefone);
// MARCAÇÃO 6
ClienteDAO dao = new ClienteDAO();
// MARCAÇÃO 7
dao.salvar(cliente);
// MARCAÇÃO 8
capítulo 3 • 67
response.sendRedirect("index.jsp");
}
}
…
}
Listagem 3.7 – Código completo do servlet “SalvarCliente”.
Para explicar o código do servlet são utilizadas as marcações no código:

• Marcação 1: definição do pacote ao qual a classe pertence;
• Marcação 2: importações de classes de diferentes pacotes, atentar para as
duas classes que estão sendo importadas “Cliente” e “ClienteDAO”, pois ambas
são utilizadas no servlet;
• Marcação 3: o servlet recupera as informações advindas do formulário da
página JSP e atribuindo-as a variáveis do tipo String;
• Marcação 4: cria-se um objeto da classe “Cliente” da camada de modelo
do sistema;
• Marcação 5: atribui os dados do formulário no objeto “cliente” para que
este possa ser persistido no banco de dados;
• Marcação 6: um objeto da classe DAO é criado, para que se possa acessar
os métodos para manipulação dos dados de cliente;
• Marcação 7: o método “salvar” da classe DAO é invocado e recebe como
parâmetro o cliente a ser salvo no banco de dados;
• Marcação 8: o servlet redireciona o usuário para a página inicial do projeto.
Este exemplo apresentado aqui de forma didática e simples utiliza uma es-
trutura de projeto compatível com MVC e que é muito utilizada em desenvolvi-
mento de sistemas web.
ATIVIDADES
01. Sobre o gerenciamento de sessões com Java, explique o porquê de se utilizar um tempo
máximo de inatividade para que a sessão continue válida.
02. Sobre o desenvolvimento de sistemas utilizando o modelo MVC, cite algumas vantagens
de se separar a visão da lógica de negócio do sistema.
68 • capítulo 3
REFLEXÃO
Com os conhecimentos adquiridos neste capítulo é possível o desenvolvimento de sistemas
que seguem os padrões e técnicas adotados pelo mercado. Foi vista a utilização de sessões
para gerenciamento de login de usuários em um sistema web, embora a utilização deste
recurso vá muito além do exemplo dado, podendo ser utilizado em diversas soluções para
sistemas na internet. O modelo MVC, adotado como padrão para o desenvolvimento de apli-
cações na web, faz parte do dia-a-dia do programador do lado servidor em sistemas web e o
conhecimento de como é feita a separação de um sistema em camadas é imprescindível para
qualquer desenvolvedor que siga modelos e padrões adotados pelo mercado.
LEITURA
Um tutorial bem didático sobre o porquê do surgimento e também sobre desenvolvimento de
aplicações com MVC II é disponibilizado pela Oracle. Escrito por Burns (2014), fica dispo-
nível online e além de conter detalhes de implementação, alguns conceitos são muito bem
explicados neste texto.
BURNS, Ed. Why Another MVC? 2014. Disponível em: <http://www.oracle.com/tech-
network/articles/java/mvc-2280472.html>. Acesso em: 15 mar. 2016.
BASHAM, Bryan; SIERRA, Kathy; BATES, Bert. Use a cabeça! Servlets & JSP. Rio de Janeiro: Alta
Books, 2010. (Use a cabeça!).
BURNS, Ed. Why Another MVC? 2014. Disponível em: <http://www.oracle.com/technetwork/
articles/java/mvc-2280472.html>. Acesso em: 15 mar. 2016.
ECKSTEIN, Robert. Java SE Application Design With MVC. 2007. Disponível em: <http://www.
oracle.com/technetwork/articles/javase/index-142890.html>. Acesso em: 15 mar. 2016.
JAVAPOINT. Model 1 and Model 2 (MVC) Architecture. Disponível em: <http://www.javatpoint.com/
model-1-and-model-2-mvc-architecture>. Acesso em: 18 mar. 2016.
MEDEIROS, Higor. Padrões de Projetos: Introdução aos Padrões Front Controller e Command.
Disponível em: <http://www.devmedia.com.br/padroes-de-projetos-introducao-aos-padroes-front-
controller-e-command/30644>. Acesso em: 15 mar. 2016.
capítulo 3 • 69
70 • capítulo 3
4
Modelagem
Comportamental e
JPA
4. Modelagem comportamental e JPA
A linguagem Java é muito robusta e cheia de recursos. Dois importantes são
apresentados neste capítulo: tipos genéricos e anotações. Estes recursos são
utilizados para modelar o comportamento do código-fonte para que se possa
tornar o desenvolvimento mais produtivo e organizado.
A JPA é uma API de persistência que pode trabalhar com diversos sistemas
de ORM, que por sua vez são compatíveis com diversos SGBDs relacionais. Isto
torna o desenvolvimento do sistema mais generalizado, não necessitando de
grandes alterações no código caso haja uma troca de tecnologia de persistên-
cia de dados, além de facilitar e muito a configuração e o mapeamento entre o
mundo orientado a objeto e o mundo relacional dos bancos de dados.
OBJETIVOS
Neste capítulo o aluno conhecerá o que são e como utilizar os tipos genéricos em listas e
conhecerá também as anotações e como utilizá-las em classes, métodos e atributos.
O tema ORM também é abordado, passando ao aluno conceitos necessários para que se
possa, posteriormente, utilizar na prática a JPA com um estudo de caso.
4.1 Tipos genéricos
De acordo com Deitel e Deitel (2010) a maior motivação para a definição de classes
e métodos genéricos em Java é a grande variação de tipos ao se executar métodos e a
sobrecarga utilizando diferentes métodos para executar exatamente a mesma ope-
ração, mas em tipos diferentes, principalmente em se tratando de listas e vetores.
Existem também as coleções genéricas, que são listas implementadas para
trabalhar com qualquer tipo de objeto, livrando o programador da implemen-
tação de listas específicas para certos tipos de objetos que são trabalhados no
sistema (DEITEL; DEITEL, 2010).
Geralmente, para listas em aplicações Java utiliza-se a interface “List”, que
possui diversas implementações. Cada implementação gerencia a lista de um
modo diferente, completamente transparente para o usuário, mas os métodos
possuem o mesmo nome e são genéricos, em outras palavras, podem manipu-
lar qualquer tipo de objeto.
72 • capítulo 4
A utilização destas listas é apresentada em um programa na listagem 4.1.
public static void main(String[] args) {
// MARCAÇÃO 1
List<String> lista;
// MARCAÇÃO 2
lista = new ArrayList<>();
// MARCAÇÃO 3
lista.add("Olá ");
lista.add("Mundo!");
// MARCAÇÃO 4
for(String s:lista)
System.out.print(s);
}
Saída:
Olá Mundo!
Listagem 4.1 – Utilização de uma lista genérica.
Para melhor explicar o código da listagem 4.1, têm-se as marcações:

• Marcação 1: declaração de uma lista de Strings utilizando a interface
“List” (java.util.List);
• Marcação 2: instanciando a lista utilizando a implementação “ArrayList”
(poderia ser outra implementação de lista);
• Marcação 3: adicionando itens à lista, neste caso são adicionadas duas
Strings, pois a lista foi definida para receber objetos deste tipo;
• Marcação 4: estrutura de repetição que imprime os valores da lis-
ta concatenados.
Observa-se no exemplo apresentado na listagem 4.1 que nenhuma imple-

mentação de lista precisou ser programada, a mesma utilização é feita para ou-
tros tipos de classes apenas substituindo <String> por outra classe.
capítulo 4 • 73
Os tipos genéricos são muito utilizados por APIs e é necessário que se sai-
ba como utilizá-los devido a alguns retornos de métodos de manipulação de
bancos de dados serem genéricos. No decorrer dos demais exemplos diferentes
utilizações de tipos genéricos são apresentadas.
4.2 Anotações em Java
A necessidade da criação das anotações (annotations em inglês) surgiu quan-

do a configuração de frameworks utilizados em desenvolvimento de sistemas
estavam se tornando muito complexas e extensas, gerando com isto muitos ar-
quivos XML (LANHELLAS, 2015).
Ao anotar o código Java, o compilador é capaz de executar tarefas em tempo
de execução diferenciadas e, dependendo da anotação que for utilizada, econo-
miza-se grande quantidade de configuração em arquivos XML.
Um exemplo recorrente de anotação em Java é: @Override. Esta anotação
indica que um método está sobrepondo o mesmo método advindo de uma su-
per classe (classe pai na herança) ou de uma interface.
Para anotas um código Java, a sua marcação (com a @), deve preceder a clas-
se, atributo ou método para qual vai ser aplicada a transformação. Um exemplo
de anotação é apresentado na listagem 4.2.
public class PessoaFisica extends Cliente {
private String cpf;
@Override
public void imprimirDocumentacao() {
System.out.println(this.cpf);
}
}
Listagem 4.2 – Exemplo básico de anotação em Java.
Nota-se que o método “imprimirDocumentacao” deve existir na clas-

se “Cliente” e está sendo reescrito na classe “PessoaFisica” provavelmente
por pessoas físicas terem uma particularidade no modo de impressão de sua
74 • capítulo 4
documentação. Para informar ao compilador que se trata de um método que
está sobrescrevendo outro já existente, é utilizada a anotação “@Override”.
CURIOSIDADE
É possível criar suas próprias anotações. Para isto, é necessário algum conhecimento da API
Reflection e de anotações Java. A real necessidade de se criar anotações também é fator
importante para se investir tempo nesta solução.
As utilizações de anotações variam muito, mas a maioria destas é na utiliza-

ção de frameworks. Um dos frameworks que mais necessitam de anotações é
o JPA (Java Persistence API) que ainda será tema deste capítulo. Outras utiliza-
ções muito recorrentes são os web services, tema do quinto capítulo deste livro.
4.3 Java Enterprise Edition (JEE)
Ao contrário do que pode parecer à primeira vista, o Java Enterprise Edition é

uma especificação, em outras palavras, é um texto enorme em PDF que contém
informações detalhadas de como se deve utilizar os recursos não funcionais ao
se desenvolver sistemas para a web (CAELUM, 2016).
CURIOSIDADE
Em desenvolvimento de software, existem os requisitos funcionais e não funcionais.
Os requisitos funcionais são aqueles que fazem parte da sua aplicação, como um cadas-
tro de clientes, a geração de um relatório, entre outros.
Os requisitos não funcionais fazem parte da estrutura utilizada para o desenvolvimento,
como o acesso ao banco de dados, o gerenciamento das sessões, gerenciamento de requi-
sições HTTP, entre outros.
Quando se utiliza as APIs do Java EE, são as implementações que seguem a

especificação que são utilizadas e não o Java EE em si.
Dentre as muitas especificações do Java EE algumas delas são:
• JavaServer pages (JSP);
• Java Servlets;
capítulo 4 • 75
• JavaServer Faces (JSF);
• Enterprise Java Beans (EJB);
• Java Persistence API (JPA);
• Java Message Service (JMS);
• Java Management Extensions (JMX);.
Algumas das especificações do Java EE são abordadas neste livro e a pró-

xima é a JPA, portanto, estão prontos para desenvolver um sistema web de
ponta-a-ponta?
4.4 Object-Relational Mapping (ORM)
A grande maioria dos bancos de dados utilizados em sistemas de informação

são relacionais por terem caráter generalista, ou seja, resolverem quase todos
os problemas quanto à persistência dos dados.
As aplicações geralmente não seguem a mesma lógica, sendo desenvolvidas
seguindo outro paradigma, o orientado a objetos.
Apesar de existirem bancos de dados não relacionais, a lógica relacional
para a persistência dos dados é muito sólida e versátil, o que o torna um padrão
no desenvolvimento de sistemas.
Mas se o sistema é desenvolvido seguindo uma lógica diferente daquela se-
guida pelo armazenamento dos dados, como é feito para um objeto se transfor-
mar em um registro de tabela e vice-versa?
Outro problema identificado é a diferença entre as linguagens SQL que
existem entre diferentes SGBDs, o que é solucionado com o uso de frameworks
ORM (CAELUM, 2016).
A transformação deve ser programada para que possa armazenar e con-
sultar os dados mesmo trabalhando com diferentes paradigmas, porém, esta
programação necessita de muito esforço do programador, além de ser difícil
torná-la uma solução generalizada.
Os sistemas chamados ORM (Object-Relational Mapping ou em português
Mapeamento Objeto-Relacional) são soluções generalizadas para este tipo
de problema.
Resumindo, a função dos ORMs é gerar código SQL em tempo de execução
levando em consideração o objeto em questão e seu mapeamento no banco
de dados.
76 • capítulo 4
O mapeamento é feito para as classes do modelo do projeto e, se correta-
mente mapeadas, a manipulação dos dados fica transparente para o desenvol-
vedor (FARIA; NORMANDES JUNIOR, 2015).
Um diagrama do funcionamento dos ORMs é exibido na figura 4.1.
Figura 4.1 – Diagrama do funcionamento do ORM.
Existem vantagens e desvantagens em seu uso. Como vantagens, pode-

se citar:
• Maior produtividade;
• Melhor organização do código;
• Menor quantidade de código a ser desenvolvido;
• Maior facilidade de crescimento do projeto.
Como desvantagem principal tem-se a curva de aprendizado muito alta. Em

outras palavras, é difícil aprender a mapear corretamente todos os tipos de re-
lacionamentos e dados utilizados em um sistema mais complexo.
Alguns dos sistemas ORM mais utilizados são:
• EclipseLink;
• Hibernate;
• OpenJPA;
capítulo 4 • 77
• Alchemy;
• ADO.NET;
• OJB;
• NHibernate;
• Django.
Cada sistema ORM é utilizado na tecnologia para a qual foi desenvolvido.

No caso da tecnologia Java, o mais utilizado é o Hibernate.
Antigamente, o mapeamento das classes com o banco de dados pelo
Hibernate era feito por meio de arquivos XML. Porém, hoje em dia, a JPA é uti-
lizada para fazer este mapeamento por meio de anotações.
Mais detalhes de como é feito o mapeamento das classes para utilização do
Hibernate com JPA são dados a seguir.
4.5 Java Persistence API (JPA)
O mapeamento no uso dos ORMs é parte fundamental, pois é este que garante
o bom funcionamento do sistema. Se uma camada de modelo de um sistema é
incorretamente mapeada, o sistema não funcionará de acordo.
O JPA é utilizado para fazer este mapeamento de forma generalizada para
diversos ORMs que suportam a especificação. Deste modo, seria simples ini-
ciar um projeto utilizando Hibernate e trocar o sistema de ORM para outro,
pois as anotações, que são parte vital da configuração do sistema, continuarão
em pleno funcionamento.
ATENÇÃO
É comum desenvolvedores inexperientes acreditarem que não é necessário conhecimento
em sistemas de bancos de dados para se utilizar ORM. Na verdade, o conhecimento deve ser
profundo, pois se trata de um mapeamento que não é trivial de ser realizado.
78 • capítulo 4
O JPA utiliza-se de anotações nas classes para que se identifique qual o
comportamento desejado para os atributos em relação ao banco de dados
da aplicação.
Algumas das anotações mais utilizadas do JPA são:
• @Entity: Define que uma classe é uma entidade (tabela);
• @Id: Define que um atributo identifica unicamente um registro na enti-
dade (chave primária);
• @Column: Identifica um atributo como sendo uma coluna na entidade;
• @Transient: Identifica que um atributo não é persistido em banco
de dados.
Em algumas anotações é possível definir propriedades. Um exemplo seria

se uma classe fosse marcada como entidade e a tabela no banco de dados para
qual a classe está sendo mapeada possui um nome diferente do nome da clas-
se. Neste caso é necessário definir na anotação o nome da tabela.
Para os atributos, não é necessário que sejam marcados como colunas se
o nome da coluna for o mesmo do atributo. Se forem diferentes, é necessário
que se marque além de definir o nome da coluna a qual o atributo se refere no
banco de dados.
A listagem 4.3 apresenta uma classe Carro anotada para ser persistida na ta-
bela “registro_carros” do banco de dados. A figura 4.2 exibe a modelagem física
da tabela no banco de dados MySQL.
Figura 4.2 – Modelo da tabela “registro_carros”.
capítulo 4 • 79
@Entity
@Table(name = "registro_carros")
public class Carro implements Serializable {
@Id
private String placa;
private String modelo;
@Column(name = "ano_fabricacao")
private int ano;
Listagem 4.3 – Classe carro anotada com JPA.
Ao analisar o código-fonte da listagem 4.3 observa-se que a classe está sen-

do anotada como entidade e que também possui uma anotação @Table. Esta
anotação possui uma propriedade que estabelece o nome da tabela na qual os
objetos da classe “Carro” serão armazenados.
No primeiro atributo da classe a anotação indica que esta é chave primária
na entidade. O nome não precisou ser definido pois na tabela o nome da coluna
é o mesmo do atributo da classe, portanto, o ORM faz essa associação.
O atributo “modelo” não precisou ser anotado, pois não tem papel diferen-
ciado na entidade e seu nome é o mesmo tanto na classe quanto na tabela.
No atributo “ano” foi necessário definir o nome da coluna a qual ele se refe-
re no banco de dados, pois não é possível identificar automaticamente quando
o nome do atributo e da coluna na tabela são diferentes.
Os relacionamentos entre as tabelas também devem ser mapeados para que
a camada de persistência trabalhe de maneira independente. Este mapeamen-
to é feito utilizando os quatro tipos de cardinalidade utilizados em bancos de
dados relacionais:
• @OneToOne: Relacionamento entre as entidades de um para um;
• @OneToMany: Relacionamento de um para muitos entre as entidades;
• @ManyToOne: Relacionamento de muitos para um entre as
duas entidades;
• @ManyToMany: Relacionamento de muitos para muitos entre duas enti-
dades relacionadas.
80 • capítulo 4
O mapeamento de relacionamentos vem acrescido de anotações como @
JoinTable ou @JoinColumn, que determinam propriedades sobre a chave es-
trangeira utilizada no relacionamento. Geralmente se faz a anotação em am-
bos os lados do relacionamento, como exemplificado nas listagens 4.4 e 4.5.
A figura 4.3 exibe o modelo das entidades “Funcionário” e “Setor” relacionadas.
Figura 4.3 – Modelo das tabelas “funcionario” e “setor”.
@Entity
public class Funcionario implements Serializable {
@Id
private int codigo;
@Temporal(TemporalType.DATE)
@Column(name = "data_contrato")
private Date dataContrato;
@ManyToOne
@JoinColumn(name = "Setor_id")
private Setor setor;
Listagem 4.4 – Classe “Funcionario” anotada com JPA.
Nota-se que na listagem 4.4 o atributo do tipo “Date” deve ser anotado de
modo diferente, inclusive informando qual o tipo de dado que será manipulado.
Na junção feita pelo relacionamento, é indicado que podem existir muitos
funcionários para um só setor, portanto, a coluna utilizada para isto é a chave
estrangeira “Setor_id”.
capítulo 4 • 81
@Entity
public class Setor implements Serializable {
@Id
private int id;
private String sigla;
@OneToMany(mappedBy = "setor",
targetEntity = Funcionario.class)
private List<Funcionario> funcionarios;
Listagem 4.5 – Classe “Setor” anotada com JPA.
Este relacionamento aqui apresentado é mapeado dos dois lados, ou seja,

para um objeto do tipo setor, têm-se uma lista de funcionários. A propriedade
“mappedBy” da listagem 4.5 indica qual atributo da classe “Funcionario” está
sendo utilizado para mapear o relacionamento.
CURIOSIDADE
Para a utilização de chaves primárias compostas a complexidade do mapeamento pode
aumentar, sendo necessária a utilização de uma classe apenas para implementar a cha-
ve primária.
Nota-se também que as classes, para serem utilizadas com ORM devem im-
plementar a interface “Serializable”, que permite a transmissão de objetos des-
construindo e reconstruindo os dados em diferentes locais.
A seguir é apresentada a continuação do exemplo de cadastro de clientes
apresentado no capítulo anterior, mas com o desenvolvimento da camada
de persistência.
82 • capítulo 4
4.6 JPA na prática
Relembrando a aplicação do capítulo anterior, que foi utilizada para demons-

trar o uso do modelo MVC para o desenvolvimento de sistemas web, nesta se-
ção a camada de persistência da aplicação é desenvolvida.
A classe cliente do modelo não foi anotada, portanto, em um primeiro mo-
mento é feita a anotação desta classe. Esta anotação é simples, pois se trata de
apenas uma entidade, sem relacionamentos e bem-comportada. A listagem 4.6
exibe o código da classe já anotada.
package br.com.alunosa.modelo;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Cliente implements Serializable {
@Id
private String documento;
private String endereco;
private String telefone;
public String getDocumento() {

return documento;
}
public void setDocumento(String documento) {

this.documento = documento;
}
public String getNome() {

return nome;
}
public void setNome(String nome) {

this.nome = nome;
capítulo 4 • 83
}
public String getEndereco() {

return endereco;
}
public void setEndereco(String endereco) {

this.endereco = endereco;
}
public String getTelefone() {

return telefone;
}
public void setTelefone(String telefone) {

this.telefone = telefone;
}
}
Listagem 4.6 – Código completo da classe “Cliente.java” antada com JPA.
Para que a aplicação possa se conectar com o banco de dados, é necessá-

rio ter um arquivo de configuração chamado “persistence.xml”. Este arquivo
configura uma unidade de persistência (persistence unit) e para criá-la no pro-
jeto é só clicar com o botão direito no projeto e selecionar “Outros”. Uma jane-
la semelhante à da figura 4.4 é exibida. Nesta janela, selecionar na esquerda
“Persistência” e na direita “Unidade de persistência”.
84 • capítulo 4
Figura 4.4 – Janela de seleção para criação da unidade de persistência.
Após feita a seleção, clicar em “Avançar” e outra tela irá aparecer (figura 4.5).
Nesta nova tela são definidos:
• O nome da unidade de persistência (entenda-se como uma conexão com
um banco de dados);
• A biblioteca ORM que será utilizada;
• A origem dos dados (a conexão com o banco de dados propriamente dita);
• Se utilizará transações em nível de aplicação;
• Se a tabela será gerada automaticamente seguindo a anotação efetuada.
capítulo 4 • 85
Figura 4.5 – Janela de criação da unidade de persistência e seus dados.
O primeiro passo na tela exibida na figura 4.4 é selecionar a origem dos

dados. Ao clicar no campo, selecionar “Nova fonte de dados...” e depois sele-
cionar a conexão criada no capítulo anterior. Em nome JNDI digitar apenas
“bdclientes”.
Os demais dados para a criação da unidade de persistência devem ser man-
tidos iguais aos apresentados na figura 4.5. Após isto, clicar em “Finalizar” e a
unidade de persistência estará criada.
Ao abrir o arquivo “persistence.xml” pode-se verificar todas as proprieda-
des do arquivo de configuração. O NetBeans possui também um editor visual
para este arquivo, abstraindo o desenvolvedor de lidar diretamente com o códi-
go XML. As propriedades da configuração podem ser alteradas a qualquer mo-
mento apenas editando este arquivo.
Uma curiosidade é que o próprio NetBeans insere no projeto as bibliotecas
do Hibernate, como exibido na figura 4.6.
86 • capítulo 4
Figura 4.6 – Bibliotecas do Hibernate no projeto web.
O próximo passo deste exemplo é programar a classe DAO para que a persis-
tência do objeto ocorra no banco de dados. O primeiro método a ser programa-
do é o “salvar”.
O código-fonte do método “salvar” é exibido na listagem 4.7.
package br.com.alunosa.dao;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;
public class ClienteDAO {
public boolean salvar(Cliente c) {
// MARCAÇÃO 1
EntityManagerFactory factory =
Persistence.createEntityManagerFactory("banco");
// MARCAÇÃO 2
EntityManager em = factory.createEntityManager();
capítulo 4 • 87
try {
// MARCAÇÃO 3
em.getTransaction().begin();
// MARCAÇÃO 4
em.persist(c);
// MARCAÇÃO 5
em.getTransaction().commit();
// MARCAÇÃO 6
em.close();
factory.close();
return true;
} catch (PersistenceException e) {
// MARCAÇÃO 7
e.getMessage();
em.close();
factory.close();
return false;
}
}
}
Listagem 4.7 – Parte principal do método “consultar” da classe “ClienteDAO”.
A explicação do código da listagem 4.7 é feito com base nas marcações:

• Marcação 1: Cria uma fábrica de gerenciador de entidades (entity mana-
ger) que será utilizado para gerar gerenciadores da unidade de persistência in-
formada, no caso, “banco”.
• Marcação 2: Cria o gerenciador de entidades propriamente dito, que é uti-
lizado para a manipulação dos dados;
• Marcação 3: Inicia a transação do banco de dados;
• Marcação 4: Salva o objeto cliente no banco de dados, neste momento o
ORM o transforma em um registro;
88 • capítulo 4
• Marcação 5: Executa um commit gravando de vez o objeto no banco;
• Marcação 6: Fecha o gerenciador de entidades e a fábrica de gerenciado-
res, após o método retorna verdadeiro;
• Marcação 7: Código que é executado caso ocorra um erro na persistência
do objeto, após retorna falso.
O próximo método a ser implementado é a consulta de um cliente por meio

de seu documento. A parte mais importante do código deste método é apresen-
tado na listagem 4.8.
public Cliente consultar(String documento) {

…
Cliente c = em.find(Cliente.class, documento);
em.close();
factory.close();
return c;
…
Na listagem 4.8 pode-se observar o uso do método “find”. Este método é

utilizado para recuperar objetos por meio de sua chave primária. Caso o objeto
não seja encontrado, o método retorna null.
O próximo método é a consulta da lista de clientes. Esta consulta utiliza-se
da linguagem JPQL (Java Persistence Query language). A listagem 4.9 exibe a
parte mais importante do código do método “consultarLista”.
LEITURA
Uma breve explicação sobre JPQL é dada por Sakurai (2011) em um artigo disponível
na internet.
capítulo 4 • 89
public List<Cliente> consultarLista() {
…
Query q = em.createQuery
("SELECT c FROM Cliente AS c");
List<Cliente> clientes = q.getResultList();
em.close();
factory.close();
return clientes;
…
Listagem 4.9 – Parte principal do método “consultarLista” da classe “ClienteDAO”.
Observa-se na listagem 4.9 que uma query é criada com um comando em

JPQL para que retorne os clientes, mas tratando cliente como objeto. Após isto,
uma lista é preenchida com os clientes retornados da consulta e no final, o mé-
todo retorna a lista. Caso não sejam encontrados resultados, a lista retorna vazia.
ATIVIDADES
01. Quanto ao reuso de software, explique o porquê de se desenvolver e utilizar lis-
tas genéricas.
02. Antigamente o mapeamento era feito em arquivos XML, hoje em dia são utilizadas ano-
tações. Cite algumas vantagens de se utilizar a abordagem contemporânea.
03. Apesar de parecida com a linguagem SQL, a linguagem utilizada no JPA é outra. Qual é
esta linguagem e o que significa sua sigla?
REFLEXÃO
Neste capítulo foram abordados temas importantes para o desenvolvimento de sistemas
web, pois são técnicas e ferramentas muito utilizadas no mercado. Estima-se que 99% das
aplicações de grande porte em Java, hoje em dia, sejam desenvolvidas utilizando a JPA, pois
90 • capítulo 4
se trata de um recurso indispensável para aumento da produtividade e torna a manutenção
do código menos trabalhosa.
A abordagem prática utilizada no capítulo dá um início muito importante ao aluno, que é a
transição do conceito para o uso de recursos em tecnologia, pois muitas vezes esta transição
não é feita de forma clara, prejudicando a correta aplicação dos conceitos em sistemas.
LEITURA
O livro de faria e Normandes Junior (2015) possui uma abordagem completa do uso do JPA
e é uma ótima referência para que se possa criar consultas e comandos em JPQL. Altamente
recomendado para quem quer seguir no desenvolvimento web utilizando a JPA.
FARIA, Thiago; NORMANDES JUNIOR,. JPA e Hibernate. [s.i]: Algaworks, 2015. 176 p.
CAELUM. Java para desenvolvimento web. Disponível em: <https://www.caelum.com.br/apostila-
java-web/>. Acesso em: 13 mar. 2016.
FARIA, Thiago; NORMANDES JUNIOR,. JPA e Hibernate. [s.i]: Algaworks, 2015. 176 p.
LANHELLAS, Ronaldo. Como criar Anotações em Java. 2015. Disponível em: <http://www.
devmedia.com.br/como-criar-anotacoes-em-java/32461>. Acesso em: 17 mar. 2016.
SAKURAI, Rafael Guimarães. JPA - Examinar a linguagem de consulta do Java Persistence API
(JPQL). 2011. Disponível em: <http://www.universidadejava.com.br/materiais/jpa-jpql/>. Acesso em:
15 mar. 2016.
capítulo 4 • 91
92 • capítulo 4
5
Objetos
Distribuídos, MDB e
Web Services
5. Objetos distribuídos, MDB e Web Services
Este é o último capítulo deste livro e aborda tecnologias mais avançadas para o
desenvolvimento de sistemas. Estas tecnologias são utilizadas em paradigmas
próprios de desenvolvimento de software e não são aplicáveis a todos os tipos
de sistemas a serem desenvolvidos.
O foco principal deste capítulo é a troca de mensagens entre aplicações ou
mesmo dentro da mesma aplicação. Para isto, uma breve explicação de tecno-
logias como MDB, JMS e EJB é dada no início.
O tema web services toma conta de grande parte do capítulo por se tratar
de uma tecnologia imprescindível para o desenvolvimento no lado servidor de
sistemas web, além de amplamente utilizada no mercado.
Uma introdução dos conceitos que cercam o mundo dos serviços web é
acompanhada de exemplos práticos de criação e consumo destes serviços no
lado servidor da aplicação.
A aplicação prática destes conceitos é essencial pois se tratam de conceitos que
não são fáceis de se utilizar na prática, embora o conceito não seja tão complexo.
Muitos serviços web são consumidos pelo lado cliente das aplicações, in-
clusive utilizando-se de tecnologias como AJAX, jQuery, entre outras, mas isto é
abordado na disciplina de programação cliente em sistemas web.
OBJETIVOS
Ao final deste capítulo o aluno conhecerá as tecnologias necessárias para se desenvolver
sistemas corporativos além de aprender a desenvolver e consumir web services, que são
parte essencial no desenvolvimento de sistemas web.
5.1 Objetos distribuídos e sistemas corporativos
Os sistemas corporativos visam a reutilização de componentes desenvolvidos

em diversos módulos, subsistemas ou até mesmo em outros sistemas em am-
biente completamente separado.
Ao utilizar a tecnologia Java para o desenvolvimento destes sistemas/com-
ponentes, existe a tecnologia EJB (Enterprise JavaBeans).
94 • capítulo 5
De acordo com Panda et al. (2014) o EJB serve como modelo para criação de
componentes de software que abstraem diversos problemas comuns em desen-
volvimento do lado servidor das aplicações.
O uso de EJB é encorajado para o desenvolvimento de aplicações distribuídas
por uma série de motivos, alguns deles, de acordo com Panda et al. (2014), são:
• Facilidade de uso;
• Muitas soluções já estão prontas e completas;
• Padrão aberto do Java EE;
• Suporte amplo de diversas entidades;
• Suporte robusto a clustering, balanceamento de carga e controle e trata-
mento de erros;
• Performance e escalabilidade.
Os EJBs são classificados em dois diferentes tipos:

• Session beans;
• Message-driven beans;
Os session beans são invocados por um cliente para executar operações como
a checagem de dados sobre cartão de crédito de um usuário (PANDA et al., 2014).
As session beans podem ser de dois tipos, de acordo com Sierra e Bates (2003):
• Stateful;
• Stateless.
O EJB marcado como stateful salva o estado do bean (componente) entre as

invocações de um único cliente, sem a necessidade de escrever código adicional.
LEITURA
O livro da série use a cabeça sobre EJB, escrito por Sierra e Bates (2003), traz uma abor-
dagem didática sobre o uso de EJBs, oferecendo também exemplos práticos. Sua leitura é
altamente recomendada para quem pretende desenvolver sistemas corporativos utilizando a
tecnologia Java.
Os stateless não armazenam estado dos componentes, sendo utilizados

para tarefas que sejam pontuais e não dependam de utilizações anteriores.
capítulo 5 • 95
Para a configuração de EJBs são utilizadas anotações, assim como em mui-
tas outras tecnologias baseadas na linguagem Java. Um exemplo básico de EJB
é apresentado na listagem 5.1.
import javax.ejb.Stateless;
@Stateless
public class OlaUsuarioBean implements OlaUsuario {
public String FalarOla(String nome) {
return “Olá ” + nome + “!”;
}
}
Listagem 5.1 – Exemplo básico de EJB.
No exemplo da listagem 5.1 um EJA é criado para falar olá a um usuário cujo
nome é parâmetro do método, observe que este EJB é stateless, portanto não
guarda seu estado dentre as chamadas.
A figura 5.1, adaptada de Panda et al. (2014), demonstra como é simples se
construir um EJB, que tornará o objeto em questão distribuído para clientes
na rede.
Figura 5.1 – Esquema simples para a criação de um EJB, adaptado de Panda et al. (2014).
5.2 Comportamento assíncrono com MDB
Os Message-Driven Beans (MDB) são utilizados para a transmissão assíncrona

de mensagens entre aplicações Java EE. Geralmente, são listeners JMS (Java
Message Service) similares a um listener de eventos, mas que recebe uma men-
sagem JMS (ORACLE, 2016).
96 • capítulo 5
CONCEITO
Em termos simples, processamento assíncrono não deixa o sistema ou o usuário esperando
uma tarefa terminar para que se continue operando, a tarefa geralmente é executada em
outro thread. Um exemplo de processamento assíncrono é AJAX, abordado na disciplina de
programação cliente para sistemas web.
Os MDBs se assemelham às session beans em alguns aspectos, de acordo

com Oracle (2016). As características de um MDB são:
• São executados quando recebida uma única mensagem;
• São invocados assincronamente;
• São por padrão stateless;
• Entre outras.
Uma analogia feita por Panda et al. (2014) diz que o JMS é para mensagens
como o JDBC é para o banco de dados, sendo uma alternativa generalizada para
acesso a outras APIs específicas.
O conteúdo de uma mensagem JMS é apresentado na figura 5.2.
Figura 5.2 – Conteúdo de uma mensagem JMS, adaptado de Panda et al. (2014).
A utilização de mensagens e MDBs não se aplica a todos os casos. Esta pode-

rosa tecnologia é útil quando se necessita de processamento assíncrono.
capítulo 5 • 97
LEITURA
O livro de Panda et al. (2014) traz exemplos práticos de uso de MDB, com códigos de sim-
ples entendimento.
5.3 XML, Web Services e SOAP
As tecnologias XML (eXtensible Markup Language) e web services são comu-

mente encontradas trabalhando em conjunto. Isto se dá pois ambas tendem a
ser independentes de plataforma. Os web services, por sua característica de ser
hospedado na internet e consumido por aplicações internas ou externas, deve
ser independente de plataforma (SHKLAR; ROSEM, 2013).
CURIOSIDADE
Além do XML, o uso de JSON (JavaScript Simple Object Notation) também é comum em
web services, por se tratar de uma linguagem de descrição de objetos que também é inde-
pendente de plataforma.
Diferentemente da abordagem utilizada na disciplina de programação

cliente em sistemas web, onde o foco é o consumo dos web services pelo lado
cliente da aplicação, nesta disciplina a criação de web services no lado servidor
é o foco.
O protocolo SOAP (Simple Object Access Protocol) pode ser utilizado para se
fazer as chamadas remotas a serviços web espalhados pela internet. Geralmente,
para estas chamadas, se utiliza o protocolo HTTP (DEITEL; DEITEL, 2010).
As solicitações e respostas de web services são feitas em pacotes chamados
mensagens SOAP (escritas em XML), trazendo desta forma a característica do
web service ser independente de plataforma.
98 • capítulo 5
CURIOSIDADE
Uma arquitetura também muito utilizada para implementação de serviços web é a REST
(Representational State Transfer), que não é um padrão mas utiliza-se de padrões de desen-
volvimento web (DEITEL; DEITEL, 2010).
O cliente de um serviço web pode ser o lado cliente da aplicação ou o lado

servidor, dependendo de qual parte da aplicação necessita do recurso oferecido
pelo serviço.
A linguagem de descrição de web services WSDL (Web Service Description
Language) pode ser utilizada para criar uma referência de como o web service
deve ser utilizado e quais os seus parâmetros, para que assim o serviço desen-
volvido possa ser disponibilizado para a comunidade.
O serviço de diretório de web services UDDI (Universal Description,
Discovery and Integration) armazena dados dos web services e serve como base
de consulta para desenvolvedores. Antes de desenvolver um serviço, veja se o
mesmo já não está disponível para uso na internet (SHKLAR; ROSEN, 2003).
O exemplo e uso prático de web services deste livro utilizam o protocolo
SOAP e o NetBeans para facilitação na criação dos serviços.
5.4 Criação de web services anotados
Nesta seção é apresentado o uso do NetBeans para facilitar a criação de um web

service em Java. Este web service é uma classe que utiliza-se de anotações para
que se comporte como um web service.
Primeiramente, um novo projeto web é criado no NetBeans com as configu-
rações apresentadas na tabela 5.1.
NOME DO PROJETO WSTESTE

Servidor Glassfish
Versão do Java EE Java EE 5
Tabela 5.1 – Dados para criação do projeto web para criação de web service.
Após a criação do projeto, deve-se clicar com o botão direito no “Pacote

de Códigos-fonte”, selecionar “Novo” e depois “Outro”. Após esta opera-
ção, uma janela semelhante à da figura 5.3 irá aparecer na tela. Nesta janela,
capítulo 5 • 99
deve-se selecionar no lado esquerdo “Web Services” e após, no lado direito,
“Web Service”. Depois de selecionado, clicar em “Próximo”.
Figura 5.3 – janela de seleção para criação de web service no projeto web com NetBeans.
Na tela subsequente deve-se informar o nome do web service, assim como

definir um pacote para ele. Deixar as configurações desta tela iguais às exibidas
na figura 5.4 e clicar em “Finalizar”.
Figura 5.4 – Propriedades para a criação do web service.
100 • capítulo 5
O web service, neste momento, encontra-se criado no projeto. A figura 5.5
exibe a estrutura do projeto logo após a criação do web service.
Figura 5.5 – Estrutura do projeto WSTeste logo após a criação do web service.
A listagem 5.2 exibe o código-fonte da classe web service “ImprimirFrase”

que foi criada pelo NetBeans. Este código é gerado como um padrão e
pode ser alterado completamente para se criar web services com diferen-
tes funcionalidades.
É interessante notas que o NetBeans cria toda uma estrutura de como utili-
zar a classe como web service, facilitando muito o desenvolvimento e aumen-
tando a produtividade.
// Marcação 1
package br.com.alunosa;
// Marcação 2
import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.jws.WebParam;
// Marcação 3
@WebService(serviceName = "ImprimirFrase")
capítulo 5 • 101
public class ImprimirFrase {
// Marcação 4
@WebMethod(operationName = "hello")
//Marcação 5
public String hello(@WebParam(name = "name") String txt) {
// Marcação 6
return "Hello " + txt + " !";
}
}
Listagem 5.2 – Web service criado pelo NetBeans no projeto WSTeste.
A explicação do código da listagem 5.1 se dá por meio das seguintes

marcações:
• Marcação 1: definição do pacote no qual se encontra a classe do
web service;
• Marcação 2: classes das anotações que devem ser importadas pois o web
service faz uso de recursos oferecidos por estas classes;
• Marcação 3: anotação que define a classe como sendo um web service.
Define também o nome do web service, que não precisa necessariamente ser
o mesmo nome da classe, porém, se não for definido o nome, atribui-se como
padrão no nome da classe seguido da palavra Service;
• Marcação 4: anotação de define que um método pode ser chamado remo-
tamente. O nome da operação é definido também, mas não obrigatoriamente,
pois se não for feita a definição explícita, a operação utiliza o mesmo nome do
método em Java;
• Marcação 5: definição do método que será executado remotamente, ob-
serva-se que a passagem de parâmetro também ocorre de forma diferente, pois
o nome do parâmetro pode ser alterado para o uso do serviço;
• Marcação 6: código que é executado pelo web service que, neste caso, re-
torna uma frase concatenando a palavra “Hello” com o parâmetro recebido do
consumidor (quem irá acessar o web service).
102 • capítulo 5
Agora analisemos o web service criado para a aplicação WSTeste. Para aces-
sar o web service, clicar no botão “Executar Projeto” e o navegador abrirá a pági-
na inicial (index.jsp) criada automaticamente pelo NetBeans.
A partir da raiz do projeto, colocar o nome do web service para que se possa
acessar as informações. Se a configuração foi deixada a padrão, o endereço de
acesso é: http://localhost:8080/WSTeste/ImprimirFrase.
O resultado do acesso às informações do web service devem ser semelhan-
tes às da figura 5.6.
Nota-se que nas informações do web service no navegador existe um link.

Este link exibe a descrição completa do web service na linguagem WSDL e é
apresentada na figura 5.7.
capítulo 5 • 103
De posse da descrição do web service é possível disponibilizá-lo no diretório

UDDI, além de se ter uma completa noção do funcionamento e das variáveis
do serviço.
104 • capítulo 5
ATENÇÃO
Como a utilização de web services cresceu muito nos últimos anos, é necessária uma aten-
ção especial em métodos utilizados que garantam a segurança na utilização destes recursos
(NAGAPPAN; SKOCZYLAS; SRIGANESH, 2003).
5.5 Consumindo Web Service Java
O web service foi criado e pode ser acessado remotamente, isto já foi verificado
anteriormente. Porém, como utilizar a funcionalidade que é servida por ele é
tema desta seção.
Para criarmos um cliente para o web service, devemos clicar com o botão
direito no projeto, clicar em “Novo” e depois em “Outro”. A janela da figura 5.8
irá aparecer e então são selecionados na esquerda “Web Services” e na direita
“Cliente para web service”.
Figura 5.8 – Janela de seleção para criação de um cliente para web service.
capítulo 5 • 105
Após a seleção, clicar em “Próximo”. A tela mudará para uma semelhante à
da figura 5.9. Deixar selecionado em “Projeto” e clicar em “Procurar...”
Figura 5.9 – Tela de criação do cliente para web service sem os dados.
Quando o botão “Procurar...” é clicado, uma nova janela aparece (figura 5.9).
Nesta janela deve ser selecionado o web service do projeto para o qual quer se
criar um cliente.
Figura 5.10 – janela de seleção do web service para o qual se quer criar o cliente.
106 • capítulo 5
Após a seleção do web service, clicar em “OK”. Automaticamente o endereço
da descrição do web service (WSDL) é atribuído. Pode-se verificar na figura 5.11
as propriedades necessárias para a criação do cliente para o web service. Não se
pode esquecer de selecionar um pacote diferente daquele criado anteriormen-
te para evitar conflitos. Ao final, clicar em “Finalizar”.
Figura 5.11 – Tela de criação do cliente para web service com os dados preenchidos.
Uma grande alteração na estrutura do projeto é esperada quando se cria o

cliente para o web service, isto acontece pois muitas classes, interfaces e arqui-
vos de configuração são criados automaticamente pelo NetBeans.
A figura 5.12 exibe a estrutura do projeto após a criação do cliente para o
web service.
capítulo 5 • 107
Figura 5.12 – Estrutura do projeto após a criação do cliente para o web service
“ImprimirFrase”.
Neste momento o cliente para consumo do web service está criado, agora é
só utilizar o recurso programado. Neste exemplo, o recurso é consumido pela
própria aplicação por meio de uma página JSP.
Deve-se excluir a página “index.html” caso tenha sido automaticamente
criada pelo NetBeans e posteriormente criar uma página chamada “index.jsp”
na raiz da pasta “Páginas Web”.
A página JSP foi escolhida para consumir o web service, pois assim é pos-
sível mostrar o seu resultado na página, verificando se o seu funcionamento
está correto.
108 • capítulo 5
O código da página JSP utilizada para consumir o web service e exibir o seu
resultado é apresentado na listagem 5.13.

<%@page import=
"br.com.alunosa.cliente.ImprimirFrase_Service"%>
<%@page import=
"br.com.alunosa.cliente.ImprimirFrase"%>
<!DOCTYPE html>
<html>
<head>
<title>Consumindo Web Service</title>
</head>
<body>
<%
// MARCAÇÃO 2
ImprimirFrase_Service servico =
new ImprimirFrase_Service();
// MARCAÇÃO 3
ImprimirFrase atuacao =
servico.getImprimirFrasePort();
// MARCAÇÃO 4
String frase =
atuacao.hello("João Paulo");
%>
<h1><%=frase%></h1>
</body>
</html>
Listagem 5.4 – Código completo da página JSP (index.jsp) que consome o web service e
exibe o resultado.
capítulo 5 • 109
A explicação do código da listagem 5.4 por meio de suas marcações é:
• Marcação 1: neste trecho de código ocorre a importação das classes que
serão utilizadas para o consumo do web service;
• Marcação 2: esta linha de comando instancia um serviço da classe
“ImprimirFrase_Service”, que posteriormente é utilizado para retornar a porta
de conexão para que o web service seja consumido;
• Marcação 3: neste comando o serviço retorna uma porta de conexão com
o web service para que a interface “ImprimirFrase” possa chamar o método
“hello” que aceita chamada remota;
• Marcação 4: aqui o método “hello” é invocado e o parâmetro é passado
para que seja processado pelo web service e gere uma resposta que é atribuída
a uma variável do tipo String chamada “frase”;
• Marcação 5: neste momento o resultado do web service é apresentado ao
usuário que acessou a página JSP.
Para se executar o projeto e verificar se a aplicação está funcionando, deve-

se primeiramente executar a função “Clean” no projeto, assim se houver de-
ploys anteriores, estas são apagadas. Após, selecionar a opção “Build” para que
este seja recompilado. Estas opções são acessadas clicando com o botão direito
na raiz do projeto, na árvore da estrutura.
Após executados os passos, clicar em “Executar Projeto” (botão verde na parte
superior do NetBeans) e esperar o navegador abrir a página “index.jsp” criada.
Se a aplicação foi corretamente construída, o resultado é semelhante ao
apresentado na figura 5.13.
Figura 5.13 – Resultado do consumo do web service com o parâmetro “João Paulo” exibido
para o usuário por meio de uma página JSP.
110 • capítulo 5
Com este exemplo é encerrado o tema de web services e também este livro.
Lembre-se que é importante executar os exemplos apresentados e se possível
a partir deles construir aplicações cada vez mais complexas, o que é um ótimo
método de aprendizado, além de se adquirir experiência com o desenvolvimen-
to de sistemas web.
CURIOSIDADE
Muitos sistemas web disponibilizam serviços para que sejam consumidos por aplica-
ções que rodam em dispositivos móveis, deste modo, as funcionalidades não precisam
ser redesenvolvidas.
ATIVIDADES
01. Qual o componente utilizado para a criação de objetos distribuídos em sistemas corpo-
rativos utilizando a tecnologia Java?
02. Do que é constituído um web service em Java?
03. O NetBeans facilita o desenvolvimento de web services, assim como o consumo, inclu-
sive gerando o arquivo WDSL do web service construído. Qual o nome do repositório no qual
pode-se armazenar descrições de web services (WSDL) a fim de disponibilizá-lo para uso?
REFLEXÃO
Caro aluno,
Chegamos ao fim desta agradável disciplina. Eu digo agradável, pois par a maioria das
pessoas é muito mais interessante estudar algo concreto e que se pode utilizar diretamente
no trabalho ou no dia-a-dia, e este é o caso da programação para servidor em sistemas web.
Neste último capítulo foram abordados alguns temas mais avançados e muito interes-
santes, destaco entre eles os web services, que são uma realidade no desenvolvimento de
sistemas para web, inclusive muitos sistemas são desenvolvidos inteiramente em cima de
serviços, seguindo a arquitetura SOA (Service Oriented Architecture).
capítulo 5 • 111
Espero que o aproveitamento dos conceitos e práticas apresentados neste livro tenham
sido satisfatórios e principalmente, tenham incentivado o constante estudo que é necessário
para quem vai atuar na área de desenvolvimento de sistemas, pois bibliotecas, tecnologias e
procedimentos estão em constante atualização, e esta atualização é rápida!
LEITURA
Para complementar os estudos deste capítulo e de muitos outros, o livro de Deitel e Deitel
(2010) intitulado “Java: Como Programar” serve de referência para o desenvolvimento de
aplicações em Java. Mesmo sem ser focado em desenvolvimento para a internet, seu vasto
conteúdo (incluindo web services) oferece uma grande fonte de consulta para desenvolve-
dores Java.
Outra recomendação, para quem quer se aprofundar no tema EJB, é o livro da série Use
a Cabeça! Intitulado EJB e escrito por Sierra e Bates (2003) traz uma abordagem didática
para o uso desta tecnologia. Ainda não existe uma versão em português, mas para quem
entende um pouco de inglês vale a pena a leitura.
SIERRA, Kathy; BATES, Bert. Head First EJB. [s.i.]: O'reilly, 2003. 734 p.
NAGAPPAN, Ramesh; SKOCZYLAS, Robert; SRIGANESH, Rima Patel. Developing Java Web
Services. Indianapolis: John Wiley & Sons, 2003. 758 p.
ORACLE. The Java EE 6 Tutorial. Disponível em: <http://docs.oracle.com/javaee/6/tutorial/doc/
gipko.html>. Acesso em: 16 mar. 2016.
PANDA, Debu et al. EJB 3 in action. 2. ed. Shelter Island: Manning, 2014.
SHKLAR, Leon; ROSEN, Richard. Web Application Architecture: Principles, Protocols and Practices.
Chichester: John Wiley & Sons, 2003.
SIERRA, Kathy; BATES, Bert. Head First EJB. [s.i.]: O'reilly, 2003. 734 p.
112 • capítulo 5
ANOTAÇÕES
capítulo 5 • 113
ANOTAÇÕES
114 • capítulo 5
ANOTAÇÕES
capítulo 5 • 115
ANOTAÇÕES
116 • capítulo 5
ANOTAÇÕES
capítulo 5 • 117
ANOTAÇÕES
118 • capítulo 5
ANOTAÇÕES
capítulo 5 • 119
ANOTAÇÕES
120 • capítulo 5

Programacao Cliente Servidor PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programacao Cliente Servidor PDF

Uploaded by

Copyright:

Available Formats

PROGRAMAÇÃO SERVIDOR

Autor do original joão paulo casati

Projeto editorial roberto paes

Coordenação de produção paola gil de almeida, paula r. de a. machado e aline

Projeto gráfico paulo vitor bastos

Diagramação bfs media

Revisão linguística bfs media

Revisão de conteúdo eduardo luiz pareto

Imagem de capa timofeev vladimir | shutterstock.com

Dados Internacionais de Catalogação na Publicação (cip)

C334p Casati, João Paulo

1.Sites na web. 2. Sites da web - desenvolvimento. 3. Sites da web –

Diretoria de Ensino — Fábrica de Conhecimento

1. A Criação de Aplicativos para WEB 7

2. Tecnologias de Sistemas e Bancos de Dados 27

2.1 Servlets Java 28

3. Sessões e o Modelo MVC 51

3.1 Gerenciamento de sessão e login 52

4. Modelagem Comportamental e JPA 71

4.1 Tipos genéricos 72

5. Objetos Distribuídos, MDB e Web Services 93

5.1 Objetos distribuídos e sistemas corporativos 94

Programar em Java para desenvolver sistemas de informação não é uma ta-

TIPO BITS VALORES

Há uma recomendação para a utilização de tipos abstratos em programação

public static void main (String[] args) {

Listagem 1.1 – Uso de variáveis primitivas em Java.

A primeira tarefa para a criação de programas em Java é a criação de uma

Figura 1.1 – Classe Java representada pela UML.

public class Pessoa {

void andar(int metros) {

void andar(String frase) {

Listagem 1.2 – Código de uma classe em Java.

Os operadores lógicos são utilizados para a comparação entre variáveis e/ou

A listagem 1.3 traz exemplos de uso dos operadores apresentados na

public static void main(String []args) {

System.out.println(7 > 8);

String texto1 = "teste";

Listagem 1.3 – Operadores lógicos, comparativos e comparação de textos.

Ao analisar o código e a saída do programa da Listagem 3 pode-se entender

// do, while contando de 1 a 10

SAÍDA (para cada estrutura):

Listagem 1.4 – Estruturas de repetição do Java.

Finalizando esta revisão da sintaxe básica do Java, tem-se as estruturas con-

public static void main(String []args) {

int idade = 21;

if(idade >= 18) {

Listagem 1.5 – Estrutura condicional if, else.

Pode-se observar no código-fonte da listagem 1.5 que sempre que a condi-

1.2 O ambiente servidor

Geralmente se nomeia servidor uma máquina que é utilizada para hospedagem

O Apache Tomcat é considerado um contêiner de servlets, em outras pala-

1.3 IDEs para desenvolvimento web

Construir programas e executá-los não requer, na maioria das tecnologias,

Figura 1.2 – Página de download do NetBeans (NETBEANS, 2016).

Após a instalação ser efetuada, é só executar o programa e a tela inicial do

Figura 1.3 – IDE NetBeans e suas divisões.

Figura 1.4 – Botões úteis do IDE NetBeans.

As funções de cada botão apresentado na figura 1.4:

1.4 Desenvolvimento web com NetBeans

Cada aplicação web que é desenvolvida utilizando o NetBeans, é tratada como

Para criar um projeto de sistema web, selecione no menu da esquerda Java

Para este projeto, o servidor Apache Tomcat é selecionado, assim como a