Programação para web II

Prévia do material em texto

PROGRAMAÇÃO PARA WEB II
Caderno de Estudos
 Prof. Cristiano Roberto Franco
UNIASSELVI
2016
NEAD
Educação a Distância
GRUPO
CENTRO UNIVERSITÁRIO
LEONARDO DA VINCI
Rodovia BR 470, Km 71, nº 1.040, Bairro Benedito
89130-000 - INDAIAL/SC
www.uniasselvi.com.br
Copyright  UNIASSELVI 2016
Elaboração:
Prof. Cristiano Roberto Franco
Revisão, Diagramação e Produção:
Centro Universitário Leonardo da Vinci - UNIASSELVI
Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri 
UNIASSELVI – Indaial.
005.276
F825p Franco, Cristiano Roberto
 Programação Web II / Cristiano Roberto Franco. Indaial 
: UNIASSELVI, 2016.
 192 p. : il.
 ISBN 978-85-7830-950-3
 
 1.Programação para internet. 
 I. Centro Universitário Leonardo Da Vinci. 
PROGRAMAÇÃO PARAWEB II
APRESENTAÇÃO
O mundo mudou! Enquanto você lê esse texto, muito provavelmente na tela de seu 
computador desktop, notebook ou dispositivo móvel, milhões de pessoas ao redor do globo 
estão trafegando dados digitalmente transformados na autoestrada da informação conhecida 
como internet. Você não usa mais essa autoestrada somente para estudar e trabalhar, você a 
usa para comprar, viajar, ouvir música, ver TV, filmes e seriados, fazer operações bancárias, 
pagar contas, falar com amigos e familiares distantes, namorar e até mesmo para compartilhar 
com o mundo que você fez uma omelete no café da manhã. E você quer poder fazer tudo isso 
a qualquer hora e de qualquer lugar.
Tamanha conectividade é possível, mas não vem de graça. Ela cobra um preço caro. 
Além de antenas, redes, roteadores e demais dispositivos físicos (que não são o objeto desta 
disciplina e por isso não serão abordados), você precisa de software que possa atender a 
essa demanda voraz por informação. E não é qualquer software... conforme a lei de Moore 
vai chegando ao seu limite, decidimos por outras estratégias para ampliar o desempenho dos 
computadores e consequentemente do software que executa neles. Processadores multicores, 
virtualização, computação em grid e cloud são apenas alguns dos artifícios que usamos para 
garantir o desempenho das aplicações. Porque no final das contas, sempre que você compra, 
viaja, ouve música, vê TV, filmes e seriados e compartilha com o mundo que fez uma omelete 
no café da manhã, você o faz através de uma aplicação.
É nesse contexto que atua a tecnologia que estudaremos nesta disciplina. A plataforma 
Java nos apresenta o Java Enterprise Edition (JEE), especialmente desenvolvido e planejado 
para ambientes com grande demanda por desempenho e robustez. É a mesma tecnologia que 
dá vazão a alguns dos serviços mais conhecidos e utilizados da internet, como Twitter, Linkedin 
e Netflix. Destaque especial para o fato de que, em momentos de pico, o Netflix concentra 37% 
de todo o tráfego de internet da América do Norte (TODD, 2015). 
Conforme Evans et al. (2011), os desenvolvedores de software reconhecem cada vez 
mais a necessidade de aplicações que sejam distribuídas, transacionais, portáveis e que 
permitam alavancar o desempenho, segurança e confiabilidade das tecnologias server-side. 
Para atender à crescente demanda, as tecnologias devem permitir que estas aplicações sejam 
projetadas e construídas mais rapidamente, com menos recursos computacionais e menor custo. 
Parece inacreditável, mas não... é simplesmente a evolução de uma tecnologia aberta que já 
existe há aproximadamente 20 anos e que conta com o feedback intenso do Java Community 
Process para definir seus rumos e roadmap.
Apesar de o JEE ter como um dos focos principais a facilidade de desenvolvimento, 
a complexidade intrínseca do ambiente para o qual foi projetado e o número de tecnologias 
envolvidas o tornam relativamente denso. Tenha em mente que você não está estudando uma 
iii
PROGRAMAÇÃO PARAWEB II iv
tecnologia para fazer um “sitezinho para seu tio que tem uma quitanda”, mas sim para construir 
aplicações distribuídas, robustas, portáveis e seguras. 
Lembre-se de que você não está sozinho nesta jornada. O meu trabalho ao longo deste 
caderno é tentar facilitar ao máximo a compreensão das tecnologias envolvidas no JEE. Para 
atingir tal objetivo, farei uso de exemplos pequenos e simples na demonstração de cada tecnologia, 
combinando-os em um exemplo maior e mais complexo como autoatividade no final de cada 
seção. Tal metodologia de ensino e aprendizagem é sugerida por Nicholas Negroponte do MIT 
Media Lab, em seu artigo Learning by Doing: Don´t dissect the frog. Built it (NEGROPONTE, 2004). 
Aproveito esse momento para destacar que os exercícios NÃO SÃO OPCIONAIS. 
O objetivo de cada exercício deste caderno é a fixação de determinado conceito através da 
prática. É aí que reside a importância da realização de todos. Sugerimos fortemente que em 
caso de dúvida em algum exercício você entre em contato com seu tutor externo ou com a 
tutoria da Uniasselvi e que não passe para o exercício seguinte enquanto o atual não estiver 
completamente compreendido. Aprender a programar utilizando a tecnologia JEE sem exercitar 
os conceitos de forma prática, somente com a leitura do caderno, é equivalente a ir a um 
restaurante e tentar matar a fome lendo o cardápio. Instruções detalhadas de como preparar 
o ambiente para a resolução dos exercícios em seu computador são mostrados na Unidade 1.
Você precisará de muita determinação e força de vontade, pois o conteúdo abordado 
neste caderno não é fácil e você levará mais do que um semestre para compreendê-lo totalmente, 
entretanto, aqui forneceremos um início sólido e consistente. Desta forma, passe por esse 
período de estudos com muita dedicação, pois você que hoje é acadêmico(a), amanhã será um 
profissional de Tecnologia da Informação com o compromisso de construir uma nação melhor.
Lembre-se de que o encantamento com a programação deriva do seu entendimento; 
a beleza desta área do conhecimento é a compreensão da lógica envolvida na construção de 
programas. Por isso, bons programadores são apaixonados por linguagens de programação e 
ambientes de desenvolvimento e estão sempre buscando novos conhecimentos. Como disse Drew 
Houston, criador do DropBox: “Programar é a coisa mais parecida que temos com superpoderes”.
Bons códigos!
Prof. Cristiano Roberto Franco
UNI Oi!! Eu sou o UNI, você já me conhece das outras disciplinas. 
Estarei com você ao longo deste caderno. Acompanharei os seus 
estudos e, sempre que precisar, farei algumas observações. 
Desejo a você excelentes estudos! 
 UNI
PROGRAMAÇÃO PARAWEB II v
PROGRAMAÇÃO PARAWEB II vi
SUMÁRIO
UNIDADE 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION ................................... 1
TÓPICO 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS 
 TECNOLOGIAS ........................................................................................... 3
1 INTRODUÇÃO ............................................................................................................... 3
2 PRINCIPAIS TECNOLOGIAS ........................................................................................ 7
2.1 A ARQUITETURA DOS CONTAINERS ....................................................................... 9
RESUMO DO TÓPICO 1 ................................................................................................. 12
AUTOATIVIDADE ........................................................................................................... 13
TÓPICO 2 – CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E 
 DEPLOYMENT ........................................................................................... 15
1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO– WILDFLY .................................... 15
2 INSTALAÇÃO DO NETBEANS ................................................................................... 21
3 INTEGRAÇÃO WILDFLY-MYSQL ............................................................................... 24
4 INTEGRAÇÃO GLASSFISH-MYSQL .......................................................................... 28
RESUMO DO TÓPICO 2 ................................................................................................. 36
AUTOATIVIDADE ........................................................................................................... 37
TÓPICO 3 – JAVA SERVER FACES (JSF) .................................................................... 39
1 INTRODUÇÃO ............................................................................................................. 39
2 CRIAÇÃO DA PRIMEIRA APLICAÇÃO ...................................................................... 41
2 CICLO DE VIDA E ESCOPOS DO JSF ....................................................................... 48
LEITURA COMPLEMENTAR .......................................................................................... 54
RESUMO DO TÓPICO 3 ................................................................................................. 59
AUTOATIVIDADE ........................................................................................................... 60
AVALIAÇÃO .................................................................................................................... 61
UNIDADE 2 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES E JAVA 
 PERSISTENCE API ................................................................................ 63
TÓPICO 1 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES ...................... 65
1 INTRODUÇÃO ............................................................................................................. 65
2 COMPONENTES DE FORMULÁRIO .......................................................................... 65
3 TABELAS ..................................................................................................................... 77
4 SUPORTE NATIVO A AJAX ........................................................................................ 81
5 ADICIONANDO UMA BIBLIOTECA EXTERNA DE COMPONENTES VISUAIS ....... 83
RESUMO DO TÓPICO 1 ................................................................................................. 93
AUTOATIVIDADE ........................................................................................................... 94
TÓPICO 2 – JAVA PERSISTENCE API (JPA) ............................................................... 95
PROGRAMAÇÃO PARAWEB II vii
PROGRAMAÇÃO PARAWEB II viii
1 INTRODUÇÃO ............................................................................................................. 95
2 MAPEAMENTO OBJETO RELACIONAL ................................................................... 96
2.1 ARQUITETURA DO DATA ACCESS OBJECT .......................................................... 98
3 JAVA PERSISTENCE API (JPA) ............................................................................... 100
4 CONCEITOS E INTERFACES DO JPA ..................................................................... 101
4.1 MAPEAMENTO DE ENTIDADES ........................................................................... 102
4.2 RELACIONAMENTOS ENTRE ENTIDADES ........................................................... 112
LEITURA COMPLEMENTAR ......................................................................................... 114
RESUMO DO TÓPICO 2 ............................................................................................... 126
AUTOATIVIDADE ......................................................................................................... 128
AVALIAÇÃO .................................................................................................................. 129
UNIDADE 3 – ENTERPRISE JAVA BEANS (EJB) E CONTEXT AND DEPENDENCY
 INJECTION (CDI) ................................................................................... 131
TÓPICO 1 – STATELESS SESSION BEANS .............................................................. 133
1 INTRODUÇÃO ........................................................................................................... 133
2 STATELESS SESSION BEANS ................................................................................ 134
2.1 EJB 3.0 .................................................................................................................... 134
2.2 EJB 3.1 .................................................................................................................... 136
2.2 TESTANDO O EJB .................................................................................................. 137
2.3 CICLO DE VIDA ...................................................................................................... 140
2.4 ESCALABILIDADE, POOL E CALL-BACKS ........................................................... 141
2.5 MÉTODOS ASSÍNCRONOS ................................................................................... 142
RESUMO DO TÓPICO 1 ............................................................................................... 144
AUTOATIVIDADE ......................................................................................................... 145
TÓPICO 2 – STATEFULL SESSION BEANS E SINGLETON SESSION BEANS ....... 147
1 INTRODUÇÃO ........................................................................................................... 147
2 STATEFULL SESSION BEANS 3.0 ........................................................................... 148
3 STATEFULL SESSION BEANS 3.1 ........................................................................... 149
3.1 CICLO DE VIDA DOS STATEFULL SESSION BEANS ........................................... 149
3.2 CALLBACKS ........................................................................................................... 152
4 SINGLETON SESSION BEANS ................................................................................ 153
4.1 CICLO DE VIDA ...................................................................................................... 154
RESUMO DO TÓPICO 2 ............................................................................................... 156
AUTOATIVIDADE ......................................................................................................... 157
TÓPICO 3 – CONTEXT AND DEPENDENCY INJECTION .......................................... 159
1 INTRODUÇÃO ........................................................................................................... 159
2 PRODUCER METHODS E ATTRIBUTES ................................................................. 160
3 EXPRESSION LANGUAGE (EL) NAME ................................................................... 161
4 ESCOPOS E CONTEXTOS ....................................................................................... 162
RESUMO DO TÓPICO 3 ............................................................................................... 164
PROGRAMAÇÃO PARAWEB II ix
AUTOATIVIDADE ......................................................................................................... 165
TÓPICO 4 – JAVA MESSAGING SERVICES ............................................................... 167
1 INTRODUÇÃO ........................................................................................................... 167
2 FILAS E TÓPICOS ..................................................................................................... 167
3 MODOS DE RECEBIMENTO.................................................................................... 171
LEITURA COMPLEMENTAR ........................................................................................ 174
RESUMO DO TÓPICO 4 ............................................................................................... 185
AUTOATIVIDADE ......................................................................................................... 186
AVALIAÇÃO .................................................................................................................. 187
REFERÊNCIAS ............................................................................................................. 189
PROGRAMAÇÃO PARAWEB II x
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
UNIDADE 1
INTRODUÇÃO AO JAVA ENTERPRISE 
EDITION
OBJETIVOS DE APRENDIZAGEM
 Ao final desta unidade, você será capaz de:
	identificar e descrever algumas das tecnologias que fazem parte 
da especificação JEE;
	identificar quais tipos de situações e ambientes são mais 
adequados para a utilização de tais tecnologias;
	montar um ambiente de desenvolvimento e deployment de 
aplicações JEE usando a IDE Eclipse e o Servidor de Aplicações 
WildFly.
TÓPICO 1 – INTRODUÇÃO AO JAVA 
ENTERPRISE EDITION E PRINCIPAIS 
TECNOLOGIAS
TÓPICO 2 – CONSTRUÇÃO DO AMBIENTE DE 
DESENVOLVIMENTO E DEPLOYMENT
TÓPICO 3 – JAVA SERVER FACES (JSF)
PLANO DE ESTUDOS
Esta unidade de ensino está dividida em três tópicos, sendo 
que no final de cada um deles, você encontrará atividades que 
contribuirão para a apropriação dos conteúdos.
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
INTRODUÇÃO AO JAVA ENTERPRISE 
EDITION E PRINCIPAIS TECNOLOGIAS
1 INTRODUÇÃO
TÓPICO 1
O Java Enterprise Edition (JEE) inicialmente evoluiu como uma plataforma de 
desenvolvimento para aplicações enterprise que focava em robustez, webservices e facilidade. 
Continuamente moldado através do feedback fornecido pelo Java Community Process (JCP), 
o JEE hoje representa um padrão universal para TI empresarial, facilitando o desenvolvimento, 
instalação e gerenciamento de aplicações multi-tier e server-centric. O sucesso na adoção da 
plataforma é inegável. Em maio de 2013, os componentes JEE6 da Oracle e outros fornecedores 
já contabilizavam 50 milhões de downloads (ORACLE, 2014).
UNIDADE 1
IMP
OR
TAN
TE! �
O JCP é o mecanismo através do qual são definidas as 
especificações técnicas para a tecnologia Java. Ele é aberto 
para a participação de qualquer pessoa. Maiores detalhes em: 
<https://www.jcp.org/>.
Conforme Evans et al. (2011), o modelo de aplicação do JEE começa com a linguagem 
de programação Java e a Java Virtual Machine. A já conhecida e comprovada portabilidade, 
segurança e produtividade no desenvolvimento que ela oferece formam a base deste modelo. 
A plataforma JEE é projetada para suportar aplicações que possuem elevado grau de 
complexidade, acessando dados das mais variadas fontes e atendendo a um grande número 
de clientes e requisições. Sua arquitetura facilita o gerenciamento da escalabilidade, pré-
requisito para ambientes corporativos de alto desempenho. Esta arquitetura divide o trabalho 
em duas partes:
UNIDADE 1TÓPICO 14
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
1) A lógica de negócio e apresentação: implementadas pelo desenvolvedor.
2) Os serviços-padrão que tais aplicações necessitam: ofertadas pela plataforma JEE através 
do servidor de aplicações.
A Figura 1 apresenta uma arquitetura JEE típica:
FIGURA 1 - ARQUITURA JEE TÍPICA
FONTE: Evans et al. (2011)
Para compreender a figura, inicialmente é necessária a compreensão do conceito de 
tier (camada lógica) e de layer (camada física). Tanto a tier quanto a layer podem ser definidas 
como um conjunto de tecnologias que representa um conceito que faz parte da aplicação. A tier 
é sempre composta por software, ou seja, é lógica. A layer é sempre composta por hardware, 
ou seja, é física. No caso da figura, temos quatro tiers e três layers:
1) Client Tier: representa a camada cliente, ou seja, o que os usuários efetivamente acessam 
da aplicação. Perceba que a figura a define com duas tecnologias: a aplicação cliente, 
normalmente uma aplicação desktop desenvolvida com Swing ou JavaFX, e as páginas web, 
acessadas através de um navegador. Ambas as tecnologias estão no layer representado 
pela máquina do usuário, ou seja, o computador onde ele acessa a aplicação.
2) Web Tier: representa a camada responsável por fazer a ligação entre as páginas web e a 
lógica de negócio, representada aqui pela tecnologia Java Server Faces (JSF). Em alguns 
casos, esta camada é dispensável. Perceba que na figura, as aplicações clientes acessam 
UNIDADE 1 TÓPICO 1 5
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
a lógica de negócio diretamente, sem esse intermédio. Esta camada poderia ainda ser 
representada por tecnologias como Servlets e Java Server Pages, que não fazem parte do 
escopo deste caderno. Se considerarmos a layer, esta parte fica alocada no JEEServer.
3) Business Tier: representa a lógica de negócios da aplicação, aqui implementada em Enterprise 
Beans individuais para a aplicação cliente e para as páginas web. Em termos de layer, ainda 
estamos no JEEServer.
4) Enterprise Information Server (EIS) Tier: representa as fontes de dados que as aplicações 
acessam através da business tier, normalmente um SGBDR. Esta fonte de dados também 
pode ser alguma aplicação legada já existente no ambiente corporativo. Agora estamos na 
layer Database Server.
É importante mencionar alguns detalhes a respeito destas definições. A Web Tier 
pode ser implementada em Servlet Containers, que são uma espécie de “mini” servidores de 
aplicação mais leves e ágeis, entretanto não disponibilizam todos os serviços dos servidores 
de aplicação. O Apache Tomcat é um exemplo de Servlet Container. Em muitas situações, é 
mais produtivo desenvolver aplicações somente com Servlet Containers, colocando a lógica 
de negócio em Plain Old Java Objects (POJOs) do que acrescentar o peso de um servidor de 
aplicação com Enterprise Beans. É por este motivo que a layer JEEServer é dividida em Web 
Tier e Business Tier. Cada caso é um caso e deve ser avaliado pesando os prós e contras de 
cada tecnologia. É o eterno tradeoff da arquitetura de software.
Outro detalhe importante é que as layers, com exceção da Client Machine, podem ser 
todas implementadas em uma única camada física. É possível colocar o JEEServer (com ou sem 
Web Tier) e o DataBase Server em um único computador, embora isso não seja recomendado.
A grande premissa por trás do JEE é que o desenvolvedor pode confiar na plataforma para 
facilitar a implementação destes serviços-padrão, normalmente representados por requisitos 
não funcionais. Como tudo na plataforma Java, o JEE é simplesmente uma especificação, ou 
seja, definições e documentos descrevendo como a tecnologia deve se comportar, além de 
padrões que devem ser obedecidos no desenvolvimento, definidos através do JCP.
No caso do JEE, um dos componentes principais (se não o principal) é o servidor 
de aplicação. É este servidor de aplicação que encapsulará internamente os serviços que a 
plataforma oferece. Cabe ao desenvolvedor utilizá-los através das tecnologias definidas para 
tal. Como exemplos de implementações desta especificação podemos citar o Jboss, o WildFly 
e o GlassFish.
UNIDADE 1TÓPICO 16
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
IMP
OR
TAN
TE! �
O Swing e o JavaFX são tecnologias definidas pela Oracle para a 
criação de interfaces em aplicações Desktop. Maiores detalhes 
podem ser encontrados em: <http://docs.oracle.com/javase/8/javase-clienttechnologies.htm>.
Mas que serviços são estes? Com o advento e popularização da internet e das tecnologias 
móveis, o número de usuários aumentou exponencialmente. Para atender à estas demandas, 
diversos requisitos não funcionais passaram a ter uma importância ainda maior para estas 
aplicações. Termos como escalabilidade, segurança, gerenciamento do ciclo de vida de objetos, 
remotabilidade, controle de transações, entre outros, vieram a fazer parte do dia a dia dos 
desenvolvedores. Ou seja, se transformaram em preocupações para os desenvolvedores, que 
agora não escrevem código somente para lidar com a lógica de negócios e os requisitos funcionais.
Algumas das tecnologias disponibilizadas pelo JEE permitem que o desenvolvedor 
simplesmente sinalize em seu código aspectos relacionados à segurança, remotabilidade, 
transações etc., e o servidor de aplicações faz todo o resto. Isto libera o desenvolvedor para 
fazer mais o que realmente é importante: escrever código relacionado às necessidades do 
usuário e a lógica do negócio.
De acordo com ORACLE (2013), o modelo simplificado de programação do JEE faz com 
que os descritores de deployment em XML sejam opcionais. Ao invés disso, o desenvolvedor 
pode colocar uma informação diretamente no código fonte através das annotations e o servidor 
irá configurar o componente em tempo de execução. Estas annotations em geral servem para 
embutir no programa dados que serial de outra forma fornecidos em um deployment descriptor. 
Com as annotations, você pode colocar a especificação do serviço do servidor ao lado do 
código que será afetado por ele.
Abaixo estão listados alguns dos serviços disponibilizados pelas tecnologias envolvidas 
na plataforma K19 (2013).
•	 Transações: A arquitetura Enterprise Java Beans (EJB) define um suporte sofisticado para 
utilização de transações. Esse suporte é integrado com a Java Transaction API (JTA) e 
oferece inclusive a possibilidade de realizar transações distribuídas.
•	 Segurança: Suporte para realizar autenticação e autorização de forma transparente. Os 
desenvolvedores das aplicações não precisam implementar a lógica de segurança, pois ela 
faz parte da arquitetura JEE.
•	 Remotabilidade: Aplicações JEE podem ser acessadas remotamente através de diversos 
UNIDADE 1 TÓPICO 1 7
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
protocolos de comunicação. Consequentemente, é possível desenvolver aplicações clientes 
de diversos tipos. Por exemplo, aplicações EJB podem ser acessadas como Web Services.
•	 Multithreading e Concorrência: A arquitetura JEE permite que as aplicações sejam acessadas 
por múltiplos usuários simultaneamente de maneira controlada para evitar problemas de 
concorrência.
•	 Persistência: Facilidades para utilizar os serviços dos provedores de persistência que seguem 
a especificação JPA.
•	 Gerenciamento de Objetos: Mecanismos de injeção de dependências e controle de ciclo de 
vida são oferecidos aos objetos de uma aplicação JEE. O mecanismo de controle de ciclo 
de vida pode garantir a escalabilidade de uma aplicação.
•	 Integração: A arquitetura EJB é fortemente integrada com os componentes da plataforma Java 
EE. Podemos, por exemplo, facilmente integrar os recursos do JSF em uma aplicação EJB.
IMP
OR
TAN
TE! �
Os enterprise java beans, conhecidos como EJBs fazem parte 
da especificação JEE e fornecem boa parte dos serviços da 
plataforma. Estudaremos detalhadamente esta tecnologia na 
Unidade 3 deste Caderno de Estudos.
2 PRINCIPAIS TECNOLOGIAS
Como descrevemos anteriormente, o servidor de aplicação JEE tem como principal 
característica o oferecimento de serviços para as aplicações nele instalados. Serviços estes 
geralmente relacionados com requisitos não funcionais como escalabilidade, remotabilidade etc. 
Para cada um destes serviços existe uma ou mais tecnologias que, trabalhando individualmente 
ou em conjunto, abstraem o desenvolvedor de detalhes específicos da implementação do mesmo.
A seguir faremos uma rápida introdução às principais tecnologias que compõem o JEE, 
conforme definido em ORACLE (2014), destacando as que serão abordadas neste Caderno 
de Estudos.
Componentes JEE: As aplicações JEE são feitas de componentes. Estes componentes 
são unidades encapsuladas de software funcionais que fazem parte das aplicações. Cada 
componente possui suas próprias classes e arquivos e se comunica com outros componentes. 
UNIDADE 1TÓPICO 18
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
A especificação JEE define os seguintes componentes: 
•	 Aplicação cliente e applets que executam no cliente.
•	 Servlets, Java Server Faces e Java Server Pages como componentes que executam no 
servidor.
•	 Enterprise Java Beans, como componentes de negócio que executam no servidor.
Todos estes componentes são escritos na linguagem de programação Java e compilados 
da mesma forma como qualquer outro programa. A diferença é que estes componentes são 
“embutidos” dentro de aplicações que obedecem às especificações JEE e são, portanto, 
gerenciadas pelo servidor de aplicação.
Java Server Faces (JSF): É um framework para a construção de aplicações web. 
Permite a utilização de classes Java como implementações de componentes HTML. Oferece 
validação de entrada, gerenciamento de eventos, conversão de dados entre componentes 
e objetos de domínio, configuração de navegação, controle do ciclo de vida dos objetos e 
a expression language (EL), que permite que componentes da interface gráfica conversem 
diretamente com o controlador. 
Java Persistence API (JPA): Apresenta uma solução para a persistência de objetos em 
ambientes relacionais, usando uma estratégia de mapeamento objeto relacional. A JPA também 
pode ser utilizada em aplicações não JEE fora do ambiente do servidor. Consiste de uma api 
de persistência, uma linguagem de query e metadados para mapeamento objeto relacional.
Java Transaction API (JTA): Oferece uma inferface-padrão para a demarcação de 
transações. A arquitetura JEE possui auto commit como default para gerenciar commits e 
rollbacks dentro de transações. Isso significa que qualquer aplicação que está visualizando um 
dado que está sendo alterado verá o mesmo atualizado depois de cada operação de leitura ou 
escrita. Entretanto, caso sua aplicação realize duas operações de acesso a dados em bases 
diferentes que dependem uma da outra, você pode utilizar a JTA API para demarcar onde a 
transação inteira começa, termina ou mesmo execute um rollback.
IMP
OR
TAN
TE! �
Nas tecnologias de bancos de dados, um rollback significa que 
o banco de dados pode voltar a determinado estado anterior, 
evitando que um erro seja propagado e mantido no mesmo.
Context and Dependency Injection for Java EE (CDI): Define um conjunto de serviços 
do JEE acessíveis via contexto. Projetado para uso com objetos que possuam estado, o CDI 
UNIDADE 1 TÓPICO 1 9
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
tem aplicações diversas, pois representa a injeção de recursos em uma classe através de 
annotations, garantindo a flexibilidade e o baixo acoplamento no desenvolvimento.
Java Message Service API (JMS): Define um padrão de mensageria que permite que 
os componentes das aplicações JEE criem, enviem, recebam e leiam mensagens. Permite a 
comunicação distribuída de forma desacoplada, confiável e assíncrona. 
Java Authentication and Authorization Service (JAAS): É o serviço que permite a 
autenticação e autorização de um usuário específico ou de um grupo de usuários. Oferece 
uma maneira desacoplada para a definição de aspectos de segurança em uma aplicação 
JEE. O modelo do JEE permite que as restrições de segurança sejam definidas em tempo 
de deployment e torna as aplicações portáveis para uma vasta gama de implementaçõesde 
diferentes fornecedores. As regras de controle de acesso são declarativas e definidas pelo 
desenvolvedor. Estas regras são interpretadas quando a aplicação é instalada no servidor, 
protegendo os desenvolvedores da complexidade da implementação de requisitos de segurança. 
O JEE permite ainda a utilização de mecanismos de segurança externos, como Active Directory 
e LDAP, por exemplo. A mesma aplicação pode fazer uso de diversos mecanismos de segurança 
sem nenhuma alteração no código fonte da mesma.
Enterprise Java Beans (EJB): São componentes que possuem atributos e métodos 
para implementar lógica de negócios. Você pode pensar neles como um bloco de construção 
que pode ser utilizado individualmente ou em conjunto com outros beans para executar lógica 
de negócios na aplicação JEE. Os Enterprise Beans podem ser de dois tipos: 
•	 Session beans: representa uma conversação transiente com o cliente. Quando o cliente 
encerra a execução, o bean e seus dados são perdidos.
•	 Message driven beans: combina características de um session bean e um ouvinte de mensagens, 
permitindo que um componente de negócios receba mensagens de forma assíncrona. 
2.1 A ARQUITETURA DOS CONTAINERS
Uma das vantagens do JEE é a possibilidade de utilizá-lo em aplicações de praticamente 
qualquer porte. Seu modelo desacoplado e flexível facilita a utilização somente dos componentes 
que fazem sentido para a aplicação. Para entender esta arquitetura, é importante entender 
de que forma o servidor de aplicação está dividido em containers. A figura a seguir ilustra o 
relacionamento entre os containers JEE.
UNIDADE 1TÓPICO 110
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 2 - RELACIONAMENTO ENTRE CONTAINERS
FONTE: Oracle (2014)
Perceba que o JEE Server possui dois containers, o Web Container e o EJB Container. 
A compreensão do funcionamento destes dois containers é fundamental para que se faça bom 
uso dos serviços do servidor de aplicação e da plataforma JEE. 
Dentro do Web Container podemos perceber as tecnologias Java Server Faces e Servlet. 
Uma figura mais completa conteria ainda as Java Server Pages (JSP). Estas tecnologias 
representam uma forma de disponibilizar a aplicação através de um navegador web. Sem um 
webcontainer não é possível publicar páginas html, xhtml e outras, o que impede a criação de 
aplicações web. Caso sua aplicação seja mandatoriamente acessada através de um navegador, 
você precisará de um webcontainer. 
Já o EJB Container é responsável pelo gerenciamento dos Enterprise Java Beans. A 
maioria dos serviços referentes a requisitos não funcionais ficam sob encargo deste container. 
Em geral, o acesso aos dados é feito através dele, visto que a JTA não está disponível no 
Webcontainer. Já dissemos aqui que nada impede a colocação de regras de negócio em POJOs 
dentro do Webcontainer e mesmo de acessar dados através dele, é simplesmente uma questão 
de analisar os prós e os contras. No modelo da figura, os componentes Web interagem com 
os componentes EJB para a lógica de negócios e o acesso aos dados.
Na figura, ainda existe o que é chamado de Client System, composto pelo Browser e 
pelo Application Client Container. Este componente representa a interface da aplicação com 
o cliente, seja pelo navegador, seja por uma aplicação Swing, JavaFX ou mesmo console. 
Perceba que o application client acessa os EJBs sem intermédio do Webcontainer.
Chegando ao final deste tópico, onde fizemos a introdução da plataforma Java 
Enterprise Edition e das principais tecnologias que a compõem, você deve pensar “é muita 
coisa para estudar”. E realmente, você tem razão, se considerarmos todo o conjunto das 
tecnologias que compõem o JEE, o volume de APIs é imenso. Entretanto, analisando o escopo 
de nossa disciplina e deste caderno, nos concentraremos nas tecnologias mais importantes 
e que impactarão diretamente sua produtividade como desenvolvedor. Nosso objetivo não é 
esgotar o tema, e sim colocar você produzindo aplicações JEE com as principais tecnologias 
UNIDADE 1 TÓPICO 1 11
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
que a plataforma disponibiliza. Seu sucesso dependerá diretamente de seus estudos futuros, 
entretanto, aqui forneceremos um embasamento sólido.
E então...que tal pôr nossas mãos à obra? Como disse Linus Torvalds, criador do sistema 
operacional Linux: “Talk is cheap... show me the code”. No próximo tópico aprenderemos como 
configurar e preparar o ambiente que dará suporte ao desenvolvimento JEE.
Bons estudos!
UNIDADE 1TÓPICO 112
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
RESUMO DO TÓPICO 1
•	 O Java Enterprise Edition (JEE) inicialmente evoluiu como uma plataforma de desenvolvimento 
para aplicações enterprise que focava em robustez, webservices e facilidade.
•	 A plataforma JEE é projetada para suportar aplicações que possuem elevado grau de 
complexidade, acessando dados das mais variadas fontes e atendendo a um grande número 
de clientes e requisições.
•	 A tier é sempre composta por software, ou seja, é lógica. A layer é sempre composta por 
hardware, ou seja, é física.
•	 A Web Tier pode ser implementada em Servlet Containers, que são uma espécie de “mini” 
servidores de aplicação mais leves e ágeis, entretanto não disponibilizam todos os serviços 
dos servidores de aplicação.
•	 A grande premissa por trás do JEE é que o desenvolvedor pode confiar na plataforma para 
facilitar a implementação destes serviços padrão, normalmente representados por requisitos 
não funcionais.
•	 Para cada um destes serviços existe uma ou mais tecnologias que, trabalhando individualmente 
ou em conjunto, abstraem o desenvolvedor de detalhes específicos da implementação do 
mesmo.
•	 Algumas das tecnologias disponibilizadas pelo JEE permitem que o desenvolvedor 
simplesmente sinalize em seu código aspectos relacionados à segurança, remotabilidade, 
transações etc., e o servidor de aplicações faz todo o resto.
•	 Uma das vantagens do JEE é a possibilidade de utilizá-lo em aplicações de praticamente 
qualquer porte. Seu modelo desacoplado e flexível facilita a utilização somente dos 
componentes que fazem sentido para a aplicação.
UNIDADE 1 TÓPICO 1 13
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
AUT
OAT
IVID
ADE �
1 Diferencie um servidor de aplicação de um webcontainer e forneça exemplos da 
aplicabilidade de ambos.
2 Explique detalhadamente e exemplifique a diferença entre uma layer e uma tier, no 
contexto de arquitetura de software.
3 Uma das vantagens da utilização de um AS que obedeça às especificações JEE é 
a disponibilização de serviços que antes eram implementados manualmente pelos 
desenvolvedores. Com vistas a isto, avalie a lista de serviços abaixo.
I – Segurança através do JAAS.
II – Mensageria através do JMS.
III – Remotabilidade.
IV – Componentização através do JTA.
Agora assinale a alternativa que lista corretamente os serviços disponibilizados 
pelos servidores de aplicação JEE 7:
a) I, II e III.
b) II e III.
c) I e III.
d) II e IV.
UNIDADE 1TÓPICO 114
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
CONSTRUÇÃO DO AMBIENTE DE 
DESENVOLVIMENTO E EPLOYMENT
1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO – WILDFLY
TÓPICO 2
Conforme vimos nos tópicos anteriores, para podermos desenvolver, implantar e testar 
aplicações que utilizem as tecnologias que fazem parte da especificação JEE, precisamos de 
um servidor de aplicação – application server (AS).
Utilizaremos, neste caderno, o WildFly Application Server, conhecido anteriomente como 
JBoss. A Red Hat, empresa que desenvolve o AS, justifica a mudança dizendo que o nome 
WildFly representa melhor o software na atualidade,pois lembra leveza, agilidade e liberdade. 
A figura a seguir mostra o website do projeto.
UNIDADE 1
NO
TA! �
O projeto WildFly pode ser acessado através da URL: <http://
wildfly.org>.
Apesar de você poder fazer o download do software pelo website e instalação 
separadamente através do arquivo, utilizaremos aqui uma abordagem diferente: instalaremos 
através da própria Integrated Development Environment (IDE) Eclipse.
UNIDADE 1TÓPICO 216
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 3 - WEBSITE DO SERVIDOR DE APLICAÇÃO WILDFLY
FONTE: O autor
Inicialmente precisaremos fazer com que o Eclipse mostre a aba dos servidores, visto 
que passaremos a utilizá-la com bastante frequência. Na figura a seguir mostramos a aba dos 
servidores na IDE.
FIGURA 4 - ABA SERVIDORES NO ECLIPSE
FONTE: O autor
Caso a aba não esteja aparecendo para você, é possível adicioná-la através da seleção 
do menu Window -> Show View -> Other. Você deve digitar a palavra server, de modo que 
esta opção fique acessível para seleção, conforme a figura a seguir.
UNIDADE 1 TÓPICO 2 17
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 5 - SELEÇÃO DA ABA SERVERS NO ECLIPSE
FONTE: O autor
Uma vez que a aba está disponível, devemos clicar com o botão direito do mouse e 
selecionar a opção New - > Server. Esta ação abrirá um novo diálogo, onde devemos selecionar 
a opção destacada na Figura 6.
A próxima tela traz os servidores disponíveis para instalação no Eclipse. Devemos 
selecionar a opção JbossAS Tools, confirmar todas as licenças e prosseguir com a instalação, 
conforme a Figura 7. Ao longo da instalação, algumas mensagens de aviso serão mostradas 
e ao final, você será solicitado para reiniciar a IDE. Finalize o procedimento e aguarde a 
reinicialização do Eclipse.
FIGURA 6 - DEFINIÇÃO DE UM NOVO SERVER
FONTE: O autor
UNIDADE 1TÓPICO 218
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 7 - SELEÇÃO DO JBOSSAS TOOLS
FONTE: O autor
Ao concluir a instalação e reinicialização da IDE, na aba Servers, clique com o botão 
direito do mouse e selecione a opção New -> Server. No momento em que este caderno foi 
escrito, somente tínhamos a versão 8 do WildFly para instalar. Caso a versão 9 ou posteriores 
aparecem para você, selecione a última versão que for compatível com a o JEE 7. Esta 
informação está disponível no website do WildFly.
Você deverá criar um novo runtime para o servidor, através das telas mostradas nas 
figuras 8 e 9. Você deve deixar a configuração exatamente como mostrado nas figuras, com 
exceção do Execution Environment, que deverá respeitar a versão do Java utilizada por você 
na IDE, e do caminho de instalação do servidor, ambas na Figura 9.
UNIDADE 1 TÓPICO 2 19
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 8 - INSTALAÇÃO DO WILDFLY
FONTE: O autor
Ao final, pressione Finish e estaremos prontos para testar a instalação de nosso servidor 
de aplicação. Na aba Server do Eclipse, deverá aparecer o servidor que acabamos de instalar. 
Clique com o botão direito no mouse no servidor e selecione a opção Start. O tempo necessário 
para a inicialização do WildFly dependerá diretamente do desempenho de seu computador. 
Automaticamente, o Eclipse seleciona a aba Console e várias mensagens geradas pelo WildFly 
aparecerão na tela. É vital que você se habitue a observar atentamente o console quando for 
testar suas aplicações, pois as mensagens de erro aparecem nesta aba. 
FIGURA 9 - INSTALAÇÃO DO WILDFLY
FONTE: O autor
UNIDADE 1TÓPICO 220
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Quando a inicialização do servidor encerrar, você deverá ver uma mensagem semelhante 
à destacada na Figura 10, indicando que o processo foi bem-sucedido. As mensagens acima 
da mensagem destacada e inclusive a versão e codinome do servidor podem variar, de acordo 
com o que foi selecionado e instalado nas etapas anteriores.
FIGURA 10 - INICIALIZAÇÃO DO WILDFLY
Por fim, para testarmos se a instalação foi bem-sucedida, devemos digitar a seguinte URL 
no navegador: <http://localhost:8080>. O navegador deverá mostrar a seguinte página, que é a 
página inicial do WildFly, que está executando localmente na porta 8080, conforme a Figura 11.
FONTE: O autor
FIGURA 11 - PÁGINA INICIAL DO WILDFLY EXECUTANDO EM LOCALHOST
FONTE: O autor
Caso você prefira utilizar uma IDE que já tenha o ambiente de Desenvolvimento completo 
embutido, pode utilizar o NetBeans, que já vem com uma implementação de referência da 
especificação JEE 7, conhecida como GlassFish. O procedimento para instalação do NetBeans 
será demonstrado a seguir.
UNIDADE 1 TÓPICO 2 21
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
2 INSTALAÇÃO DO NETBEANS
O NetBeans é uma IDE desenvolvida pela Oracle que permite que você desenvolva 
aplicações desktop, web e mobile em Java, bem como aplicações com HTML5, JavaScript e 
CSS. A IDE possui ainda uma vasta gama de ferramentas para desenvolvedores PHP e C/
C++. É gratuita, open source e tem uma grande comunidade de usuários e desenvolvedores 
ao redor do mundo (NETBEANS, 2015).
Ela pode ser obtida através do endereço <https://netbeans.org/downloads/index.html>, 
conforme a Figura 12. Neste endereço existem diversas versões para download, para diversos 
sistemas operacionais e em diversos idiomas. Você deve selecionar a opção destacada.
FIGURA 12 - DOWNLOAD DO NETBEANS
FONTE: O autor
Essa versão possui diversas ferramentas embutidas, o que praticamente elimina a 
necessidade de configuração, além de dois servidores, o GlassFish e o Tomcat. Em nossa 
disciplina precisaremos do GlassFish, visto que o Tomcat não é um Application Server, mas 
sim um servlet container.
Uma vez feito o download, podemos proceder com a instalação do NetBeans. O 
instalador da ferramenta é bem simples e, embora demore um pouco para concluir todo o 
processo, exige pouca interação por parte do usuário. Na Figura 13 podemos perceber uma 
janela informando quais softwares serão instalados em seu computador.
UNIDADE 1TÓPICO 222
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 13 - TELA DO INSTALADOR
FONTE: O autor
Caso deseje personalizar a instalação, retirando ou colocando itens, basta selecionar 
a opção “Personalizar”. Esta opção leva para a tela de configuração mostrada na Figura 14. 
Recomendamos que você mantenha todas as funcionalidades, com exceção do PHP e C/C++, 
que são completamente opcionais. O Tomcat deve ser selecionado pois, caso sua aplicação não 
utilize funcionalidades específicas de servidores de aplicação, ele representa uma opção mais leve 
e performática. Aprenderemos que funcionalidades específicas são essas ao longo do caderno. 
A última tela antes da instalação propriamente dita é mostrada na Figura 15. Basta 
selecionar a opção onde você diz que aceita os termos da licença e clicar em finalizar. O 
instalador procederá automaticamente com a cópia, descompactação e download dos arquivos 
necessários ao NetBeans. Lembramos que a versão da ferramenta poderá variar, dependendo 
de quando você fará a leitura do caderno e download da mesma. O importante é sempre manter-
se em versões superiores à utilizada aqui, aumentando a probabilidade de compatibilidade.
UNIDADE 1 TÓPICO 2 23
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 14 - CONFIGURAÇÃO DO INSTALADOR
FONTE: O autor
FIGURA 15 - CONTRATO DE LICENÇA
FONTE: O autor
Uma vez que a instalação foi concluída, ao abrir a IDE nos deparamos com a tela 
mostrada na Figura 16. Não é objetivo deste caderno a explicação das funcionalidades do 
NetBeans, visto que inclusive utilizaremos o Eclipse para o desenvolvimento de nossos 
exemplos.O Eclipse é melhor em algumas atividades e o NetBeans em outras. Com o tempo 
e a utilização, você elegerá a sua favorita.
UNIDADE 1TÓPICO 224
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 16 - INTERFACE DO NETBEANS
FONTE: O autor
ATEN
ÇÃO!
Tutoriais sobre o NetBeans podem ser acessados gratuitamente 
no endereço:
<https://netbeans.org/kb/docs/java/quickstart-gui.html>.
Para o desenvolvimento das aplicações, precisaremos estabelecer conexão com 
bancos de dados relacionais. A plataforma Java, através do JDBC e mais recentemente do 
JPA, permite a conexão com os principais players do mercado. Para facilitar o aprendizado e 
reduzir a configuração, trabalharemos com o banco de dados MySQL, que já foi utilizado por 
você em disciplinas anteriores.
3 INTEGRAÇÃO WILDFLY-MYSQL
Conforme K19 (2013), aplicações Java se comunicam com banco de dados através de 
conexões JDBC. Para estabelecer uma conexão JDBC, algumas informações como usuário, 
senha e base de dados são necessárias. As configurações relativas às conexões JDBC podem 
ser definidas nas aplicações ou nos servidores de aplicação. Em um servidor de aplicação, 
as configurações JDBC são definidas em componentes chamados Data Sources. Os Data 
UNIDADE 1 TÓPICO 2 25
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Sources permitem que uma única configuração JDBC seja utilizada por diversas aplicações. 
Eles também permitem que outros tipos de configurações sejam compartilhadas, como por 
exemplo, a configuração de um Connection Pool. Além disso, através de Data Sources podemos 
utilizar facilmente o serviço de transações dos servidores de aplicação. Esse serviço é definido 
pela especificação Java Transaction API (JTA), que será abordada na Unidade 3 deste Caderno 
de Estudos.
Inicialmente devemos fazer o download do driver jdbc para o MySQL, disponível em 
<http://dev.mysql.com/downloads/connector/j/>, conforme a Figura 17. É recomendável fazer 
o download do driver independente de plataforma, visto que ele funciona em qualquer sistema 
operacional. 
Uma vez que o download foi concluído, passamos para a integração do driver com 
o WildFly. Lembramos que a função do driver JDBC é estabelecer a comunicação entre o 
Sistema Gerenciador de Banco de Dados Relacional (SGBDR) e a plataforma Java, neste 
caso, representado pelo servidor de aplicações.
FIGURA 17 - DRIVER JDBC
FONTE: O autor
O próximo passo consiste em copiar o driver para o diretório adequado dentro da 
instalação do WildFly. Inicialmente localize o diretório onde o WildFly está instalado e lá dentro, 
localize o diretório modules/com. Agora crie um diretório chamado mysql e, dentro deste, outro 
diretório chamado main. O driver MySQL deverá ser copiado para esta pasta recém criada. 
Crie também neste diretório um arquivo vazio chamado module.xml.
UNIDADE 1TÓPICO 226
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 18 - LOCAL DO DRIVER JDBC
FONTE: O autor
O próximo passo consiste em copiar o driver para o diretório adequado dentro da 
instalação do WildFly. Inicialmente localize o diretório onde o WildFly está instalado e lá dentro, 
localize o diretório modules/com. Agora crie um diretório chamado mysql e, dentro deste, outro 
diretório chamado main. O driver MySQL deverá ser copiado para esta pasta recém-criada. 
Crie também neste diretório um arquivo vazio chamado module.xml.
O conteúdo deste arquivo deverá ser igual ao da imagem abaixo, respeitando o nome 
do arquivo que você copiou para dentro da pasta após o atributo path, na linha 4. Este arquivo 
representará a instalação de um módulo adicional no WildFly. Ao encerrar, verifique o código 
fonte escrito com cuidado, salve e feche o arquivo.
FIGURA 19 - ARQUIVO MODULE.XML
FONTE: O autor
A próxima (e última) etapa consiste na configuração do arquivo standalone.xml, 
disponível no caminho /standalone/configuration, no diretório de instalação do WildFly. Dentro 
deste arquivo, encontre a tag <datasources> e insira a configuração de um novo datasource e 
um novo driver, conforme mostrado na Figura 20. Caso já existam configurações para outros 
datasources e drivers, você não precisa excluí-los, uma vez que eles em geral servem como 
exemplo e o WildFly pode trabalhar com múltiplos datasources.
UNIDADE 1 TÓPICO 2 27
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Na Figura 20 podemos ainda perceber o nome de nosso datasource (java:/MYSQL_DS), 
representado pelo número 1 e também o nome do módulo que instalamos no arquivo module.
xml, representado pelo número 2. Outros aspectos importantes a serem destacados são o 
usuário e senha dentro da tag <security> e a url de conexão, dentro da tag <connection-url>. 
Estes valores deverão refletir a condição de seu SGBD. No caso deste exemplo, o usuário e 
senha do banco de dados são “root” e o nome da base de dados é JEE7. Faça as alterações de 
acordo com as configurações do MySQL instalado em seu computador. Ao encerrar, verifique 
o código fonte escrito com cuidado, salve e feche o arquivo.
FIGURA 20 - CRIAÇÃO DO DATASOURCE
FONTE: O autor
Para podermos realizar os testes da configuração que acabamos de fazer, verifique se 
o MySQL está funcionando corretamente em seu computador, de outra forma, não podemos 
nos conectar com ele através do WildFly. Feita esta verificação, abra o Eclipse e encontre 
o WildFly na aba Servers, iniciando-o. Diversas mensagens aparecerão no console, sendo 
que ao final devemos encontrar a mesma mensagem que mostramos na Figura 10 desta 
unidade, o que demonstra que o servidor iniciou sem erros. A garantia de que o datasource foi 
configurado corretamente vem através de uma mensagem no console que mostra o nome de 
todos os datasources configurados para aquela instância do servidor de aplicação. No nosso 
caso, devemos buscar pelo nome java:/MYSQL_DS, conforme mostra a Figura 21. 
FIGURA 21 - CONFIGURAÇÃO DEMONSTRADA NO CONSOLE
FONTE: O autor
UNIDADE 1TÓPICO 228
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
4 INTEGRAÇÃO GLASSFISH-MYSQL
Neste tópico, demonstraremos de que forma fazer a integração entre o MySQL e o 
Servidor de aplicações Glassfish através do NetBeans.
ATEN
ÇÃO!
Em nossos exemplos, o Netbeans está configurado para o idioma 
inglês, ao invés do português que é instalado automaticamente. 
Caso deseja trocar o idioma, o procedimento é demonstrado 
em: <http://www.frameworksystem.com/blog/alterando-a-
linguagem-no-netbeans/>.
Inicialmente, acesse a aba Services, demonstrada na Figura 22. Nesta aba, clique com o 
botão direito no mouse na opção Databases, selecionando New Connection. Selecionando esta 
opção, aparecerá uma janela que permitirá selecionar a qual banco de dados nos conectaremos. 
Selecione a opção MySQL e o próprio Netbeans sugerirá um driver, conforme a Figura 23. 
FIGURA 22 - INTEGRAÇÃO GLASSFISH-MYSQL
FONTE: O autor
UNIDADE 1 TÓPICO 2 29
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 23 - MYSQL JDBC DRIVER
FONTE: O autor
Pressione o botão Next e preencha as configurações mostradas na Figura 24 de acordo 
com as configurações do MySQL instalado em seu computador. Ao finalizar as configurações, 
pressione o botão Test Connection e aguarde pela mensagem Conection Succeeded, indicando 
que o Netbeans encontrou o banco de dados e conseguiu se conectar.
ATEN
ÇÃO!
Antes de realizar o procedimento de teste da conexão, certifique-
se de que o MySQL está funcionando corretamente em seu 
computador e de que o mesmo foi inicializado.
UNIDADE 1TÓPICO 230
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 24 - CONFIGURAÇÃO DO MYSQL
FONTE: O autor
Existem algumas configurações adicionais, mas com o objetivo de simplificar o processode configuração, podemos pressionar o botão Finish e aguardar o resultado demonstrado na 
Figura 25. O número 1 mostra a nova conexão com o banco MySQL através de sua adição 
às databases. O número 2 indica os Schemas ou databases disponíveis no banco de dados 
com o qual nos conectamos. Em seu computador, o número dois trará Schemas diferentes 
dos mostrados na Figura.
Em nosso exemplo, a conexão foi renomeada para MYSQL_DS, selecionando a mesma 
com o botão direito e clicando na opção renomear. Este passo é opcional e não interferirá 
diretamente com o resto do procedimento. O importante é você conseguir encontrar a conexão 
que criou dentro do Netbeans.
Seguindo este procedimento, você configurou uma nova conexão com o banco de 
dados MySQL diretamente através do Netbeans. Para fazer a configuração do datasource e 
do pool de conexões, devemos acessar a interface de administrador do Glassfish, disponível 
na url <http://localhost:4848>, sem esquecer de antes inicializar o servidor dentro do Netbeans.
UNIDADE 1 TÓPICO 2 31
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 25 - CONEXÃO COM O MYSQL
FONTE: O autor
Para inicializar o Glassfish, basta ir até a aba Services e escolher a opção Server. Dentre 
os servidores listados, clique com o botão direito do mouse no Glassfish e em seguinda na 
opção Start, conforme a Figura 26. Quando o servidor terminar seu processo de inicialização, 
você pode ir até o navegador web e digitar a URL supracitada.
Pronto! Você agora está na interface de administração do Glassfish (Figura 27). Da 
mesma forma que no WildFly, existem inúmeras configurações que podem ser feitas para 
otimizar o desempenho e performance do servidor de aplicação, mas como este não é o objetivo 
desta disciplina, faremos as configurações mínimas necessárias para o funcionamento dos 
exemplos que utilizaremos.
UNIDADE 1TÓPICO 232
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 26 - INICIALIZAÇÃO DO GLASSFISH
FONTE: O autor
FIGURA 27 - INTERFACE DE ADMINISTRAÇÃO DO GLASSFISH
FONTE: O autor
UNIDADE 1 TÓPICO 2 33
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Uma vez na interface de administração, selecione a opção JDBC/JDBC Connection 
Pools, onde criaremos o pool de conexões para nosso datasource. Um pool de conexões é 
uma espécie de cache de conexões com o banco de dados, mantidas de forma que possam 
ser reutilizadas quando futuras requisições forem feitas, otimizando recursos computacionais. 
A próxima tela lista todos os pools já existentes e, para criar um novo pool, clique no botão 
New. A Figura 28 mostra as configurações do primeiro passo para a criação do pool. Após 
preencher estas configurações, clique em Next.
FIGURA 28 - CONFIGURAÇÃO DO POOL DE CONEXÕES
FONTE: O autor
Na tela seguinte existem vários campos que permitem configuração, mas para nossa 
finalidade, devemos alterar somente as propriedades adicionais listadas na Tabela 1:
TABELA 1 - PROPRIEDADES DO POOL DE CONEXÕES
Propriedade Valor
user <usuário do seu banco de dados MySQL>
ServerName localhost
DatabaseName jee7
Password <senha do seu banco de dados MySQL>
Url jdbc:mysql://localhost:3306/jee7
URL jdbc:mysql://localhost:3306/jee7
FONTE: O autor
Para concluir o processo, clique em Finish e aguarde a criação do novo pool de conexões. 
Ao final, o Glassfish exibirá todos os pools de conexão disponíveis, entre os quais deverá estar 
o que você acabou de criar (Figura 29). 
UNIDADE 1TÓPICO 234
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 29 - LISTAGEM DOS POOLS DE CONEXÃO
FONTE: O autor
Ao clicar no pool recém criado, você será levado a uma tela que permite o teste do mesmo 
através do botão Ping. Se o pool estiver funcionando, haverá uma mensagem informando que 
o ping foi bem sucedido (Figura x).
FIGURA 30 - TESTE DO POOL DE CONEXÕES
FONTE: O autor
Como último passo do processo, precisaremos criar o datasource propriamente dito. Ainda 
na interface de administração do Glassfish, selecione a opção JDBC/JDBC Resources. Nesta 
tela estão listados todos os datasources disponíveis no Glassfish. Para criar um novo, clique no 
botão New e preencha as configurações da tela seguinte conforme demonstrado na Figura 31.
UNIDADE 1 TÓPICO 2 35
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 31 - CONFIGURAÇÃO DO DATASOURCE
FONTE: O autor
ATEN
ÇÃO!
JNDI é o acrônimo de Java Naming and Directory Interface, 
cujo objetivo é permitir a busca de objetos de forma distribuída 
simplesmente através de um nome. Com essa tecnologia, o 
cliente abstrai totalmente os detalhes referentes à implementação 
do recurso que está sendo buscado. Maiores detalhes sobre o 
JNDI podem ser obtidos em: <http://docs.oracle.com/javase/
tutorial/jndi/overview/>.
Assim encerramos o processo de criação dos DataSources nos servidores de aplicação 
e IDEs que você poderá utilizar ao longo da disciplina. Agora estamos prontos para efetivamente 
pôr a “mão na massa” e começar a fazer os exercícios e criar nossas próprias aplicações 
utilizando JEE 7 e os servidores de aplicação WildFly e Glassfish. Caso você queira utilizar 
o Glassfish com o Eclipse ou o WildFly com o Netbeans, basta configurá-los da forma como 
demonstramos ao longo deste tópico.
UNIDADE 1TÓPICO 236
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
RESUMO DO TÓPICO 2
•	 De modo a podermos desenvolver, implantar e testar aplicações que utilizem as tecnologias 
que fazem parte da especificação JEE, precisamos de um servidor de aplicação - application 
server (AS).
•	 Entre as principais opções estão o Wildfly Application Server, disponibilizado pela Red Hat 
e o GlassFish Application Server, disponibilizado pela Oracle.
•	 Para desenvolver aplicações corporativas podemos utilizar o Netbeans ou o Eclipse, bastando 
configurá-lo para acessar o AS.
•	 O servidor de aplicação disponibiliza serviços de persistência através de JDBC, JPA e JTA, 
havendo necessidade de configuração de fontes de dados (Datasources) para que os serviços 
funcionem.
UNIDADE 1 TÓPICO 2 37
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
AUT
OAT
IVID
ADE �
1 Configure as duas IDEs (eclipse e netbeans) para trabalharem ambas com os 
servidores de aplicação GlassFish e WildFly:
2 Configure mais um datasource para cada servidor de aplicação, preferencialmente 
utilizando um banco de dados diferente do MySQL: 
3 Encontre e descreva pelo menos mais três implementações de Servidores de 
Aplicação compatíveis com a especificação JEE 7. Estes servidores de aplicação 
podem ser tanto proprietários como open source.
UNIDADE 1TÓPICO 238
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
JAVA SERVER FACES (JSF)
1 INTRODUÇÃO
TÓPICO 3
O Java Server Faces (JSF) é o framework padrão da plataforma Java para a construção 
de aplicações web com JEE. Ele define e implementa um modelo de componentes visuais 
para WEB, utilizando uma arquitetura MVC (model-view-controller). Esta arquitetura propõe a 
divisão das responsabilidades de uma aplicação em três camadas distintas (Figura 32): 
1. View: responsável pela renderização da interface gráfica da aplicação.
2. Controller: responsável por receber e tratar os eventos da View.
3. Model: responsável pela implementação da lógica de negócios. 
UNIDADE 1
FIGURA 32 - ARQUITETURA MVC
FONTE: Disponível em: <http://stackoverflow.com/questions/29594105/mvc-is-it-model-
to-view-or-controller-to-view>. Acesso em: 20 set. 2015.
UNIDADE 1TÓPICO 340
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Da mesma forma que as demais tecnologias que fazemparte da plataforma Java, o 
JSF é definido por uma especificação mantida pelo JCP através de JSRs. Ele define uma 
API padrão e extensível através de classes e interfaces, simplificando o desenvolvimento e 
aumentando a produtividade de aplicações em Java para Web.
As principais funcionalidades que o JSF traz para uma aplicação web incluem 
(SOFTPLAN, 2015): 
•	 Gerenciamento do ciclo de vida dos componentes visuais e a responsabilidade na geração 
do HTML a partir deles.
•	 Disponibilização de uma biblioteca de componentes visuais básicos análogos aos 
componentes HTML.
•	 Suporte à templates de tela para reuso de estruturas de interfaces Web;
•	 Desenvolvimento de componentes visuais personalizados;
•	 Suporte embutido à ajax.
•	 Validação, conversão e formatação de dados de formulários.
•	 Tratamento de eventos entre telas Web.
•	 Gerenciamento da navegabilidade da aplicação.
O JSF funciona baseado em objetos que são mantidos em memória no servidor e que 
ficam responsáveis pela geração do HTML que será enviado ao navegador. Esta estratégia 
permite que os valores contidos nos componentes mantenham seu estado, permitindo sua 
recuperação mesmo após várias requisições. O objetivo desta arquitetura é a limitação imposta 
pela característica stateless do HTTP.
A Figura 33, retirada de SOFTPLAN (2015), exemplifica o funcionamento do JSF. Imagine 
um cliente que faz uma primeira requisição para uma aplicação web em um AS. O JSF utiliza 
um arquivo no formato xHTML para descrever uma interface da aplicação. Quando o recurso 
representado por esse arquivo é solicitado, uma árvore de componentes é gerada no servidor 
e um HTML é enviado ao cliente. Para as próximas requisições a este recurso pelo mesmo 
cliente, o servidor utiliza a árvore já em memória para montar o HTML. Este processo faz parte 
do ciclo de vida do JSF. 
FIGURA 33 - ARQUITETURA DO JSF
FONTE: SOFTPLAN, 2015 
UNIDADE 1 TÓPICO 3 41
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
2 CRIAÇÃO DA PRIMEIRA APLICAÇÃO
Vamos agora demonstrar como criar uma pequena aplicação utilizando as capacidades 
básicas do JSF. Abra o Eclipse e selecione um projeto do tipo Dynamic Web Project, conforme 
a Figura 34. 
FIGURA 34 - CRIAÇÃO DO PROJETO NO ECLIPSE
FONTE: O autor.
A próxima etapa consiste em configurar o projeto de forma que ele permita a utilização 
das tecnologias que veremos ao longo do caderno. A Figura 35 ilustra a interface de configuração 
deste tipo de projeto. Os números 1, 2 e 3 destacam o nome do projeto, o AS que utilizaremos 
e quais APIs farão parte do projeto, respectivamente. 
Para o nome do projeto, você pode colocar o que achar mais adequado. O Servidor 
de Aplicação que utilizaremos será o mesmo que instalamos no tópico anterior, o WildFly. A 
configuração, entretanto, exige um pouco mais de cuidado. Clicando no botão modify, a imagem 
da Figura 36 permite que selecionemos somente as APIs que utilizaremos no projeto. Para o 
nosso projeto, selecione as mesmas APIs da figura e clique no botão OK.
UNIDADE 1TÓPICO 342
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 35 - CONFIGURAÇÃO DO PROJETO
FONTE: O autor.
De volta a tela principal de configuração, prossiga clicando no botão Next até encontrar 
a tela mostrada na Figura 37. Esta é a tela de configuração da implementação para o JPA. 
Sugerimos configurar exatamente como mostrado na figura, pois embora não iremos utilizar 
JPA no primeiro exemplo, a configuração do mesmo neste momento nos poupará esforço futuro. 
Não se esqueça de configurar também a conexão com o MySQL.
UNIDADE 1 TÓPICO 3 43
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 36 - APIS UTILIZADAS
FONTE: O autor.
FIGURA 37 - CONFIGURAÇÃO DO JPA
FONTE: O autor.
UNIDADE 1TÓPICO 344
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Prossiga pressionando o botão Next até se deparar com a tela mostrada na Figura 38. 
Esta tela configura a geração automática do arquivo beans.xml, necessário para se utilizar 
CDI. Mantenha a configuração como na figura e pressione o botão Finish.
FIGURA 38 - CONFIGURAÇÃO DO CDI
FONTE: O autor
Pronto! A partir de agora utilizaremos este projeto para nossos exemplos. Para conferir 
se a criação foi feita corretamente, basta expandir o projeto recém-criado no Eclipse. A estrutura 
de diretórios deve ficar semelhante à mostrada na Figura 39.
FIGURA 39 - ESTRUTURA DO PROJETO
FONTE: O autor
Para criar nosso primeiro JSF, clique com o botão direito do mouse no diretório 
WebContent e selecione a opção New XHTML Page. Dê o nome formulario.xhtml para a mesma 
e clique no botão Next. Na tela apresentada a seguir, mantenha a configuração mostrada na 
Figura a seguir e clique em Finish. Isso criará um template XHTML vazio para nossa aplicação.
UNIDADE 1 TÓPICO 3 45
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 40 - CONFIGURAÇÃO DO TEMPLATE XHTML
FONTE: O autor
O Eclipse gera um template vazio para uma página XHTML, entretanto, a importação das 
bibliotecas que contém os componentes visuais já está feita. Na Figura 41 podemos perceber 
a existência destas bibliotecas e sua efetiva utilização. 
Entre as linhas 2 e 5 são referenciadas URLs através dos prefixos ui, f e h. Estes 
prefixos servirão para utilizar os componentes visuais, de acordo com sua natureza. Isto 
pode ser percebido através do componente head que aqui ele é <h:head>, o que indica que a 
importação ocorrerá através da URL referenciado no prefixo h.
O exemplo contendo o código fonte completo pode ser visualizado na Figura 42. A linha 
1 foi removida para simplificar o exemplo. Da mesma forma que no HTML, os componentes 
visíveis ficam dentro da tag <body>. Na linha 11 criamos um formulário que contém um Label, um 
InputText e um Button, todos componentes visuais do JSF. O InputText é mapeado diretamente 
para um atributo do formularioMB e o Button é mapeado diretamente para um método do mesmo 
arquivo. No exemplo em questão, não faremos a criação do model e utilizaremos o controller 
para simular esta função.
Note que este mapeamento de um componente de formulário diretamente para um atributo 
UNIDADE 1TÓPICO 346
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
e de um botão diretamente para um método aumenta muito a produtividade no desenvolvimento. 
Em algumas IDEs, é possível inclusive gerar Views e Controllers automaticamente a partir de 
classes de domínio.
FIGURA 41 - IMPORTAÇÃO DAS BIBLIOTECAS
FONTE: O autor
FIGURA 42 - CÓDIGO FONTE DO ARQUIVO JSF
FONTE: O autor
Mas o que é o formularioMB? O JSF funciona através de uma arquitetura MVC, o que exige 
a presença de um intermediário entre o model e a view. Este intermediário é o controller, que no 
caso do JSF é chamado de Managed Bean (MB). Cabe ao MB mapear os componentes para o 
model, instanciar os objetos no lado do servidor e também reagir aos eventos gerados na view.
O MB sempre é uma classe serializável com métodos getters e setters para permitir o 
acesso aos componentes visuais. A figura a seguir mostra o código-fonte de um MB. Inicialmente, 
a anotação named permite que o MB seja visualizado dentro dos arquivos XHTML. É por causa 
desta anotação que conseguimos referenciar métodos públicos e atributos do MB. A anotação 
@RequestScoped indica que o escopo do MB é de request, ou seja, os valores da árvore de 
objetos devem ser mantidos somente durante o request. 
UNIDADE 1 TÓPICO 3 47
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 43 – CÓDIGO-FONTE DO MB
FONTE: O autor
Para este exemplo utilizamos uma String como o objeto de domínio, para fins de 
simplificação. Na verdade, o MB segue a convenção Java Bean: métodos getters esetters para 
todos os atributos, um construtor vazio e a implementação da interface Serializable. O método 
executar serve simplesmente para ilustrarmos o funcionamento do botão. 
Para criar esta classe, expanda o diretório Java Resources de seu projeto e clique com 
o botão direito do mouse no diretório src. Selecione a opção Java Class e copie o código-fonte 
contido na imagem do MB. Atenção para o nome do pacote, pois o utilizaremos nos exemplos 
posteriores. Uma vez que a classe esteja pronta, clique com o botão direito do mouse no arquivo 
formulario.xhml e selecione a opção Run on Server. 
UNIDADE 1TÓPICO 348
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 44 - DEPLOYMENT E EXECUÇÃO DO PROJETO
FONTE: O autor
Ao seguir este procedimento, a aplicação então é exibida no navegador interno do 
Eclipse. Ao testá-la, podemos ver mensagens sendo exibidas no console do AS.
2 CICLO DE VIDA E ESCOPOS DO JSF
Para entendermos de que forma o JSF se comporta na questão da árvore de objetos 
em memória, e consequentemente extrairmos o máximo da tecnologia, é essencial entender 
o ciclo de vida e os escopos do JSF. 
FIGURA 45 - TESTE DA APLICAÇÃO JSF
FONTE: O autor
UNIDADE 1 TÓPICO 3 49
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Conforme SOFTPLAN (2015), o ciclo de vida do JSF é simplesmente a sequência 
dos passos que o Front Controller do JSF executa ao receber uma requisição de um cliente, 
conforme descrito a seguir:
1. O primeiro passo é a restauração da árvore de componentes. Caso seja o primeiro acesso 
daquele cliente, o JSF cria a árvore de acordo com a descrição do arquivo .xhtml. Caso não 
seja o primeiro acesso, a árvore é recuperada da memória no servidor.
2. O segundo passo é a extração dos valores de campos de formulários vindos com a requisição 
e atribuição dos mesmos aos respectivos componentes dentro da árvore, atualizando-os. 
Neste momento ocorre também a conversão dos dados. 
3. O terceiro passo consiste na validação dos valores dos componentes que possuírem regras 
de validação associadas. Por exemplo, um campo obrigatório que é submetido sem nenhum 
valor ou um campo numérico que vem com um valor alfanumérico. Neste passo, caso alguma 
das validações não seja bem sucedida, o JSF interrompe seu ciclo de vida retornando para 
o navegador do usuário com uma mensagem de erro.
4. Caso a validação seja bem sucedida, o próximo passo é atualizar os valores dos campos dentro 
do Managed Bean. Neste momento, todos os métodos setters dentro do MB serão invocados.
5. Neste passo os métodos associados a ações de botões são executados dentro do MB.
6. Aqui o JSF gera o HTML a ser enviado para o usuário com base na árvore de componentes. 
Antes disso, os valores dos componentes são extraídos do MB, através da invocação de todos 
os métodos getters. Quando o processo encerra, o HTML é finalmente enviado ao navegador.
ATEN
ÇÃO!
O Front Controller é um padrão de projeto relacionado a 
aplicações web. Consiste basicamente de um ponto central de 
entrada que gerencia as requisições de usuários. É o que ocorre 
com o JSF. Maiores detalhes podem ser obtidos em: <http://
www.martinfowler.com/eaaCatalog/frontController.html>.
Faremos a seguir algumas modificações em nosso exemplo anterior que permitirão 
a compreensão deste mecanismo. A primeira etapa já está pronta e consiste na impressão 
de uma mensagem no momento em que o construtor vazio do MB é invocado. Colocaremos 
mensagens ainda dentro do método getNome() e do método setNome(), conforme ilustrado 
na Figura 46. 
UNIDADE 1TÓPICO 350
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
Agora faremos novamente a publicação da aplicação, clicando com o botão direito do 
mouse sobre o arquivo formulario.xhtml e selecionando a opção Run As->Run On Server. Essa 
ação permitirá a visualização das alterações em nosso exemplo.
FIGURA 46 - O CICLO DE VIDA DO JSF
FONTE: O autor
Na Figura 47, podemos perceber que a aplicação carregou normalmente no navegador, 
mas o importante é conseguir observar as mensagens do console. Neste caso, o construtor 
do MB foi invocado e também o método getter. É possível ainda notar que duas instâncias do 
MB são criadas, ao invés de somente uma. O motivo para tal comportamento será explicado 
na Unidade 3 deste Caderno de Estudos. 
Mas por que o valor de nome é igual a null? Isso ocorre devido ao próprio ciclo de vida 
do JSF, onde o MB é instanciado e, como esta é a primeira requisição, a árvore de componentes 
deve ser montada com base no arquivo xhtml e alocada na memória. O último passo antes 
de renderizar o HTML é atribuir os valores do MB aos componentes visuais. Como nosso MB 
não possui nenhum valor, o getNome aparece retornando null. 
UNIDADE 1 TÓPICO 3 51
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 47 - CICLO DE VIDA DO JSF
FONTE: O autor
Mas o que acontece quando colocamos um valor para Nome e clicamos em executar? 
Faça o teste em sua aplicação que eu explicarei os resultados obtidos aqui. Depois da primeira 
requisição, ciclo de vida do JSF é executado sempre da mesma forma, como podemos avaliar 
observando a Figura 48. 
Cada número indica um passo do ciclo de vida. A linha destacada pelo número 1 ilustra 
a criação de uma nova instância do MB, enquanto a linha 2 trata da busca da árvore dos 
componentes visuais e dos valores dos atributos do MB. Por enquanto o nome continua nulo. 
Na linha destacada pelo número 3, os métodos setters do MB são invocados e, como agora 
possuímos o valor “Catarina” no componente associado ao nome, o MB recebe este valor. O 
número 4 mostra as duas linhas que são impressas ao invocarmos o método executar. Lembre-
se de que a ação que efetivamente faz essa invocação é o clique no botão. Por fim, o número 
5 trata da renderização dos componentes em HTML para envio ao navegador. Neste passo, o 
valor dos componentes é atualizado com o valor existente no atributo do MB associado através 
da expression language.
UNIDADE 1TÓPICO 352
P
R
O
G
R
A
M
A
Ç
Ã
O
P
A
R
A
W
E
B
II
FIGURA 48 - CONTINUAÇÃO DO CICLO DE VIDA JSF
FONTE: O autor
Cada vez que você clicar no botão Executar, uma nova instância de FormularioMB é criada 
e o getNome retornará null. Este comportamento é característico da annotation @RequestScoped, 
onde uma nova instância de FormularioMB é criada a cada requisição do usuário. Esta anotação 
define que o tempo de vida deste objeto é marcado pela requisição do usuário.
Outro escopo existente é o SessionScope, onde o tempo de vida do MB é marcado pela 
sessão do usuário. Caso nenhuma configuração adicional seja feita, o MB se mantém desde 
pressionarmos o botão até fecharmos o navegador. Este tipo de escopo é interessante para 
guardar uma sessão de login do usuário, garantindo que ele tenha passado por uma página 
e se identificado antes de acessar a parte protegida de uma aplicação. Você já deve ter visto 
aplicações web onde o tempo de sessão é definido em minutos, para aumentar a segurança. Em 
geral, este tipo de configuração é utilizado em aplicações de Home Banking e cartões de crédito. 
Na figura a seguir demonstramos como alterar o escopo de nosso MB para Session. Basta 
alterar a annotation @RequestScoped para @SessionScoped. Perceba que o comportamento 
da primeira e segunda vez que executamos (1) é o mesmo do @RequestScoped, entretanto, 
no terceiro acesso (2), o método getNome busca o valor já existente no MB, agora persistente 
entre as requisições do usuário. No próximo passo, o método setter é invocado e o nome 
Catarina é substituído por Cecilia no MB (3). O método executar é invocado novamente (4) e, 
finalmente, o HTML é renderizado com o valor atualizado no componente, obtido