Apol Programação para Web II

Prévia do material em texto

2016
Programação Para Web II
Prof. Cristiano Roberto Franco
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.
Impresso por:
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. 
III
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.
IV
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 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
V
Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto para 
você que está chegando agora à UNIASSELVI quanto para você que já é veterano, há 
novidades em nosso material.
Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é 
o material base da disciplina. A partir de 2017, nossos livros estão de visual novo, com um 
formato mais prático, que cabe na bolsa e facilita a leitura. 
O conteúdo continua na íntegra, mas a estrutura interna foi aperfeiçoada com nova 
diagramação no texto, aproveitando ao máximo o espaço da página, o que também 
contribui para diminuir a extração de árvores para produção de folhas de papel, por exemplo.
Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente, 
apresenta também este livro no formato digital. Assim, você, acadêmico, tem a possibilidade 
de estudá-lo com versatilidade nas telas do celular, tablet ou computador. 
 
Eu mesmo, UNI, ganhei um novo layout, você me verá frequentemente e surgirei para 
apresentar dicas de vídeos e outras fontes de conhecimento que complementam o assunto 
em questão. 
Todos esses ajustes foram pensados a partir de relatos que recebemos nas pesquisas 
institucionais sobre os materiais impressos, para que você, nossa maior prioridade, possa 
continuar seus estudos com um material de qualidade.
Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de 
Desempenho de Estudantes – ENADE. 
 
Bons estudos!
NOTA
VI
VII
UNIDADE 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION ............................................... 1
TÓPICO 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS 
 TECNOLOGIAS ................................................................................................................ 31 INTRODUÇÃO ..................................................................................................................................... 3
2 PRINCIPAIS TECNOLOGIAS ........................................................................................................... 7
2.1 A ARQUITETURA DOS CONTAINERS ...................................................................................... 9
RESUMO DO TÓPICO 1........................................................................................................................ 11
AUTOATIVIDADE ................................................................................................................................. 12
TÓPICO 2 – CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT .... 13
1 INTRODUÇÃO ..................................................................................................................................... 13
1.1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO – WILDFLY ................................................ 13
2 INSTALAÇÃO DO NETBEANS ........................................................................................................ 19
3 INTEGRAÇÃO WILDFLY-MYSQL ................................................................................................... 22
4 INTEGRAÇÃO GLASSFISH-MYSQL ............................................................................................... 26
RESUMO DO TÓPICO 2........................................................................................................................ 34
AUTOATIVIDADE ................................................................................................................................. 35
TÓPICO 3 – JAVA SERVER FACES (JSF) ........................................................................................... 37
1 INTRODUÇÃO ..................................................................................................................................... 37
2 CRIAÇÃO DA PRIMEIRA APLICAÇÃO ........................................................................................ 39
3 CICLO DE VIDA E ESCOPOS DO JSF ............................................................................................ 46
LEITURA COMPLEMENTAR ............................................................................................................... 53
RESUMO DO TÓPICO 3........................................................................................................................ 57
AUTOATIVIDADE ................................................................................................................................. 58
UNIDADE 2 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES E JAVA 
 PERSISTENCE API ....................................................................................................... 59
TÓPICO 1 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES ....................................... 61
1 INTRODUÇÃO ..................................................................................................................................... 61
2 COMPONENTES DE FORMULÁRIO ............................................................................................. 61
3 TABELAS ................................................................................................................................................ 73
4 SUPORTE NATIVO A AJAX .............................................................................................................. 78
5 ADICIONANDO UMA BIBLIOTECA EXTERNA DE COMPONENTES VISUAIS .............. 80
RESUMO DO TÓPICO 1........................................................................................................................ 90
AUTOATIVIDADE ................................................................................................................................. 91
TÓPICO 2 – JAVA PERSISTENCE API ............................................................................................... 93
1 INTRODUÇÃO ..................................................................................................................................... 93
2 MAPEAMENTO OBJETO RELACIONAL ...................................................................................... 94
2.1 ARQUITETURA DO DATA ACCESS OBJECT ............................................................................ 96
sumárIo
VIII
3 JAVA PERSISTENCE API (JPA) ......................................................................................................... 98
4 CONCEITOS E INTERFACES DO JPA ............................................................................................ 99
4.1 MAPEAMENTO DE ENTIDADES .............................................................................................100
4.2 RELACIONAMENTOS ENTRE ENTIDADES ..........................................................................111
LEITURA COMPLEMENTAR .............................................................................................................114
RESUMO DO TÓPICO 2......................................................................................................................125
AUTOATIVIDADE ...............................................................................................................................127
UNIDADE 3 – ENTERPRISE JAVA BEANS (EJB) E CONTEXT AND DEPENDENCY 
 INJECTION (CDI) ........................................................................................................129
TÓPICO 1 – STATELESS SESSION BEANS ....................................................................................131
1 INTRODUÇÃO ...................................................................................................................................131
2 STATELESS SESSION BEANS ...........................................................................................................132
2.1 EJB 3.0 ..............................................................................................................................................132
2.2 EJB 3.1 ..............................................................................................................................................134
2.3 TESTANDO O EJB .........................................................................................................................135
2.4 CICLO DE VIDA ............................................................................................................................138
2.5 ESCALABILIDADE, POOL E CALL-BACKS .............................................................................139
2.6 MÉTODOS ASSÍNCRONOS ........................................................................................................140
RESUMO DO TÓPICO 1......................................................................................................................142
AUTOATIVIDADE ...............................................................................................................................143
TÓPICO 2 – STATEFUL SESSION BEAN E SINGLETON SESSION BEANS ..............................145
1 INTRODUÇÃO ...................................................................................................................................145
2 STATEFULL SESSION BEANS 3.0 ....................................................................................................146
3 STATEFULL SESSION BEANS 3.1 ..................................................................................................147
3.1 CICLO DE VIDA DOS STATEFULL SESSION BEANS ............................................................147
3.2 CALLBACKS....................................................................................................................................150
4 SINGLETON SESSION BEANS ........................................................................................................1504.1 CICLO DE VIDA ............................................................................................................................152
RESUMO DO TÓPICO 2......................................................................................................................154
AUTOATIVIDADE ...............................................................................................................................155
TÓPICO 3 – CONTEXT AND DEPENDENCY INJECTION ...........................................................157
1 INTRODUÇÃO ...................................................................................................................................157
2 PRODUCER METHODS E ATTRIBUTES .......................................................................................158
3 EXPRESSION LANGUAGE (EL) NAME .........................................................................................159
4 ESCOPOS E CONTEXTOS ...............................................................................................................160
RESUMO DO TÓPICO 3......................................................................................................................162
AUTOATIVIDADE ...............................................................................................................................163
TÓPICO 4 – JAVA MESSAGE SERVICE (JMS)............................................................................... 165
1 INTRODUÇÃO ...................................................................................................................................165
2 FILAS E TÓPICOS ..............................................................................................................................165
3 MODOS DE RECEBIMENTO .....................................................................................................169
LEITURA COMPLEMENTAR .............................................................................................................173
RESUMO DO TÓPICO 4......................................................................................................................183
AUTOATIVIDADE ...............................................................................................................................184
REFERÊNCIAS .......................................................................................................................................185
1
UNIDADE 1
INTRODUÇÃO AO JAVA
ENTERPRISE EDITION
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
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.
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.
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)
2
3
TÓPICO 1
UNIDADE 1
INTRODUÇÃO AO JAVA ENTERPRISE EDITION
E PRINCIPAIS TECNOLOGIAS
1 INTRODUÇÃO
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).
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/>.
IMPORTANT
E
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:
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.
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
4
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 a lógica de negócio diretamente, sem esse 
intermédio. Esta camada poderia ainda ser representada por tecnologias como 
TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS
5
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.
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>.
IMPORTANT
E
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
6
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 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.
TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS
7
• 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.
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.
IMPORTANT
E
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. 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.
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
8
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.
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.
IMPORTANT
E
Context and Dependency Injection for JavaEE (CDI): Define um conjunto 
de serviços do JEE acessíveis via contexto. Projetado para uso com objetos que 
possuam estado, o CDI 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 
TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS
9
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ções de 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.
FIGURA 2 - RELACIONAMENTO ENTRE CONTAINERS
FONTE: Oracle (2014)
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
10
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 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!
11
Neste tópico você viu que:
• 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.
RESUMO DO TÓPICO 1
12
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.
AUTOATIVIDADE
13
TÓPICO 2
CONSTRUÇÃO DO AMBIENTE DE
DESENVOLVIMENTO E EPLOYMENT
UNIDADE 1
1 INTRODUÇÃO
1.1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO – WILDFLY
Conforme vimosnos 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.
O projeto WildFly pode ser acessado através da URL: <http://wildfly.org>.
NOTA
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 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
14
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
15
FIGURA 5 - SELEÇÃO DA ABA SERVERS NO ECLIPSE
FONTE: O autor
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
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
16
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
17
FONTE: O autor
FONTE: O autor
FIGURA 8 - INSTALAÇÃO DO WILDFLY
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
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
18
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
FONTE: O autor
FONTE: O autor
FIGURA 11 - PÁGINA INICIAL DO WILDFLY EXECUTANDO EM LOCALHOST
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.
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
19
FONTE: O autor
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
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 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
20
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
21
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. OEclipse é melhor em algumas atividades 
e o NetBeans em outras. Com o tempo e a utilização, você elegerá a sua favorita.
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
22
FIGURA 16 - INTERFACE DO NETBEANS
FONTE: O autor
Tutoriais sobre o NetBeans podem ser acessados gratuitamente no endereço:
<https://netbeans.org/kb/docs/java/quickstart-gui.html>.
ATENCAO
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 Sources permitem 
que uma única configuração JDBC seja utilizada por diversas aplicações. Eles 
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
23
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 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
24
FIGURA 18 - LOCAL DO DRIVER JDBC
FONTE: O autor
FONTE: O autor
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
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
25
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
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
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
26
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.
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/>.
ATENCAO
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
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
27
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.
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.
ATENCAO
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
28
FIGURA 24 - CONFIGURAÇÃO DO MYSQL
FONTE: O autor
Existem algumas configurações adicionais, mas com o objetivo de 
simplificar o processo de 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 datasourcee 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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
29
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 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
30
FIGURA 26 - INICIALIZAÇÃO DO GLASSFISH
FONTE: O autor
FONTE: O autor
FIGURA 27 - INTERFACE DE ADMINISTRAÇÃO DO GLASSFISH
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
31
FONTE: O autor
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
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
FONTE: O autor
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
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 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
32
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 30).
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.
TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT
33
FIGURA 31 - CONFIGURAÇÃO DO DATASOURCE
FONTE: O autor
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/>.
ATENCAO
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.
34
RESUMO DO TÓPICO 2
 Neste tópico você viu que:
• 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.
35
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.
AUTOATIVIDADE
36
37
TÓPICO 3
JAVA SERVER FACES (JSF)
UNIDADE 1
1 INTRODUÇÃO
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. 
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.
38
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
Da mesma forma que as demais tecnologias que fazem parte 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 daaplicaçã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 
TÓPICO 3 | JAVA SERVER FACES (JSF)
39
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.
40
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
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.
TÓPICO 3 | JAVA SERVER FACES (JSF)
41
FIGURA 36 - APIS UTILIZADAS
FONTE: O autor.
FIGURA 37 - CONFIGURAÇÃO DO JPA
FONTE: O autor.
42
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
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
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
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.
TÓPICO 3 | JAVA SERVER FACES (JSF)
43
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.
44
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
Note que este mapeamento de um componente de formulário diretamente 
para um atributo 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. 
TÓPICO 3 | JAVA SERVER FACES (JSF)
45
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 e setters 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. 
46
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
FIGURA 44 - DEPLOYMENT E EXECUÇÃO DO PROJETO
FONTE: O autor
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.
3 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
TÓPICO 3 | JAVA SERVER FACES (JSF)
47
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 campoobrigató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.
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>.
ATENCAO
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. 
48
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
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. 
TÓPICO 3 | JAVA SERVER FACES (JSF)
49
FONTE: O autor
FIGURA 47 - CICLO DE VIDA DO JSF
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.
50
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
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 através do 
método getNome (5).
TÓPICO 3 | JAVA SERVER FACES (JSF)
51
FONTE: O autor
FIGURA 49 - MANAGED BEAN COM ESCOPO DE SESSÃO
Uma experiência interessante para comprovar o funcionamento deste 
escopo é pegar a URL do navegador interno do Eclipse, copiá-la e acessar a 
aplicação através de um navegador externo. Mas espere aí... os valores que eu 
coloquei não aparecem fora do Eclipse. Isto ocorre porque o AS trata este acesso 
como um segundo acesso feito por outro usuário. Se você observar os logs do 
servidor, perceberá que ele obedecerá o mesmo ciclo de vida. Mas e por que ele 
não cria uma nova instância do MB? Isto significa que os valores se confundirão 
entre os usuários? Vou responder a esta pergunta com outra. Você se lembra 
de quando acessamos nossa aplicação pela primeira vez e o servidor criou duas 
instâncias do FormularioMB? O segundo usuário está acessando nossa aplicação 
através daquela segunda instância, que o AS já criou para evitar o overhead 
de instanciação de um novo objeto e melhorar a performance da aplicação. 
Lembrando que esta característica é configurável. 
A última experiência consiste em abrir uma instância da aplicação através 
de outro navegador (se você abriu o Chrome, tente acessar a aplicação do Firefox 
e, em último caso, do Internet Explorer). Observando o log no console, percebemos 
que o mesmo mostra a criação de uma nova instância do FormularioMB, pois para o 
servidor somos um novo usuário e nossas duas instâncias iniciais já estão ocupadas.
52
UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION
Existem outros escopos no JSF além do Request e Session. Para maiores detalhes 
acesse: http://uaihebert.com/jsf-mini-livro-dicas-conceitos-e-boas-praticas/
ATENCAO
Nesta unidade percorremos bastante conteúdo... entendemos o contexto 
onde são aplicadas as aplicações JEE, compreendemos a necessidade de um 
servidor de aplicação, criamos e configuramos um ambiente para a criação 
de aplicações enterprise e, por fim, introduzimos as Java Server Faces de forma 
prática, enfatizando a caracterização de sua arquitetura e seu ciclo de vida. Nas 
próximas unidades abordaremos aspectos avançados de JSF e demonstraremos 
o funcionamento de outras tecnologias chave que fazem parte da especificação 
JEE, como CDI e EJB. Novamente queremos destacar a necessidade de realização 
das autoatividades e de todas as implementações que são solicitadas no caderno. 
É somente