Laboratório de Programação I

Wagner Mendes Voltz

Código Logístico Fundação Biblioteca Nacional

ISBN 978-65-5821-025-2

I000018 9 786558 210252

Laboratório de
Programação II

Wagner Mendes Voltz

IESDE BRASIL
2021
© 2021 – IESDE BRASIL S/A.
É proibida a reprodução, mesmo parcial, por qualquer processo, sem autorização por escrito do autor e do
detentor dos direitos autorais.
Projeto de capa: IESDE BRASIL S/A. Imagem da capa: Shemul/envato elements

CIP-BRASIL. CATALOGAÇÃO NA PUBLICAÇÃO

SINDICATO NACIONAL DOS EDITORES DE LIVROS, RJ
V899L

Voltz, Wagner Mendes

Laboratório de programação II / Wagner Mendes Voltz. - 1. ed. - Curi-
tiba [PR] : Iesde, 2021.
106 p. : il.
Inclui bibliografia
ISBN 978-65-5821-025-2

1. Java (Linguagem de programação de computador). 2. Programação

de sistemas (Computação). 3. Linguagem de programação (Computadores).
I. Título.
CDD: 005.4
21-70716
CDU: 004.45

Todos os direitos reservados.

IESDE BRASIL S/A.

Al. Dr. Carlos de Carvalho, 1.482. CEP: 80730-200
Batel – Curitiba – PR
0800 708 88 88 – www.iesde.com.br
Wagner Mendes Voltz Especialista em Administração com ênfase em
Gestão da Tecnologia da Informação pela Faculdade
de Administração e Economia (FAE). Graduado em
Tecnologia em Informática pela Universidade Federal
do Paraná (UFPR). Atua como professor desde
2012 e como analista de sistemas desde 2005. Tem
experiência na área de ciência da computação com
ênfase em metodologia e técnicas de computação.
Ministra as disciplinas de Programação Orientada
a Objetos, Desenvolvimento em Java com Testes
Unitários, Desenvolvimento em Java Web, Padrões de
Projeto, Desenvolvimento em Android, Qualidade de
Código-Fonte, Metodologias Ágeis, Gestão da Qualidade
em Projetos e Sistemas Operacionais.
Vídeos
em
QR code!
Agora é possível acessar os vídeos do livro por
meio de QR codes (códigos de barras) presentes
no início de cada seção de capítulo.

Acesse os vídeos automaticamente, direcionando

a câmera fotográfica de seu smartphone ou tablet
para o QR code.

Em alguns dispositivos é necessário ter instalado

um leitor de QR code, que pode ser adquirido
gratuitamente em lojas de aplicativos.
 SUMÁRIO
1 Introdução a Java Web 9
1.1 Java Web 9
1.2 Maven 14
1.3 Servidores Web 20

2 Criando páginas web com Java 30

2.1 JSF e configuração 30
2.2 Primeira tela com JSF 37
2.3 Outros componentes em JSF 44

3 Criando páginas avançadas com Java 47

3.1 Listando dados com JSF 47
3.2 Inserindo, atualizando e removendo dados com JSF 58
3.3 Utilizando Scope 68

4 Arquitetura e persistência de dados com Java 71

4.1 Modelo MVC 71
4.2 Mapeamento objeto-relacional (ORM) 74
4.3 Hibernate e JPA 76
4.4 Configurando Hibernate e JPA 78

5 Anotações do JPA e injeção de dependência 83

5.1 Anotações do Hibernate e JPA 83
5.2 Gerenciando conexões 90
5.3 Utilizando injeção de dependência com Spring 93

Gabarito 103

Referências 106
Vídeo
APRESENTAÇÃO
Prezado aluno,
Este livro foi elaborado visando gerar uma experiência
prática por meio da construção de um software na linguagem de
programação Java que possa ser acessível de qualquer navegador
web e dispositivo móvel.
Para que essa jornada seja a mais completa possível,
apresentaremos os conceitos de Java Enterprise Edition (Java EE ou
JEE) e usaremos as principais bibliotecas para termos um software
Java Web. Todas as conceituações terão um bloco de código-fonte,
o qual será nosso aliado durante toda a leitura da obra. Para facilitar
o entendimento do código-fonte, ele estará à disposição no livro,
podendo ser validado na plataforma GitHub.
No primeiro capítulo, aprenderemos os conceitos das
aplicações Java Web e como elas são diferentes das aplicações
Java Desktop. Além disso, conheceremos mais a respeito do
gerenciador de dependências Maven e do contêiner Apache
Tomcat. Ambas as ferramentas são essenciais para termos um
sistema web utilizando Java.
Na sequência, no segundo capítulo, mergulharemos na criação
de sistemas web e de páginas web que funcionarão em qualquer
navegador, independentemente de o usuário estar usando um
tablet, um celular ou um notebook. Para isso, usaremos o JSF e
o Bootstrap. Esses conceitos ficarão mais avançados no terceiro
capítulo, quando criaremos telas que realizarão a inclusão,
remoção, listagem e edição de dados cadastrados pelo usuário.
No quarto e quinto capítulos, vincularemos o software web
a um banco de dados, permitindo que o usuário não perca
os dados cadastrados durante o uso. Para isso, usaremos a
biblioteca JPA e o Hibernate.
Durante toda a leitura, você encontrará diversos códigos-fonte
e suas respectivas explicações. Não tenha receio de copiá-los,
mas tente entender o que cada bloco ou palavra reservada
 faz. Se você somente reproduzir o código sem entendê-lo, prejudicará a sua
capacidade de interpretá-lo com qualidade.
Após a leitura, esperamos que você consiga criar programas Java que
serão acessados na web e que usarão banco de dados. E aí, animado para
essa aventura?
Bons estudos!

8 Laboratório de Programação II
 1
Introdução a Java Web
No mundo globalizado em que vivemos, interligado por redes
de dados, em especial pela internet, é até difícil imaginar algum
software que não as utilize. Diariamente, fazemos o uso de diver-
sos sites para realizar as atividades rotineiras, em vez de instalar-
mos um programa específico em nossos computadores. O maior
uso de softwares na internet é o foco do nosso estudo.
Neste capítulo, conheceremos as diferenças entre a criação de
softwares utilizando Java e a criação de software utilizando Java
Web. Além disso, criaremos nosso primeiro software, que será
acessado via navegador web. Prepare-se para desenvolver solu-
ções ricas e interativas na internet com Java Web.

1.1 Java Web

Vídeo A linguagem de programação Java é muito completa e por isso é
complexo o entendimento de suas diversas características e siglas.
Dentre as diversas siglas, encontramos JSE, JEE e JME, que represen-
tam as plataformas de desenvolvimento suportadas pela linguagem.
A seguir, detalharemos cada uma delas.
• JSE – Java Standard Edition:

• Contém os recursos básicos da linguagem Java, que incluem

os pacotes java.lang, java.io, java.util, entre outros.
• Normalmente, começamos a aprender Java utilizando JSE.
• Costuma ser utilizado para a criação de softwares que serão
instalados ou executados em computadores pessoais e não
acessarão a internet nem utilizarão base de dados.

Introdução a Java Web 9

 • JEE – Java Enterprise Edition:

• Utilizado para o desenvolvimento de aplicações corporativas

com recursos mais complexos, como persistência em banco
de dados, transação de dados, web services, gerenciamento de
threads, gerenciamento de conexões HTTP e gerenciamento
da sessão web.
• Composto de JSE e um conjunto de protocolos, também
chamados de APIs. Estes permitem o desenvolvimento de
aplicativos Java utilizando web, banco de dados, segurança
nas transações e outras funcionalidades. Com JEE, o
desenvolvimento de um aplicativo fica simplificado, pois será
possível reaproveitar módulos e componentes já definidos na
plataforma de desenvolvimento.
• JME – Java Micro Edition:

• Versão enxuta do JSE para ser utilizada em dispositivos com

baixo poder de processamento ou sistemas embarcados.
• Não possui interface gráfica de interação.
• Encontrado em smart TVs, aparelhos de DVD, SIM cards
(utilizados em smartphones e celulares), entre outros.
Antigamente, o número 2 era utilizado nessas siglas, mas esse pa-
drão entrou em desuso. Caso você encontre, em suas pesquisas, algo
como J2SE, J2EE ou J2ME, saiba que se trata do mesmo conteúdo que
estamos estudando. Em 2020, o projeto JEE, que começará a se chamar
JakartaEE, foi cedido pela Oracle para a Fundação Eclipse. No momento,
seguiremos com a convenção mais utilizada: JEE.

Um detalhe importante é não confundir essas siglas com JRE, JDK e

JVM, que se referem ao conjunto básico para executar um programa
Java (JRE e JVM) ou, então, para criar programas em Java (JDK).

Como focaremos no desenvolvimento de soluções para a web, va-

mos nos aprofundar no JEE, uma plataforma de desenvolvimento que
visa permitir aplicativos seguros, escaláveis e altamente disponíveis
(BOND, 2003). Ela define quais serviços deverão ser fornecidos pelos
softwares chamados servidores de aplicação, os quais são instalados
em computadores do tipo servidor e permitem que qualquer pessoa
acesse o programa desenvolvido em Java, por meio de um endereço na
web. A seguir, listaremos os nomes de alguns servidores de aplicação.

10 Laboratório de Programação II
 • Apache TomEE
• Oracle WebLogic
• IBM WebSphere
• WildFly (antigo RedHat JBoss)
• Apache Geronimo
• Oracle GlassFish

É erro comum achar que um servidor de aplicação é o mesmo que

um contêiner. Este contém algumas especificações de JEE, já o servidor de
aplicação contém todas as especificações, mas separadas por contêine-
res. O contêiner mais conhecido (e que usaremos em nossos estudos) é
o Apache Tomcat, considerado um servlet container, pois ele lida somente
com as especificações necessárias para o desenvolvimento na web.

Agora, listaremos os serviços definidos no JEE. São eles:

• Para trabalhar na web:

• Costumam ser chamados servlets.

• Java Server Faces (JSF).
• Java Server Pages (JSP).
• Java Servlets.
• Para acessar e persistir dados em banco de dados:

• Java Database Connectivity (JDBC).

• Java Persistence API (JPA).
• Para o desenvolvimento de componentes de software:

• Enterprise Java Beans (EJB).

• Para trabalhar com arquivos XML e webservices:

• Java API for XML Web Services (JAX-WS).

• Java API for XML Binding (JAX-B).
• Para trabalhar com autenticação e segurança de dados:

• Java Authentication and Authorization Service (JAAS).

• Para controle de transação no contêiner:

• Java Transaction API (JTA).

• Para comunicação entre aplicações de maneira assíncrona, com
o uso de mensagens ou e-mail:

• Java Message Service (JMS).

Introdução a Java Web 11

 • Para acessar diretórios:

• Java Naming and Directory Interface (JNDI).

• Para administração da aplicação e estatística:

• Java Management Extensions (JMX).

• Para integração entre servidores e sistemas legados

• Java Connector Architecture (JCA).

A fim de fixarmos esses diversos conceitos, apresentamos a Figura
1. Perceba que há o servidor de aplicação JEE e dentro dele temos dois
contêineres: um para a parte web e outro para os componentes de
programação (EJB).
Figura 1
Organização proposta pelo JEE para fluxo de dados

Servidor de aplicação
JEE

Navegador Contêiner web – Apache

web Tomcat

Página JSF Página JSP

Banco de
dados

App Java Contêiner EJB

Bean Bean
corporativo corporativo

Fonte: Elaborada pelo autor.

Perceba que o navegador web (que pode ser o Google Chrome ou o

Mozilla Firefox, por exemplo) acessou o contêiner web (no nosso caso,
o Apache Tomcat). Já um outro programa Java, que não foi desenvolvi-
do usando JSP ou JSF, acessou diretamente o contêiner EJB via protoco-
lo de rede local.

Outro detalhe importante nessa figura: o servidor de aplicação é

responsável por acessar a base de dados, não o navegador nem o
programa Java. Por fim, é importante notarmos que o contêiner web
se comunica com o contêiner EJB para acessar a lógica do negócio.

12 Laboratório de Programação II
Essa organização é chamada de camada. O padrão JEE propõe quatro
camadas. São elas:
• Client Tier.
• Web Tier.
• Business Tier.
• Enterprise Information System Tier (EIS Tier).

A camada do cliente (client tier) não é controlada pelo JEE, sendo

ela basicamente o computador do usuário que acessará algum re-
curso do servidor de aplicação JEE. O usuário fará isso por meio de
um navegador web ou de algum outro aplicativo Java. A camada web
(web-tier) fornece uma página web implementada por um JSF ou JSP,
fazendo a ligação do navegador web com a camada de negócios.

A camada de negócios (business-tier) encapsula a lógica do negó-

cio. É aqui que são definidas todas as regras, determinada a aloca-
ção de recursos e feita a validação de dados. Por fim, a camada EIS
abrange os bancos de dados, a conectividade e a integração entre
aplicação e base de dados. Na Figura 2, detalharemos o lugar de
cada camada.
Figura 2
Camadas propostas no JEE

Servidor de aplicação
JEE
Vídeo
Navegador Contêiner web – web tier
web Para conhecer melhor
o projeto JakartaEE,
Página JSF Página JSP mantido pela fundação
EIS tier
Eclipse, assista ao vídeo
25 anos de Java: Jakarta
Client tier
Banco de EE: O que todo dev precisar
dados saber para utilizá-lo com
Rhuan Rocha, publicado
Contêiner EJB – pelo canal SouJava. O
App Java business tier conteúdo dará sequência
Bean Bean na evolução do JavaEE.

corporativo corporativo Disponível em: https://

www.youtube.com/
watch?v=Mrth_6rbKXg. Acesso
em: 8 fev. 2021.
Fonte: Elaborada pelo autor.

Introdução a Java Web 13

 Conhecer e dominar essas informações são passos importantes
para a sequência de nossos estudos. Podem parecer complicadas as
diversas siglas e os conceitos, mas visite esse tópico sempre que ficar
em dúvida. Com a repetição e a prática, logo você dominará o JEE.

1.2 Maven
Vídeo Para criarmos programas utilizando JEE, precisamos ter os softwa-
res Java Developer Kit (JDK), na versão 8 ou superior, e interface de
desenvolvimento (IDE), com suporte a JEE, configurados em nossos
computadores.

Utilizaremos a OpenJDK, na versão 11.0.9.1; para a escrita do có-

digo-fonte, usaremos o Eclipse IDE for Enterprise Java Developers, na
versão 2020-09. Não há problema fazermos uso de JDK da Oracle ou
outra IDE, como o IntelliJ, pois os exemplos deste material são inde-
pendentes de IDE e serão suportados em diversas versões do Java (a
partir da versão 8 da JDK). Para que isso seja possível, utilizaremos o
programa Apache Maven, chamado, também, simplesmente Maven.

Sendo uma ferramenta de automação de compilação de diversas

linguagens de programação, como Java, C#, Ruby e Scala, o Maven
precisa ser instalado em seu computador, o que permitirá que o pro-
jeto Java fique independente de IDE. Ele consegue fazer isso porque
trabalha com um arquivo XML de configuração (pom.xml), o qual é
composto das diversas configurações do software que está sendo de-
senvolvido. Nele, definimos as bibliotecas de dependência e os plu-
gins necessários para que o projeto funcione.

Desse modo, para termos acesso à base de dados, precisaremos

colocar informações do JDBC no arquivo pom.xml; faremos o mes-
mo ao utilizar o JSF para criar páginas na web. Adicionaremos as
informações dessa biblioteca no arquivo pom.xml e, quando isso for
realizado, o Maven, automaticamente, procurará na internet onde
estão essas configurações do JDBC ou do JSF e fará o download para
a sua máquina; assim, você poderá seguir com o desenvolvimento
do software. Sem o Maven, será necessário encontrar o site correto
para baixar o JDBC ou JSF. Esse trabalho pode ser custoso e difícil
de fazer manutenção, já que muitas bibliotecas de software mudam

14 Laboratório de Programação II
 Vídeo
o endereço no qual estão hospedadas ou, então, têm suas versões Para configurar o Maven no
Linux, utilize o tutorial do link
alteradas.
a seguir.
Para utilizar o Maven, precisamos executar os seguintes passos: Disponível em: https://medium.
com/@andgomes/instalando-
• Fazer o download no site https://maven.apache.org/ -o-apache-maven-no-ubuntu-
-de4a95a5975a. Acesso em: 5
• Clicar na opção download (ou acessar o link direto https://ma- maio 2021.
ven.apache.org/download.cgi) e
• Selecionar, em Files, a opção Binary zip archive.

As figuras a seguir mostram as telas de download do Maven para

Microsoft Windows e para Linux.
Figura 3
Download do Maven para Microsoft Windows

Figura 4
Download do Maven para Linux

Para Linux, selecione a opção Binary tar.gz archive. Vídeo

O vídeo Java: Instalando
1. Após o download, clique duas vezes no arquivo para descompactar
e Configurando o Apache
o Maven no local que você desejar. Na sequência, configure uma Maven no Windows, do
variável de ambiente em seu sistema operacional, para que ele canal Loiane Graner,
apresenta um tutorial
reconheça a palavra mvn como um programa a ser utilizado por para configurar o Maven
linha de comando. no Windows.

2. Para validar se a instalação foi bem-sucedida, abra uma tela de Disponível em: https://www.
youtube.com/watch?v=-
comando (prompt de comando ou terminal) e digite mvn-version. ucX5w8Zm8s. Acesso em: 8 fev.
2021.
A figura a seguir mostra como configurar o Apache Maven no Linux.

Introdução a Java Web 15

 Figura 5
Configuração do Apache Maven no Linux

Fonte: software Prompt de comando

3. Caso sejam apresentados dados da versão do Apache Maven, a
instalação e configuração foram bem-sucedidas.

Agora que o Maven está configurado, vamos criar o nosso primeiro pro-
jeto usando Java EE. Como estamos usando o Maven, criaremos o projeto
por ele, não pelo Eclipse IDE. Para criar o projeto web, siga os passos a seguir:
1. Abra uma tela de comando (terminal ou prompt de comando)
e escolha a pasta na qual você armazenará o código-fonte do
projeto. No exemplo aqui, usaremos a pasta c:\java\.
2. Digite o comando a seguir para criar o projeto Java Web:
mvn archetype:generate -DgroupId=br.com.aula
-DartifactId=primeiroprojeto -DarchetypeArtifactId=maven-
archetype-webapp -DinteractiveMode=false
3. Ao pressionar a tecla Enter, alguns downloads serão realizados,
já que o Maven buscará na web tudo o que for necessário para
você seguir com a programação de um projeto Java Web básico.
Em alguns computadores, o download não será realizado, pois o
Maven já foi utilizado em algum outro momento, e os arquivos já
se encontram em seu computador.
4. Caso tenha dado certo, a mensagem BUILD SUCCESS será
apresentada (Figura 6).
Figura 6
Resultado de sucesso na criação do projeto

Fonte: software Prompt de comando

16 Laboratório de Programação II
 5. Caso ocorra algum erro, a mensagem de BUILD FAIL, com a
descrição do erro, aparecerá. Leia com calma o relatório do erro
para saber o que precisa ser configurado.

Agora importaremos o projeto para o Eclipse IDE, a fim de analisar-

mos o arquivo pom.xml. Para isso, execute os seguintes passos:
1. Abra o Eclipse IDE.
2. Escolha o local em que o seu workspace ficará.
3. Selecione o menu File Import, então uma caixa de seleção será
aberta.
4. Selecione a opção Maven Existing Maven Projects.

A figura a seguir apresenta a tela de importação do projeto Maven

no Eclipse IDE.
Figura 7
Importando o projeto Maven no Eclipse IDE

Fonte: software Eclipse IDE

Introdução a Java Web 17

 5. Selecione o diretório em que o projeto Maven foi criado; no nosso
exemplo: C:/Java/primeiroprojeto.

Veja a seguir, na Figura 8, a tela do Eclipse IDE para seleção do pro-

jeto a ser importado.
Figura 8
Selecionando o projeto para ser importado

Fonte: software Eclipse IDE

6. Clique no botão Finish, para finalizar a importação do projeto.

Caso alguma mensagem de erro seja apresentada no Eclipse, na

aba Makers, ignore-a, pois vamos resolvê-la na sequência.

Para finalizarmos o tópico, vejamos o arquivo pom.xml (Figura 9).

Clique nele duas vezes para visualizar o conteúdo.

18 Laboratório de Programação II
 Figura 9
Arquivo pom.xml

Fonte: software Eclipse IDE

Perceba que existe uma configuração referente ao JUnit, que é a bi-

blioteca para testes unitários. A configuração sugerida pelo Maven está
desatualizada, por isso precisaremos mudar as informações das tags
groupId, artifactId e version. Mude esse trecho de código para:

<dependency> Leitura
<groupId>org.junit.jupiter</groupId> No blog Caelum, leia
o texto Processo de
<artifactId>junit-jupiter-api</artifactId> build com o Maven, de
Lucas Cavalcanti. O autor
<version>5.7.0</version> apresenta os detalhes
da ferramenta Maven,
<scope>test</scope> que ajudará você no
desenvolvimento de
</dependency> software JEE.

Ao salvar o arquivo pom.xml, o Maven automaticamente fará o do- Disponível em: https://blog.caelum.
wnload na internet da versão 5.7.0 do JUnit. Perceba que você não pre- com.br/processo-de-build-com-o-
maven/. Acesso em: 8 fev. 2021.
cisa informar em qual site está essa biblioteca, pois o programa faz
pesquisas em repositórios de arquivos pré-definidos, sendo o MVN
Reposiory (https://mvnrepository.com/) um dos mais utilizados. Na prática

Com esses aprendizados do Maven, o projeto criado poderá ser im- Para saber mais sobre a criação
de projetos web com Maven,
portado em qualquer outra IDE. Essa ferramenta traz muitos benefícios acesse o link a seguir.
e facilidades para o desenvolvimento de software e, por isso, tornou-se Disponível em: https://mkyong.
um padrão de mercado. Aprofundar-se no tema ajudará na maximiza- com/maven/how-to-create-a-we-
b-application-project-with-maven/.
ção do uso dessa ferramenta. Acesso em: 3 maio 2021.

Introdução a Java Web 19

 1.3 Servidores Web
Até o momento, aprendemos como construir um projeto Java Web
Vídeo
por meio de um gerenciador de dependências, o Apache Maven. Já vi-
mos, também, como alterar as configurações do projeto com mudanças
realizadas no pom.xml. Agora, dois passos precisam ser realizados:
• gerar a versão do projeto ou fazer o build do projeto, como cos-
tumeiramente é falado;
• executar, com essa versão gerada, a versão em um Servlet
Container; com isso, poderemos acessar o nosso software via na-
vegador web.

Para gerar uma versão, você pode escolher duas opções: ou por
linha de comando ou dentro da própria IDE. Vamos começar com a
opção de linha de comando. Para isso:
1. abra uma janela de comando (prompt de comando ou terminal);
2. acesse a pasta do projeto (C:\java\primeiroprojeto, caso seja Windows);
3. digite o comando mvn clean install.

Caso tudo dê certo, a mensagem BUILD SUCCESS será apresentada.

O comando clean faz a remoção de versões anteriores, geradas em

outro momento. Já o comando install lerá o arquivo pom.xml e gerará
um arquivo para ser executado em um servlet container. Esse arquivo
gerado terá a extensão .war e estará disponível na pasta target. Re-
torne ao Eclipse e verifique se essa pasta foi criada, juntamente com o
arquivo primeiroprojeto.war.

A figura a seguir mostra a tela com o arquivo primeiroprojeto.war

gerado na pasta target.
Figura 10
Arquivo primeiroprojeto.
war gerado com sucesso
na pasta target

Fonte: software Eclipse IDE.

20 Laboratório de Programação II
 A segunda opção de geração de versão pode ser acionada dentro do
próprio Eclipse. Para isso, realize os seguintes passos:
1. Clique com o botão direito no nome do projeto (primeiroprojeto).
2. Selecione a opção Run As Maven Install.

A seguir você pode conferir a versão sendo gerada dentro do

Eclipse.
Figura 11
Gerando versão usando o Maven dentro do Eclipse

Fonte: software Eclipse IDE.

Espere a construção do projeto e acompanhe pela aba Console se

esse processo de construção deu certo, ou seja, se apareceu a mensa-
gem BUILD SUCCESS.

A Figura 12 apresenta, dentro do Eclipse, tela que deve aparecer

com a mensagem de status de sucesso.

Introdução a Java Web 21

 Figura 12
Status de sucesso na construção do projeto dentro do Eclipse

Fonte: software Eclipse IDE.

Agora, precisamos utilizar um Servlet Container, que também
pode ser chamado servidor web. Utilizaremos o servidor web Apache
Tomcat – um projeto de código aberto (open source) muito utilizado
em projetos Java Web.
Para usarmos o Tomcat, precisamos:
1. acessar o site http://tomcat.apache.org/;
2. selecionar, no menu download, a opção Tomcat 9 ou acessar o
seguinte link: https://tomcat.apache.org/download-90.cgi;
3. ir até a opção Core, na versão corrente, e selecionar a opção
desejada.

• Caso seja Windows, selecionar a opção 64bits. Se seu sistema

operacional for 32bits, escolha essa opção.
• Caso seja Linux, selecionar a opção .zip.
Na figura a seguir, você pode conferir as opções de download do
Apache Tomcat.
Figura 13
Opções de download do Apache Tomcat

Fonte: site Tomcat.apache.org

22 Laboratório de Programação II
 No caso de nosso exemplo, utilizamos a versão 9.0.41.

Após o download, você irá descompactar o arquivo. Aqui, descom-

pactaremos o Tomcat para a pasta c:\java\. Agora vamos reconhecer as
pastas do Apache Tomcat, apresentadas na figura a seguir.
Figura 14
Pastas do Apache Tomcat

Fonte: Elaborada pelo autor.

A pasta bin é onde você encontrará os arquivos para iniciar e parar o

Tomcat. Para iniciar, use os arquivos startup.bat, no caso do Windows,
e startup.sh, no caso de Linux. Para parar o Tomcat, use os arquivos
shutdown.bat, no caso do Windows, e shutdown.sh, no caso de Linux.
Nessa pasta, você não irá alterar nenhuma configuração ou arquivo.

Na pasta conf, teremos os arquivos para alterar as configurações

padrões do Tomcat. Caso queira personalizar algo, altere algum dos
arquivos. Na pasta lib, encontramos as diversas bibliotecas utilizadas
pelo Tomcat. Nessa pasta, você não irá alterar nada. A pasta logs é uma
pasta que o Tomcat utiliza para gravar informações sobre acesso e ro-
tinas de processamento. É nela que você poderá conferir informações
de uso do Tomcat. As pastas temp e work armazenam arquivos que
o Tomcat cria à medida que é utilizado e acessado pelos usuários da
internet. Você não deve se preocupar com elas.

Introdução a Java Web 23

 Por fim, chegamos à pasta webapps. É nela que os arquivos .war
ficam. Após criar uma versão pelo Maven, você pode copiar o arqui-
vo .war da pasta target do projeto para a pasta webapps do Tomcat.
Quando iniciamos o Tomcat, são verificados quais arquivos com ex-
tensão .war estão na pasta webapps e, caso esteja algum, o contêiner
web faz o processo de descompilação do .war e torna-o disponível para
acesso do usuário.

Para validar o conhecimento do parágrafo anterior, vamos copiar o

arquivo primeiroprojeto.war da pasta target e colá-lo na pasta webapps
do Tomcat (Figura 15).
Figura 15
Adicionando o arquivo .war na pasta webapps

Fonte: Elaborada pelo autor.

Agora, precisamos iniciar o Tomcat. Para isso, retorne à pasta ante-

rior e abra a pasta bin. Nela, execute o arquivo startup.bat (caso seja
Windows) ou startup.sh (caso seja Linux). Caso tudo dê certo, será apre-
sentada a mensagem Tomcat started (Figura 16).
Figura 16
Iniciando o Tomcat

Fonte: software Prompt de comando.

Por fim, abra um navegador e digite http://localhost:8080/

primeiroprojeto. Se tudo ocorrer corretamente, você encontrará a
seguinte tela:

24 Laboratório de Programação II
 Figura 17
Execução do projeto primeiroprojeto.war

Fonte: Elaborada pelo autor.

A partir de agora, aprenderemos como parar o Tomcat. Para realizar

essa ação, retorne à pasta bin e, nela, execute o arquivo shutdown.bat
(caso seja Windows) ou shutdown.sh (caso seja Linux). Se o processo
tiver dado certo, retorne ao navegador web e tente digitar o endereço
http://localhost:8080/primeiroprojeto. Caso tenha funcionado, o na-
vegador informará que a página não está disponível, pois o servidor
Tomcat está parado.

Além dessa opção para executar um projeto Java Web adicionando

um arquivo na pasta webapps, temos a opção de executar o projeto
web pelo Eclipse IDE. Para fazer isso, retorne ao Eclipse e clique no
menu Window Show View Servers, como apresentado na figura a
seguir.
Figura 18
Acessando as opções de servidores no Eclipse para configurar o Tomcat

Fonte: Eclipse IDE.

Introdução a Java Web 25

 Será aberta uma aba chamada Servers, no canto inferior da IDE,
como você pode ver na Figura 19 a seguir.

Figura 19
Aba Servers

Fonte: Eclipse IDE.

Em qualquer parte dessa aba, clique com o botão direito e selecione
a opção New Server.

A seguir, veja a tela que mostra como adicionar um servidor no

Eclipse IDE.
Figura 20
Adicionando um servidor

Fonte: Eclipse IDE.

Na pasta Apache, selecione a opção Tomcat v9.0 Server e clique em

Next, como mostrado na figura a seguir.

26 Laboratório de Programação II
 Figura 21
Adicionando o Tomcat versão 9.0

Fonte: Eclipse IDE.

Na próxima tela, selecione a pasta na qual está o Tomcat, o que

pode ser visto na figura a seguir.
Figura 22
Selecionando o Tomcat que foi descompactado anteriormente

Fonte: Eclipse IDE.

Introdução a Java Web 27
 Ao pressionar o botão Finish, você perceberá que um servidor
Tomcat foi adicionado na aba Servers. Para vincular o projeto, chamado
primeiroprojeto, ao novo servidor Tomcat, clique duas vezes na opção
Tomcat v9.0 Server at localhost. Uma nova aba será aberta e você
deverá acessar a opção modules, que fica logo acima da aba Servers e
ao lado da aba Overview.
Figura 23
Opção modules do Tomcat

Fonte: Eclipse IDE.

Clique no botão Add Web Module, localizado à direita da tela. Ao cli-

car nessa opção, uma janela será aberta para você selecionar um pro-
jeto Java Web. Selecione a opção primeiroprojeto e salve as alterações.
Figura 24
Adicionando o projeto ao Tomcat

Vídeo
O vídeo Como Configu-
rar o SERVIDOR APACHE
TOMCAT em sua máquina
para PROJETOS JAVAWEB,
do canal Tecnologia
Radioativa, ensina como
Fonte: Eclipse IDE.
instalar e configurar Para executar o Tomcat e acessar o projeto primeiroprojeto, retorne à
o Apache Tomcat não
embarcado. aba Servers e clique com o botão direito no servidor Tomcat v9.0 Server
Disponível em: https://www. at localhost. Selecione a opção Start. Aguarde a inicialização do contêiner
youtube.com/watch?v=9Z4OKoh- web e abra um navegador. Digite http://localhost:8080/primeiroprojeto
Omw. Acesso em: 8 fev. 2021.
e verifique se será apresentada a mensagem Hello World.

28 Laboratório de Programação II
 Figura 25
Iniciar um servidor Tomcat no Eclipse

Fonte: Eclipse IDE.

Para parar o Tomcat, retorne à aba Servers e clique com o botão direito
no servidor Tomcat v9.0 Server at localhost. Selecione a opção Stop.

Com essas configurações você estará apto a utilizar o servidor web

Tomcat. Mesmo que existam novas versões desse servidor, o conteúdo
aqui postado é um padrão desde a versão 6 e não há expectativas de
mudança no formato de organização de pastas e de como o servidor é
iniciado e parado.

CONSIDERAÇÕES FINAIS
Neste capítulo, estudamos as diferenças do JSE e JEE, além de termos
aprendido a criar um projeto Java Web. Esses primeiros passos são im-
portantes para a sequência dos estudos, pois são os pilares do desen-
volvimento Java Web. Continue a estudar as ferramentas de mercado
apresentadas (Apache Maven e Apache Tomcat) e pratique diversas vezes
a construção de projetos.

ATIVIDADES
1. Diferencie as especificações JMS e JPA que estão presentes no JEE.
Vídeo
2. É correto afirmar que o Apache Maven é uma funcionalidade de uma
IDE? Justifique a sua resposta.
3. Quais são os softwares necessários para desenvolver um projeto Java
Web e conseguir executá-lo, tornando-o disponível para ser acessado
em qualquer navegador?
Introdução a Java Web 29
 2
Criando páginas web com Java
Desde a sua criação, o Java foi projetado para diversos apa-
relhos, independentemente do sistema operacional utilizado. Foi
desenvolvido também para uso na web; inicialmente com a tecno-
logia applets, na sequência com JSP (Java Server Pages) e, finalmen-
te, com JSF (Java Server Faces).
Neste capítulo, iremos aprender como fazer uma página web
básica, utilizando JSF e os diversos componentes desse padrão.
Nesse momento, não focaremos na parte de design e beleza do
site. Para tornar suas páginas mais atraentes, aconselhamos es-
tudar CSS e Bootstrap (https://getbootstrap.com/), ou, então, pes-
quisar componentes previamente configurados e padronizados,
como o Primefaces (https://www.primefaces.org/).
E aí, preparado para fazer um projeto Java acessível por uma
página web? Bons estudos!

2.1 JSF e configuração

Vídeo O Java Server Faces (JSF) é uma especificação Java presente no pa-
cote Java EE, servindo para a construção de páginas web que irão se
comunicar com código-fonte Java. A versão do JSF é a 2.3 e é baseada
em facelets, que é um sistema de templates de código aberto para a
internet. Por meio do facelets, podemos criar componentes baseados
em HTML, permitindo assim a personalização que atenderá às necessi-
dades dos usuários. Por exemplo, em HTML, um botão do tipo <input
type= “button”> não faz nenhuma ação. Com facelets esse botão
poderá realizar uma ou mais ações. Pensando em otimizar o trabalho
dos desenvolvedores, o JSF traz diversas personalizações que auxiliam
na construção de páginas para a web.

30 Laboratório de Programação II
 O JSF não substitui outras tecnologias utilizadas nas páginas da web,
como o Javascript ou folhas de estilo (CSS), que podem ser utilizadas
com o JSF sem nenhum problema.

Para termos um projeto utilizando JSF, precisaremos de:

• JDK 11 ou superior;
• IDE para programação (sugerimos Eclipse IDE for Enterprise Java
Developers);
• Apache Maven, versão 3.x ou superior;
• Apache Tomcat, versão 9.x ou superior.

Para termos um projeto Java Web, precisaremos fazer os seguintes

passos:
1. criar um projeto Java Web por meio de comandos do Apache
Maven;
2. importar o projeto criado para o Eclipse;
3. inserir as dependências do JSF dentro do arquivo pom.xml;
4. alterar o arquivo web.xml;
5. construir uma versão após as alterações dos itens 3 e 4;
6. executar a versão gerada dentro do Apache Tomcat;
7. abrir um navegador e verificar se o projeto criado está acessível.

Agora, vamos detalhar cada um dos passos citados anteriormente.

Para isso, teremos diversos códigos que precisarão ser utilizados.

1) Criar um projeto Java Web por meio de comandos do Apache

Maven

Para criar um projeto Java Web, você precisará abrir um terminal

de comando (caso seja Linux) ou um prompt de comando (caso seja
Microsoft Windows). Pelo terminal de comando, acesse a pasta onde
ficará o novo projeto. Aconselhamos criar uma pasta chamada java na
raiz do sistema operacional e usá-la para armazenar todos os projetos.
Caso seja Windows, a pasta ficará em C:\java; caso seja Linux, ficará em
/java. Após isso, insira o comando a seguir:

mvn archetype:generate -DgroupId=br.com.aula -DartifactI-

d=projetoWeb -DarchetypeArtifactId=maven-archetype-webapp
-DinteractiveMode=false

A tela com o comando inserido pode ser vista na figura a seguir.

Criando páginas web com Java 31

 Figura 1
Comando para criação de um projeto Java web

Fonte: software Prompt de comando.

Esse comando irá gerar um projeto Java Web chamado projetoWeb
e, se nenhum erro tiver acontecido, será apresentada a mensagem
BUILD SUCCESS em verde. Com isso, poderemos partir para o segundo
passo, que é importar o projeto no Eclipse.

2) Importar o projeto criado para o Eclipse

Para importar o projeto recém-criado, faça os seguintes passos:

1. abra o Eclipse IDE;
2. escolha o local onde ficará o seu workspace;
3. selecione o menu File Import e será aberta uma caixa de seleção;
4. selecione a opção Maven Existing Maven Projects;
5. selecione o diretório em que o projeto Maven foi criado, no caso,
no C:/Java/projetoWeb;
6. clique no botão Finish para finalizar a importação do projeto.

A figura a seguir apresenta a tela de importação do projeto para o

Eclipse.

Figura 2
Importação do projeto para o Eclipse

Fonte: software Eclipse.

32 Laboratório de Programação II
 Agora vamos adicionar as configurações para utilizarmos JSF. Para
isso, vamos precisar alterar algumas configurações do arquivo pom.xml.

3) Inserir as dependências do JSF dentro do arquivo pom.xml

Procure o arquivo pom.xml, que estará na raiz do projeto. Abra esse

arquivo e procure a tag <dependencies>. Logo a seguir dessa tag, in-
sira os seguintes códigos:

<dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-api</artifactId>

<version>2.2.20</version>

</dependency>

<dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-impl</artifactId>

<version>2.2.20</version>

</dependency>

Salve esse arquivo e espere um momento, pois o Maven automati-

camente irá fazer o download dessas novas dependências para a sua
máquina. O seu arquivo pom.xml ficará da seguinte forma:

<project xmlns=”http://maven.apache.org/POM/4.0.0”

xmlns:xsi=”http://www.w3.org/2001/
XMLSchema-instance”

xsi:schemaLocation=”http://maven.apache.org/
POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”>

<modelVersion>4.0.0</modelVersion>

<groupId>br.com.aula</groupId>

<artifactId>projetoWeb</artifactId>

<packaging>war</packaging>

<version>1.0-SNAPSHOT</version>

<name>projetoWeb Maven Webapp</name>

<url>http://maven.apache.org</url>

(Continua)

Criando páginas web com Java 33

 <dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>3.8.1</version>

<scope>test</scope>

</dependency>

<dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-api</artifactId>

<version>2.2.20</version>

</dependency>

<dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-impl</artifactId>

<version>2.2.20</version>

</dependency>

</dependencies>

<build>

<finalName>projetoWeb</finalName>

</build>

</project>

Agora precisamos configurar o arquivo web.xml, que é responsável

pelas configurações dos facelets e do JSF.

4) Altere o arquivo web.xml

Todo projeto Java Web tem um arquivo de configuração web.xml,

que fica localizado na pasta webapp WEB-INF, como mostra a figura
a seguir.

34 Laboratório de Programação II
 Figura 3
Localização do arquivo web.xml

Package Explorer projetoWeb/pom.xml web.xml

1 <!DOCTYPE we-app PUBLIC
2 “-//Sun Microsystems, Inc. //DTD Web Application 2.3//EN”
projetoWeb 3 “http://java.sun.com/dtd/web-app_2_3.dtd” >

src/main/resources 4
5 <web-app>
JRE System Library [J2SE-1.5] 6 <display-name>Archetype Created Web Application</display-name>
Maven Dependencies 7 </web-app>

src 8

main
webapp
WEB-INF
web.xml
index.jsp
target
pom.xml
Fonte: Elaborada pelo autor.

Abra esse arquivo e você perceberá que ele está com o código da
Figura 3. Você precisará substituir todo o código atual pelo código a
seguir.

<?xml version = “1.0” encoding = “UTF-8”?>

<web-app xmlns:xsi=”http://www.w3.org/2001/
XMLSchema-instance”

xmlns=”http://java.sun.com/xml/ns/javaee”

xmlns:web=”http://java.sun.com/xml/ns/javaee/web-
-app_2_5.xsd”

xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”

id=”WebApp_ID” version=”2.5”>

<welcome-file-list>

<welcome-file>index.xhtml</welcome-file>

</welcome-file-list>

<servlet>

<servlet-name>Faces Servlet</servlet-name>

<servlet-class>javax.faces.webapp.
FacesServlet</servlet-class>
(Continua)

Criando páginas web com Java 35

 <load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>Faces Servlet</servlet-name>

<url-pattern>*.xhtml</url-pattern>

</servlet-mapping>

</web-app>

Após a alteração, não se esqueça de salvar o arquivo web.xml.

A tag <welcome-file> serve para determinarmos qual arquivo será

a página inicial do projeto. No nosso caso, será um arquivo index.xhtml,
que ainda não foi criado. Para que não tenhamos problemas na exe-
cução do projeto, renomeamos o arquivo index.jsp para index.xhtml.
Para renomear, clique com o botão direito no arquivo desejado e sele-
cione a opção refactor rename.

5) Construir uma versão após as alterações dos itens 3 e 4

Após essas alterações, precisamos gerar uma versão do projeto

para que ele seja executado no Apache Tomcat. Lembrando que toda
vez que um projeto é gerado, a pasta target é atualizada com um novo
arquivo .war. Esse arquivo é a versão do seu projeto. Para gerar a ver-
são, siga os passos a seguir:
1. clique com o botão direito no nome do projeto (projetoWeb);
2. selecione a opção run as maven install;
3. espere a construção do projeto e acompanhe pela aba Console
se esse processo de construção deu certo, ou seja, se apareceu a
mensagem BUILD SUCCESS.

Agora vamos executar o projeto no Apache Tomcat.

6) Executar a versão gerada dentro do Apache Tomcat

Para executar o projeto no Tomcat, você deve acessar a aba

servers. Caso essa aba não esteja disponível, clique no menu
window show view servers.

Para vincular o projeto projetoWeb ao servidor Tomcat, clique duas

vezes na opção Tomcat v9.0 server at localhost. Será aberta uma nova
aba e você deverá acessar a opção modules, que fica logo acima da aba
servers e ao lado da aba overview.

36 Laboratório de Programação II
 Clique no botão add web module, localizado à direita da tela. Ao
clicar nessa opção, será aberta uma janela para você selecionar um
projeto Java Web. Selecione a opção projetoWeb e salve as alterações.

Para executar o Tomcat, retorne à aba servers e clique com o botão

direito no servidor Tomcat v9.0 server at localhost. Selecione a opção
start. Aguarde a inicialização do contêiner web e abra um navegador.

7) Abrir um navegador e verificar se o projeto criado está

acessível

Digite http://localhost:8080/projetoWeb e verifique se será apre-

sentada a mensagem “Hello world” (Figura 4).

Figura 4
Execução com sucesso do projeto

Vídeo
No vídeo Java Server
Faces - O que é JSF e
Configurações com TomCat
e Maven, do canal Digital
Innovation One, encon-
traremos um resumo do
que aprendemos nesta
Fonte: Elaborada pelo autor. seção.

Com o sucesso das configurações citadas, você está pronto para Disponível em: https://youtu.be/
ZPAHvSRqqNY. Acesso em: 12
aprender os comandos e os conceitos do JSF, integrando a programa-
fev. 2021.
ção Java com os conceitos de programação para web.

2.2 Primeira tela com JSF

Vídeo O JSF implanta o padrão arquitetural chamado Model-View-Controller
(MVC), o qual é utilizado para organizar e separar as responsabilidades
de cada camada de programação. Na seção view estarão os arquivos
que serão visualizados pelos clientes (no nosso caso são os arquivos
com extensão .xhtml, que utilizarão a programação JSF). Já os arquivos
do tipo controller são requisitados pelos usuários a partir de um clique.
Por fim, os arquivos do tipo model terão o código-fonte Java com as
regras de negócio digitadas.

Criando páginas web com Java 37

 Para facilitar o entendimento do padrão MVC, vamos para o exem-
plo que é representado na Figura 5. Um usuário acessa um site pelo
seu computador ou por um smartphone. Quando esse site foi desen-
volvido usando JSF, a requisição de acesso (podendo ser uma URL ou
um clique de botão) chega até um controller, que interpreta o que foi
solicitado pelo cliente e decide se retorna uma página web (view) ou se
vai até um arquivo do tipo model para executar alguma tarefa.
Figura 5
Padrão arquitetural MVC

Application server
Banco de
J2EE EAR
Computador

dados
pessoal

JSF web application

Bibliotecas de apoio ao JSF

Controller

Faces servlet Faces-config.xml

View Model
Dispositivo
móvel

JSP/JSF
Beans

Fonte: Elaborado pelo autor com base em Tutorialspoint.

Vídeo Os arquivos do tipo controller costumam ter uma anotação

Para conhecer mais @ManagedBean. Com ela, qualquer arquivo do tipo view poderá aces-
sobre o JSF e o padrão
arquitetura MVC, assista
sar uma funcionalidade mapeada no controller.
à aula introdutória de JSF,
Agora vamos criar o nosso primeiro controller, que será utilizado
O que é JSF? - Curso JSF, do
canal AlgaWorks. no arquivo index.xhtml, que é um view. Siga os passos a seguir para
Disponível em: https://youtu. criar o controller:
be/3Cj2mDx0-Ws. Acesso em: 12
fev. 2021. 1. Crie a classe PrimeiroManagedBean.java na pasta src/main/java

A figura a seguir apresenta a tela após o primeiro controller ser

criado.

38 Laboratório de Programação II
 Figura 6
Primeiro controller criado

projetoWeb

src/main/resources

src/main/java

(default package)

PrimeiroManagedBean.java

JRE System Library [J2SE-1.5]

Maven Dependencies

src

main

target

pom.xml
Fonte: Elaborada pelo autor.

a) Caso não esteja aparecendo o Source Folder Java, clique com o

botão direito no projetoWeb e selecione a opção New Source Folder.

b) Digite src/main/java1.

A figura a seguir apresenta a tela de criação do Source Folder Java.

Figura 7
Criação do Source Folder Java

New Source Folder

Source Folder
Creat a new source folder.

Project name: projetoWeb Browse...

Folder name: src/main/java1 Browse...

Update exclusion filters in other source folders to solve nesting
Ignore optional compile problems

Cancel Finish

Fonte: Elaborada pelo autor.

Criando páginas web com Java 39
 c) Renomeie o source folder que acabou de ser criado. Para isso,
clique com o botão direito no source folder e selecione a opção refactor
→ rename.

d) Mude o nome para Java.

2. Abra o novo arquivo e insira o código a seguir:

import javax.faces.bean.ManagedBean;

@ManagedBean(name = “primeiro”)

public class PrimeiroManagedBean {

public String getMessage() {

return “Esta é uma mensagem que surgiu no controller”;

3. Agora abra o arquivo index.xhtml e insira o código #{primeiro.

message} dentro da tag <body>.

<html>

<body>

<h2>Hello World!</h2>

#{primeiro.message}

</body>

</html>

4. Pare o Tomcat, caso ele esteja em execução, e salve todos

os arquivos. Após isso, inicie o Tomcat e acesse o endereço
http://localhost:8080/projetoWeb/.
5. O resultado esperado é que sejam apresentadas duas mensagens.
A primeira é “Hello World” e a outra é “Esta é uma mensagem que
surgiu no controller”, como você pode ver na figura a seguir.

40 Laboratório de Programação II
 Figura 8
Página trazendo dados do ManagedBean

localhost:8080/projetoWeb/

localhost:8080/projetoWeb/

Hello World!
Esta é uma mensagem que surgiu no controller

Fonte: Elaborada pelo autor.

Agora vamos explicar o que aconteceu. Dentro do arquivo

PrimeiroManagedBean.java, adicionamos a anotação @ManagedBean
(name = “primeiro”). Ela é usada para informar que esse arquivo poderá
ser acessado por uma tela. É uma boa prática dar um nome para o seu
ManagedBean. No nosso caso, demos o nome primeiro.

Dentro desse arquivo foi criado um método chamado getMenssage(),

que retorna um texto. Esse método poderá ser acionado pela view, pois
ele está dentro de um ManagedBean.

E como acessamos um método do controller por uma tela (view)?

A resposta é utilizar um padrão dentro da view para acessar o método
desejado. O padrão consiste em utilizar uma # para abrir a chamada
de controller. Na sequência, abrimos as chaves ( { ) e digitamos o nome
do ManagedBean desejado e, após isso, o nome do método, sem usar
os parênteses. Perceba que a palavra get não precisa ser usada. Veja o
código que inserimos:

#{primeiro.message}

Lembrando que estarão erradas as seguintes opções:

• #{primeiroManagedBean.message}
• #{primeiro.getMessage}
• #{primeiro.getMessage()}

Criando páginas web com Java 41

 Agora vamos aprender como usar um campo para inserção de tex-
to, um botão e um campo para exibir mensagem. A ideia desse exem-
plo é um usuário digitar algo e, ao clicar no botão, o conteúdo digitado
ser exibido com letras maiúsculas.
Para que tudo isso aconteça, vamos retornar ao arquivo index.xhtml e adicionar novas
propriedades na tag <html> para que possamos utilizar facelets.

<?xml version=”1.0” encoding=”UTF-8”?>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html xmlns=”http://www.w3.org/1999/xhtml”

xmlns:f=”http://java.sun.com/jsf/core”

xmlns:h=”http://java.sun.com/jsf/html”>

Como vamos utilizar facelets, as tags html precisarão começar com h.

• <head> passará a ser <h:head>
• <body> passará a ser <h:body>
• <form> passará a ser <h:form>
• <input type= “text”> passará a ser <h:inputText>
• <input type= “button”> passará a ser <h:commandButton>

O código completo da tela ficará assim:

<?xml version=”1.0” encoding=”UTF-8”?>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html xmlns=”http://www.w3.org/1999/xhtml”

xmlns:f=”http://java.sun.com/jsf/core”

xmlns:h=”http://java.sun.com/jsf/html”>

<h:head>

<title>Titulo da página</title>

</h:head>

<h:body>

<h2>#{primeiro.message}</h2>

(Continua)

42 Laboratório de Programação II
 <h:form>

<h:inputText value=”#{primeiro.nome}” />

<h:commandButton value=”Exibir Maiusculo” actionListener=”#{pri-

meiro.exibirMaiusculo}” />

<br />

<h:outputText value=”#{primeiro.nomeMaiusculo}” />

</h:form>

</h:body>
</html>

No arquivo PrimeiroManagedBean.java, precisaremos mapear dois Vídeo

novos campos (nome e nomeMaiusculo). Para o correto funcionamen- Confira a aplicação de
diversos componentes
to do JSF, todo atributo utilizado em tela precisa ter um método get e na prática no vídeo Com-
outro do tipo set mapeado no controller, em que iremos criar o méto- ponentes backing bean
jsf (Java Server Faces), do
do exibirMaiusculo, que será chamado pelo botão mediante um clique. canal Alex – Jdev Treina-
Confira a seguir como vai ficar o ManagedBean: mento on-line.

Disponível em: https://

import javax.faces.bean.ManagedBean; www.youtube.com/
watch?v=bToKNlRgnt8. Acesso em:
@ManagedBean(name = “primeiro”)
12 fev. 2021.
public class PrimeiroManagedBean {

private String nome;

private String nomeMaiusculo;

public String getNome() {

return nome;

public void setNome(String nome) {

this.nome = nome;

public String getNomeMaiusculo() {

return nomeMaiusculo;

(Continua)

Criando páginas web com Java 43

 public void setNomeMaiusculo(String nomeMaiusculo) {

this.nomeMaiusculo = nomeMaiusculo;

public String getMessage() {

return “Esta é uma mensagem que surgiu no

controller”;

public void exibirMaiusculo() {

nomeMaiusculo = nome.toUpperCase();

}
}

O resultado dessas alterações é apresentado na Figura 9. Ao digitar

algo no campo de texto e pressionar o botão, o conteúdo digitado é
apresentado em maiúsculo.

Figura 9
Tela JSF funcionando

Título da página

localhost:8080/projetoWeb/index.xhtml

Esta é uma mensagem que surgiu no controller

aula jsf Exibir Maiusculo

AULA JSF
Fonte: Elaborada pelo autor.

Com base nesse conhecimento, você conseguirá criar páginas incrí-

veis com JSF e interação com controllers. Tente criar campos na tela e
botões para treinar o aprendizado visto nesta seção.

2.3 Outros componentes em JSF

Vídeo Nesta seção, vamos detalhar mais componentes que podem ser uti-
lizados em suas páginas JSF. Todos eles podem ser usados numa mes-
ma página e quantas vezes forem necessárias.

44 Laboratório de Programação II
 Quadro 1
Lista de componentes JSF

Tag Função Como é no html

O usuário pode digitar algo e o campo esconderá
h:inputSecret <input type=”password”>
o que foi digitado.
Utilizado para a digitação de grandes textos, com
h:inputTextarea <textarea>
mais de um parágrafo.
h:inputHidden Um campo que não ficará visível para o usuário. <input type=”hidden”>

h:inputFile Um campo para realizar upload de arquivos. <input type=”file”>

h:graphicImage Utilizado para apresentar uma imagem. <img>

h:dataTable Utilizado para ser uma tabela de dados. <table>

<tr>
Representa uma linha e uma coluna dentro de
h:column <td> </td>
uma tabela.
</tr>
h:message Apresenta uma mensagem para o usuário. <span>

h:messages Apresenta várias mensagens para o usuário. <span>

Apresenta uma informação formatada para o Texto puro, não tem tag em
h:outputFormat
usuário. html
Utilizado para ser um nome ou descrição de um
h:outputLabel campo. Ele fica vinculado a um campo de entrada <label>
de dados (h:inputText).
h:commandLink Um link para uma nova página. <a href>
Utilizado para ser um link de uma página ou de uma
h:outputLink <a>
ação, sendo mais simples que o commandLink.
<table>
<tr>
Usado para separação de informações na tela, se-
h:panelGrid <td></td>
melhante ao table do html.
</tr>
</table>
Utilizado para separação de conteúdo na tela, se-
h:panelGroup <div> ou <span>
melhante ao <div> ou <span> do html.
Utilizado para apresentar diversas opções, em que
h:selectOneRadio <input type=”radio”>
o usuário deverá selecionar uma delas.
Utilizado como uma caixa de checagem, com a op-
h:selectBooleanCheckbox <input type=”checkbox”>
ção verdadeira ou falsa.
Utilizado para apresentar várias caixas de checa-
h:selectManyCheckbox <input type=”checkbox”>
gem, com a opção verdadeira ou falsa.
Apresenta uma lista de dados, e o usuário poderá
h:selectOneListbox <select>
selecionar uma opção.
Apresenta uma lista de dados, e o usuário poderá
h:selectManyListbox <select>
selecionar várias opções.
(Continua)

Criando páginas web com Java 45

 Tag Função Como é no html
Apresenta um menu com várias opções e o usuá-
h:selectOneMenu <select>
rio poderá selecionar uma delas.
Apresenta um menu com várias opções, e o usuá-
h:selectManyMenu <select>
rio poderá selecionar várias opções.

Site Fonte: Elaborado pelo autor.

Não deixe de consultar Os componentes apresentados no Quadro 1 contemplam mais

alguns sites que trazem de 90% das opções disponíveis em JSF. A melhor forma de entender
didaticamente o uso
desses componentes. Os o que cada um faz é fazer experimentos e ir incluindo cada compo-
mais indicados são:
nente no arquivo index.xhtml. Faça isso de maneira gradativa, ou
Tutorials Point. Disponível em: https://
www.tutorialspoint.com/jsf/index. seja, insira um componente, salve as alterações e recarregue a pá-
htm. Acesso em: 12 fev. 2021. gina no navegador para entender o que aconteceu. Na sequência,
Java T Point. Disponível em:
https://www.javatpoint.com/ insira outro componente.
jsf-ui-components. Acesso em: 12
fev. 2021.

CONSIDERAÇÕES FINAIS
Neste capítulo, conhecemos o JSF e os componentes que ele traz
configurados, devido ao padrão facelets, o qual permite que a criação de
páginas html fique muito mais dinâmica e personalizada. Graças a essa
personalização, conseguimos fazer a interação da nossa página web com
os arquivos do tipo controller por meio da anotação @ManagedBean, as-
sim temos o uso avançado das páginas na internet com uso da tecnologia
Java.

ATIVIDADES
Vídeo 1. O que é facelets e qual é a sua função?

2. Quais componentes podem ser utilizados em JSF para a geração de

links entre páginas? Explique um pouco sobre eles.

3. O que é um padrão Model-View-Controller (MVC)?

46 Laboratório de Programação II
 3
Criando páginas
avançadas com Java
Quando é necessário criar um software para resolver um pro-
blema, algumas funcionalidades costumam ser mapeadas com
maior frequência e costumam envolver listagem, inserção, edição e
remoção de dados em cadastros. Ao ser identificado esse conjunto
de necessidades, usamos o termo CRUD, que é um acrônimo para
quatro palavras em inglês (C - create, R - read, U - update e D - delete).
Na sequência do livro vamos aprender como fazer um CRUD
básico utilizando JSF visando ao desenvolvimento prático dos con-
ceitos já vistos em Java e JSF. Lembrando que ainda não utiliza-
remos banco de dados nem outras bibliotecas de apoio. Ao final
deste capítulo, você estará habilitado a criar páginas totalmente
funcionais em JSF utilizando design de padrão de mercado.

3.1 Listando dados com JSF

Vídeo Para criarmos o nosso primeiro CRUD com JSF, vamos utilizar o pro-
jeto que anteriormente foi configurado e que se chama projetoWeb.
Assim evitamos o retrabalho de configuração do Maven, do Apache
Tomcat e do JSF.

A ideia é criarmos um cadastro completo de unidades federativas

brasileiras, ou seja, cadastrar dados dos estados da nossa nação. É um
exemplo simples, mas que irá demonstrar todas as particularidades
envolvidas para criar um CRUD. Vamos ao passo a passo do que pre-
cisamos fazer:
1. Crie um novo pacote (package) chamado br.com.aula.model. Para
criá-lo, você deve clicar com o botão direito do mouse em cima do
source folder src/main/java e selecionar a opção NEW PACKAGE.

Criando páginas avançadas com Java 47

 2. Repita o passo anterior, mas crie um pacote chamado br.com.
aula.controller. O resultado deverá ficar conforme a Figura 1.

Figura 1
Pacotes que precisam ser criados no source folder src/main/java

Fonte: biblioteca Hibernate tools

Essa separação visa seguir o modelo MVC já estudado e assim man-

teremos as responsabilidades de cada arquivo bem delimitadas. Agora
vamos criar o arquivo do tipo model chamado Uf.java. Para isso siga os
passos a seguir:
1. Clique com o botão direito no pacote br.com.aula.model e selecione
a opção NEW CLASS e insira o nome Uf no campo Name.
2. Após a classe ter sido criada, vamos inserir três atributos nela.
Teremos um atributo numérico id e outros dois atributos de
texto chamados sigla e nome, que devem ter o encapsulamento
privado (private).
3. Crie métodos acessores (get e set) para esses atributos, pois
iremos acessá-los a partir do controlador que logo criaremos.
4. Salve as alterações clicando no ícone de disquete próximo ao
menu superior File.

O seu código ficará assim:

package br.com.aula.model;
public class Uf {
private Integer id;
private String sigla;
private String nome;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}

(Continua)

48 Laboratório de Programação II
 public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getSigla() {
return sigla;
}
public void setSigla(String sigla) {
this.sigla = sigla;
}
}
Agora vamos criar a nossa nova tela em JSF, que será de listagem
de dados e ainda não terá um design agradável. Focaremos no código
para entender como funciona a listagem de dados com JSF. Para criar
uma nova tela, realize os passos a seguir:
1. Clique com o botão direito na pasta src/main/webapp e selecione
a opção NEW → FILE.
2. Digite no campo File Name o nome do arquivo a ser gerado.
Usaremos o nome uf.xhtml. Na Figura 2 visualizamos onde ficou o
arquivo:

Figura 2
Novo arquivo uf.xhtml

Fonte: biblioteca Hibernate tools

Criando páginas avançadas com Java 49

 3. Insira o código a seguir dentro desse novo arquivo:
<html xmlns=”http://www.w3.org/1999/xhtml”
xmlns:h=”http://java.sun.com/jsf/html”
xmlns:f=”http://java.sun.com/jsf/core”
xmlns:ui=”http://java.sun.com/jsf/facelets”>

<h:head>
<title>Cadastro UF</title>
</h:head>
<h:body>
<h2>Cadastro de Unidades Federativas (UF)</h2>
<h:form id=”form”>

<h:dataTable value=”#{ufBean.list}” var=”item” id=”tabelaUf”>

<h:column>
<f:facet name=”header”>Sigla</f:facet>
<h:outputText value=”#{item.sigla}” id=”sigla” />
</h:column>
<h:column>
<f:facet name=”header”>Nome</f:facet>
<h:outputText value=”#{item.nome}” />
</h:column>
</h:dataTable>
</h:form>
</h:body>
</html>

4. Salve as alterações clicando no ícone de disquete próximo ao

menu superior File.

Acabamos de criar o nosso novo arquivo JSF, contudo precisamos

obsevar algumas particularidades:
• Na tag <html> estão presentes as configurações dos pacotes que
serão utilizados para implementar facelets. No caso temos o html
(representado pela letra h), as implementações do JSF core (repre-
sentado pela letra f) e as implementações do JSF facelets (repre-
sentado pelas letras ui). Esse será um padrão para todas as telas.
• Na tag <h:head> temos as configurações de cabeçalho da página.
É o mesmo que a tag <head> do html.
• Na tag <h:body> iremos ter todas as funcionalidades da página. É
o mesmo que a tag <body> do html.

50 Laboratório de Programação II
 • Na tag <h:form> teremos os campos com que o usuário irá inte-
ragir. É o mesmo que a tag <form> do html.
• A tag <h:dataTable> será usada para exibir uma lista de dados; é o
mesmo que a tag <table> do html. Como utilizaremos dados que
vêm de um controlador Java, precisamos usar o h:dataTable ao in-
vés do <table>. Nessa tag a lista de valores da lista estará na proprie-
dade value, e cada um dos itens da lista terá um nome definido a
partir da propriedade var. No nosso caso a lista vem do controlador
ufBean.list, e os valores individuais se chamarão item. Exemplo:

<h:dataTable value=”#{ufBean.list}” var=”item” id=”tabelaUf”>

• Dentro da tag <h:dataTable> teremos duas colunas representa-

das pela tag <h:column>. Uma coluna será para a sigla da UF e a
outra coluna será usada para o nome completo da UF. Essa tag
substitui as tags <tr> e <td> do html.
• Dentro de cada <h:column> existem dois atributos. Um deles é o
<f:facet>, que é usado para ser o cabeçalho da lista, e o outro é o
<h:outputText>, que exibirá o dado que está na lista.

Agora precisaremos criar o ManagedBean (ou a classe controla-

dora) para que essa tela exiba os dados. Para isso, siga os passos a
seguir:
1. Clique com o botão direito no pacote br.com.aula.controller,
selecione a opção NEW CLASS e insira o nome UfBean no
campo Name.
2. Abra o arquivo UfBean.java e, na linha acima da declaração da
classe, insira a anotação @ManagedBean e @ApplicationScoped:
@ManagedBean
@ApplicationScoped
public class UfBean {
3. Insira um atributo privado chamado List<Uf> list e crie um método
get para acessar os dados, lembrando que a lista a ser usada é do
pacote java.util.List:
private List<Uf> list;
public List<Uf> getList() {
return list;
}

Criando páginas avançadas com Java 51

 4. Agora vamos criar uma lista de valores predefinida para ser
apresentada na nossa tela uf.xhtml. Para isso três passos são
necessários:

a) Alterar o arquivo pom para que ele utilize a versão correta de

compilação (no caso a 1.6). Para isso, abra o arquivo pom.xml
e insira o código a seguir, que precisa estar logo acima da tag
<modelVersion>. Caso esses comandos já estejam no arquivo
pom.xml, nenhuma ação será necessária e você já pode ir
para o próximo ponto.
<properties>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>

b) Alterar o arquivo pom, incluindo uma nova dependência. Para

isso, abra o arquivo pom.xml e insira o código a seguir, o qual
deve estar entre as tags <dependencies>.
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-web-api</artifactId>
<version>8.0.1</version>
<scope>provided</scope>
</dependency>
c) Inserir um novo método na classe UfBean.java:
@PostConstruct
public void init() {
if (list == null) {
list = new ArrayList<Uf>();
}
}
5. Agora vamos colocar valores na listagem no método init(). Logo
após o código list = new ArrayList<Uf>(), insira o código a seguir:
Uf pr = new Uf();
pr.setId(1);
pr.setNome(“Paraná”);
pr.setSigla(“PR”);
list.add(pr);

Uf sp = new Uf();
sp.setId(2);
sp.setNome(“São Paulo”);
52 Laboratório de Programação II
 sp.setSigla(“SP”);
list.add(sp);
O código da sua classe UfBean.java deve ficar semelhante ao código
a seguir:
package br.com.aula.controller;

import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.bean.ApplicationScoped;
import javax.faces.bean.ManagedBean;
import br.com.aula.model.Uf;

@ManagedBean
@ApplicationScoped
public class UfBean {
private List<Uf> list;
public List<Uf> getList() {
return list;
}
@PostConstruct
public void init() {
if (list == null) {
list = new ArrayList<Uf>();

Uf pr = new Uf();
pr.setId(1);
pr.setNome(“Paraná”);
pr.setSigla(“PR”);
list.add(pr);

Uf sp = new Uf();
sp.setId(2);
sp.setNome(“São Paulo”);
sp.setSigla(“SP”);
list.add(sp);
}
}
}
E o arquivo pom.xml deve ficar semelhante ao seguinte código:
<project xmlns=”http://maven.apache.org/POM/4.0.0”

Criando páginas avançadas com Java 53

 xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0
(Continua) http://
maven.apache.org/maven-v4_0_0.xsd”>
<properties>
<maven.compiler.source>1.6</maven.compiler.source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>

<modelVersion>4.0.0</modelVersion>
<groupId>br.com.aula</groupId>
<artifactId>projetoWeb</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>projetoWeb Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
<version>2.2.20</version>
</dependency>

<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-impl</artifactId>
<version>2.2.20</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-web-api</artifactId>
<version>8.0.1</version>

54 Laboratório de Programação II
 <scope>provided</scope>
</dependency> (Continua)
</dependencies>
<build>
<finalName>projetoWeb</finalName>
</build>
</project>
Agora é o momento de visualizar as alterações. Por isso, salve-as em
todos os arquivos e faça a build do projeto no Maven.
1. Clique com o botão direito no nome do projeto (projetoWeb).
2. Selecione a opção Run As → Maven Install.
3. Espere a construção do projeto e acompanhe pela aba Console
se esse processo de construção deu certo, ou seja, se apareceu a
mensagem de BUILD SUCCESS.

Agora vamos executar o projeto no Apache Tomcat. Abra a aba

Servers do Eclipse e clique com o botão direito no servidor Tomcat v9.0
Server at localhost. Selecione a opção Start. Aguarde a inicialização
do contêiner web e abra um navegador. Digite http://localhost:8080/
projetoWeb/uf.xhtml e verifique se a tela de listagem de UF apresentou
um resultado semelhante ao da Figura 3.

Figura 3
Listagem de cidades usando JSF

localhost:8080/projetoWeb/uf.xhtml

Cadastro de Unidades Federativas (UF)

Sigla Nome
PR Paraná
SP São Paulo

Fonte: Elaborada pelo autor.

Caso tenha sido apresentada alguma mensagem de erro ao acessar

o endereço, sugerimos que a leia com calma. O Java costuma sugerir
a linha e qual erro ocorreu. Segue um exemplo aleatório para explicar
isso (Figura 4).

Criando páginas avançadas com Java 55

 Figura 4
Mensagem de erro na linha 20, informando que existe um comando desconhecido (h:outputTe)

HTTP Status 500 – Internal Server Error

Type Exception Report

Message / uf.xhtml @20,40 <h:outputTe> Tag Library supports namespace: http://java.sun.com/jsf/html, but no tag was
defined for name: outputTe

Description The server encountered an unexpected condition that prevented it from fulfilling the request.

Exception

javax.servlet.ServletException: /uf.xhtml @20,40 <h:outputTe> Tag Library supports namespace:

javax.faces.webapp.FacesServlet.service(FacesServlet.java:671)
org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)

Fonte: Elaborada pelo autor.

Na Figura 4 percebemos um erro na linha 20 no elemento
h:outputTe. Você se lembra desse comando no JSF? Pois bem, ele não
existe mesmo. O que existe é h:outputText.
Atenção
Lembre-se de que as mensa- Para finalizar a nossa primeira tela de listagem de dados, que tal adi-
gens de erro são para auxiliar, e cionarmos um design mais agradável e, principalmente, que se adapta a
não para assustar. Leia-as com
computadores e a dispositivos móveis, como tablets e smartphones?
calma e você descobrirá qual é o
problema e qual é a solução. Quem faz esse trabalho adaptativo é uma biblioteca chamada Boots-
trap, utilizada por milhões de sites no mundo e que traz um kit de fer-
ramentas para configuração e padronização de telas. Essa biblioteca
não tem relação com Java EE ou JSF, mas pode trabalhar com ambas
em harmonia.
Site Agora vamos aos passos para configurar a biblioteca Bootstrap. Você
Para saber mais sobre a não precisará fazer o download de nada, basta seguir os passos a seguir:
biblioteca Bootstrap, acesse o
site oficial. 1. Abra o arquivo uf.xhtml e insira o código a seguir dentro da tag
Disponível em: https://getbootstrap. <h:head>, podendo ser antes ou depois da tag <title>. A ordem
com/. Acesso em: 3 maio 2021. não irá influenciar o uso da biblioteca.
<link href=”https://cdn.jsdelivr.net/npm/
[email protected]/dist/css/bootstrap.min.css”
rel=”stylesheet” integrity=”sha384-BmbxuPwQa2lc/
FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl”
crossorigin=”anonymous”/>
2. Dentro do arquivo uf.xhtml, insira o código a seguir antes do
fechamento da tag </h:body>.
<script src=”https://cdn.jsdelivr.net/npm/
[email protected]/dist/js/bootstrap.bundle.

(Continua)

56 Laboratório de Programação II
 min.js” integrity=”sha384-b5kHyXgcpbZJO/
tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0”
crossorigin=”anonymous”></script>
Feito isso, já temos o Bootstrap configurado no nosso projeto. Como
não alteramos nada de classe Java (nem modelos nem controladores),
não precisamos parar o servidor Tomcat nem fazer a build no Maven.
Basta retornar ao navegador e atualizar a página. Você vai perceber
que as letras da listagem da Figura 5 estão diferentes da Figura 3. Ou
seja, o Bootstrap entrou em ação, mas ainda pode ser melhor.

Figura 5
Tela de listagem de UF utilizando Bootstrap

localhost:8080/projetoWeb/uf.xhtml

Cadastro de Unidades Federativas (UF)

Sigla Nome
PR Paraná
SP São Paulo

Fonte: Elaborada pelo autor.

Para melhorar a exibição dos dados na tabela, vamos adicionar algu-

mas propriedades que estão previamente configuradas no Bootstrap.
Dentro da tag <h:dataTable>, adicione a propriedade class=”container”.
O código ficará assim:
<h:dataTable value=”#{ufBean.list}” var=”item”
id=”tabelaUf” class=”container”>
Atualize a página no navegador e verifique o que aconteceu com a
tabela que exibe os dados:

Figura 6
Vídeo
Listagem de UF utilizando Bootstrap
No vídeo Bootstrap //
Dicionário do Progra-
localhost:8080/projetoWeb/uf.xhtml mador, do canal Código
Fonte TV, você entenderá
o Bootstrap, o que é,
Cadastro de Unidades Federativas (UF) histórico e como usá-lo.

Disponível em: https://

Sigla Nome www.youtube.com/
PR Paraná watch?v=zEi62PpFezU. Acesso em:
SP São Paulo 3 maio 2021.

Fonte: Elaborada pelo autor.

Criando páginas avançadas com Java 57

 Saiba mais
Agora temos a exibição de dados mais limpa e organizada, graças à
Para conhecer melhor
a biblioteca Bootstrap, biblioteca Bootstrap.
acesse o site oficial e leia
a documentação ( https:// Chegamos ao fim deste tópico e agora já sabemos como criar telas
getbootstrap.com/), além de em JSF que listam dados predefinidos. Além disso, nossas telas estão
assistir ao vídeo a seguir
para entender o potencial ficando mais agradáveis devido ao uso do Bootstrap, sem contar que
dessa biblioteca. elas funcionarão direito independentemente do tamanho da tela do
Disponível em: https://www.
youtube.com/watch?v=zEi62PpFe- usuário, já que o Bootstrap faz a adaptação do seu site tanto para com-
zU. Acesso em: 5 maio 2021. putadores como para celulares e tablets.

3.2 Inserindo, atualizando e

Vídeo removendo dados com JSF
Vamos avançar na criação do nosso CRUD. Percebemos que a lis-
tagem de dados está com dados fixos, o que não é muito legal para o
usuário, afinal, ele vai desejar cadastrar itens para usar posteriormen-
te. Neste tópico vamos criar maneiras de inserir, editar e remover itens
de uma lista de dados a partir de telas do JSF, tudo isso sem esquecer
as boas práticas de tela aplicadas com o Bootstrap.

A primeira alteração que precisamos fazer é adicionar um botão na

tela uf.xhtml, o qual vai servir para invocar uma nova tela que será usada
para cadastrar unidades federativas. Para isso, siga os passos a seguir:
1. Abra o arquivo uf.xhtml.
2. Copie o código a seguir e adicione-o logo abaixo da tag
</h:dataTable>.
<h:commandButton value=”Adicionar” action=”#{ufBean.
novo}”/>
Perceba que esse botão está com a propriedade value preenchida.
Nessa propriedade colocamos um texto que será exibido dentro do bo-
tão. Além disso, a propriedade action está sendo usada, a qual serve
para enviar um comando para o ManagedBean acionar o método lá
configurado, por isso precisamos criar esse método. Todo método uti-
lizado dentro de um action precisa retornar um texto, que deve ter o
mesmo nome da tela desejada (veremos isso no passo 4).
3. Abra o arquivo UfBean.java, inclua o atributo privado Uf e crie os
métodos acessores para torná-lo visível para as telas JSF.
private Uf uf;
public Uf getUf() {
(Continua)

58 Laboratório de Programação II
 return uf;
}
public void setUf(Uf uf) {
this.uf = uf;
}
4. Dentro do arquivo UfBean.java, insira o código a seguir, referente
ao método novo().
public String novo() {
this.uf = new Uf();
return “cadastrarUf”;
}
O método novo() precisa retornar um texto, pois ele foi invocado
pela tela uf.xhtml a partir de um action. O texto a ser retornado
deve ser o nome da tela que se deseja abrir, sem o .xhtml.

5. Agora precisamos criar a tela cadastrarUf.xhtml. Por enquanto

vamos criá-la com uma breve mensagem. Sugerimos que a
tela uf.xhtml seja copiada e colada na pasta src/main/webapp.
Ao realizar isso, será apresentada uma mensagem de conflito
de nomes, e deverá ser informado o nome desejado (no caso
cadastrarUf). Lembrando que para copiar podemos usar o
comando CTRL+C do teclado e para colar, CTRL+V.
6. Abra o arquivo cadastrarUf.xhtml e apague todo o conteúdo
dentro do <h:form>. O código ficará assim:
<html xmlns=”http://www.w3.org/1999/xhtml”
xmlns:h=”http://java.sun.com/jsf/html”
xmlns:f=”http://java.sun.com/jsf/core”
xmlns:ui=”http://java.sun.com/jsf/facelets”>

<h:head>
<link href=”https://cdn.jsdelivr.net/npm/
[email protected]/dist/css/bootstrap.min.css”
rel=”stylesheet” integrity=”sha384-BmbxuPwQa2lc/
FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl”
crossorigin=”anonymous”/>
<title>Cadastro UF</title>
</h:head>
<h:body>
<h2>Cadastro de Unidades Federativas (UF)</h2>
<h:form id=”form”>
(Continua)

Criando páginas avançadas com Java 59

 </h:form>
<script src=”https://cdn.jsdelivr.net/
npm/[email protected]/dist/js/bootstrap.
bundle.min.js” integrity=”sha384-b5kHyXgcpbZJO/
tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0”
crossorigin=”anonymous”></script>
</h:body>
</html>
A classe UfBean.java ficará assim:
package br.com.aula.controller;

import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.bean.ApplicationScoped;
import javax.faces.bean.ManagedBean;
import br.com.aula.model.Uf;

@ManagedBean
@ApplicationScoped
public class UfBean {
private List<Uf> list;
public List<Uf> getList() {
return list;
}
@PostConstruct
public void init() {
if (list == null) {
list = new ArrayList<Uf>();

Uf pr = new Uf();
pr.setId(1);
pr.setNome(“Paraná”);
pr.setSigla(“PR”);
list.add(pr);

Uf sp = new Uf();
sp.setId(2);
sp.setNome(“São Paulo”);
sp.setSigla(“SP”);
list.add(sp);
}
(Continua)

60 Laboratório de Programação II
 }
private Uf uf;

public Uf getUf() {
return uf;
}

public String novo() {

this.uf = new Uf();
return “cadastrarUf”;
}
}
Como realizamos alterações no Java, precisaremos pa-
rar o Tomcat e realizar um novo processo de build via Maven.
Após esse procedimento, inicie o Tomcat e acesse o endereço
http://localhost:8080/projetoWeb/uf.xhtml. Um novo botão será apre-
sentado na tela (Figura 7).

Figura 7
Tela de listagem com novo botão de adicionar

localhost:8080/projetoWeb/uf.xhtml

Cadastro de Unidades Federativas (UF)

Sigla Nome
PR Paraná
SP São Paulo

Adicionar

Fonte: Elaborada pelo autor.

Clique nele e uma nova tela será apresentada com uma mensagem
de “Cadastro de Unidades Federativas (UF)”. Você perceberá que a URL
no navegador não mudou para /projectoWeb/cadastrarUf.xhtml. Não
fique preocupado com isso, pois essa é a forma que o JSF trabalha.
Agora vamos personalizar o botão da tela uf.xhtml, por isso retorne a
esse arquivo e adicione a propriedade class=”btn btn-primary” dentro
da tag h:commandButton. O código ficará assim:
<h:commandButton value=”Adicionar” action=”#{ufBean.
novo}” class=”btn btn-primary”/>

Criando páginas avançadas com Java 61

 Como foi uma alteração num arquivo JSF, não é necessário realizar
um novo processo de build no Maven nem parar o Tomcat. Abra o na-
vegador para perceber a mudança.

Agora vamos nos concentrar na tela cadastrarUf.xhtml (Figura 8).

Precisamos adicionar dois campos de texto nessa tela. O primeiro cam-
po será utilizado para guardar dados da sigla de uma UF, e o segundo
para guardar o nome completo da unidade federativa. Esses campos
serão do tipo <h:inputText> e serão acompanhados de um texto infor-
mativo (h:outputLabel).

Figura 8
Botão com a propriedade de cor alterada

Cadastro de Unidades Federativas (UF)

Sigla Nome
PR Paraná
SP São Paulo

Adicionar

Fonte: elaborada pelo autor.

Vamos aproveitar esse momento para criar uma validação no pri-

meiro campo. Fundamentadas na regra brasileira de unidades federa-
tivas, as siglas devem ter no máximo dois caracteres e por isso vamos
utilizar a propriedade maxlength para controlar isso. Essa proprieda-
de é utilizada dentro da tag <h:inputText>.

Outra regra importante é que a sigla de uma UF só pode ser com-

posta de letras, então vamos usar o comando f:validateRegex para
fazer essa validação. Esse comando precisa ser usado entre as tag
<h:inputText> e </h:inputText>.

Outra validação necessária é garantir que ambos os campos devem

ser preenchidos pelo usuário. Nada pode ficar vazio. Para obrigar o
preenchimento, utilizamos a propriedade required=”true”, a qual faz
parte da tag <h:inputText>. Caso algum campo não tenha sido preen-
chido, apresentaremos uma mensagem para o usuário informando
que o campo é de preenchimento obrigatório. Essa mensagem é con-
figurada pelo comando <h:message>, que deve estar logo após a tag
</h:inputText>.

62 Laboratório de Programação II
 Adicione o código-fonte a seguir dentro da tag <h:form> do arquivo
cadastrarUf.xhtml
<h:panelGrid columns=”3” cellpadding=”5”>
<h:outputLabel value=”Sigla UF:” for=”sigla-uf”
class=”form-label”/>
<h:inputText id=”sigla-uf” required=”true”
value=”#{ufBean.uf.sigla}” label=”Sigla UF”
validatorMessage=”Digite somente letras”
maxlength=”2” class=”form-control”>
<f:validateRegex pattern=”^[a-zA-Z]+$” />
</h:inputText>
<h:message for=”sigla-uf” display=”text” />
<h:outputLabel value=”Nome UF:” for=”nome-uf”
class=”form-label”/>
<h:inputText id=”nome-uf” required=”true”
value=”#{ufBean.uf.nome}” label=”Nome UF”
class=”form-control”>
</h:inputText>
<h:message for=”nome-uf” display=”text” />
</h:panelGrid>
<h:commandButton value=”Salvar” action=”#{ufBean.
salvar}” class=”btn btn-success”/>
O resultado dessas alterações deverá ser algo semelhante à Figura 9:

Figura 9
Tela de cadastro de uma nova UF após as alterações

Cadastro de Unidades Federativas (UF)

Sigla UF:

Nome UF:

Salvar

Fonte: Elaborada pelo autor.

Perceba que essa tela já está usando Bootstrap tanto no botão

(h:commandButton) como nos campos de texto (h:inputText). As pro-
priedades do Bootstrap são acionadas pelo atributo class.

Outra funcionalidade que você pode testar é tentar inserir algo com
os campos vazios, como mostrados na figura a seguir. Ao clicar no bo-
tão Salvar com os campos vazios, será apresentada uma mensagem
(Figura 10).

Criando páginas avançadas com Java 63

 Figura 10
Validação de preenchimento dos campos

Cadastro de Unidades Federativas (UF)

Sigla UF: Sigla UF: Erro de validação: o valor é necessário.

Nome UF: Nome UF: Erro de validação: o valor é necessário.

Salvar

Fonte: Elaborada pelo autor.

Além dessa validação, podemos testar se o campo Sigla UF está acei-

tando valores com mais de dois dígitos e números. Para isso coloque
um número nesse campo e pressione o botão Salvar, uma mensagem
semelhante à Figura 11 será apresentada.

Figura 11
Validação do tipo do valor digitado pelo usuário no campo Sigla UF

Cadastro de Unidades Federativas (UF)

Sigla UF: 11 Digite somente letras

Nome UF: Nome UF: Erro de validação: o valor é necessário.

Salvar

Fonte: Elaborada pelo autor.

Para finalizar o processo de inserção de uma nova UF, precisamos

criar o método salvar() que está sendo invocado pela tela cadastrarUf.
xhtml. Para isso retorne ao UfBean.java e insira o código a seguir:
public String salvar() {
Random random = new Random();
this.uf.setId(random.nextInt());
list.add(this.uf);
return “uf”;
}
Nesse código, estamos inserindo um número aleatório no campo
id para que ele seja o identificador da UF cadastrada. Após isso, adi-
cionamos o que foi digitado na lista de UFs. Por fim, chamamos a tela
uf.xhtml para que seja exibida a lista completa de unidades federativas.

64 Laboratório de Programação II
 A última alteração necessária é alterar o método init(), retirando as
unidades federativas criadas à mão. O método init() deverá ficar assim:
@PostConstruct
public void init() {
if (list == null) {
list = new ArrayList<Uf>();
}
}
Após essas alterações, não se esqueça de parar o Tomcat e reali-
zar um novo processo de build pelo Maven. Na Figura 12 temos um
exemplo de cadastros realizados a partir das alterações que fizemos
até aqui.

Figura 12
Cadastro de novas unidades federativas a partir do próprio sistema

Cadastro de Unidades Federativas (UF)

Sigla Nome
PR PARANA
SC SANTA
RN Rio Grande do Norte
TO Tocantins

Adicionar

Fonte: Elaborada pelo autor.

Até o momento já implementamos as letras C (create) e R (read) do

CRUD por meio de uma listagem de dados e da inserção de novos itens.
Agora vamos fazer a letra D, que representa a remoção de um item.
Para isso, vamos adicionar um botão de remoção e esse ficará ao nome
de cada UF listada na tela uf.xhtml. Ao clicar nesse botão, será invocado
o UfBean e esse removerá o item da lista. Vamos ao passo a passo:
1. Abra a tela uf.xhtml e adicione uma nova coluna dentro
do <h:dataTable>. Essa coluna deve ficar logo acima da tag
</h:dataTable>
<h:column>
<h:commandButton value=”Remover”
action=”#{ufBean.remover(item)}” class=”btn
btn-warning”/>
</h:column>

Criando páginas avançadas com Java 65

 2. Abra a classe UfBean.java e adicione o método remover.
public String remover(Uf uf) {
list.remove(uf);
return “uf”;
}
Após essas alterações, não se esqueça de parar o Tomcat e realizar
um novo processo de build pelo Maven. Na Figura 13 temos um exem-
plo de cadastros realizados a partir das alterações que fizemos até aqui
com o botão de remoção ao lado. Ao clicar nele, você perceberá que a
unidade federativa cadastrada irá sumir.

Figura 13
Tela de listagem com opção de remoção

Cadastro de Unidades Federativas (UF)

Sigla Nome

TO TOCANTINS Remover

PA Pará Remover

Adicionar

Fonte: Elaborada pelo autor.

Para finalizar o nosso CRUD, precisamos criar uma opção de edição

de dados. Para isso, vamos adicionar um botão de edição que ficará ao
lado do nome de cada UF listada na tela uf.xhtml. Ao clicar nesse botão,
será invocada a tela cadastrarUf.xhtml, com os campos já preenchidos
e, após a alteração dos dados, o usuário irá salvar os dados que serão
apresentados na tela uf.xhtml. Vamos ao passo a passo das alterações
necessárias:
1. Abra a tela uf.xhtml e adicione um novo botão ao lado do botão
de remoção. O código deverá ficar assim:
<h:column>
<h:commandButton value=”Editar” action=”
#{ufBean.editar(item)}” class=”btn btn-info”/>
<h:commandButton value=”Remover”
action=”#{ufBean.remover(item)}” class=”btn btn-
warning” />
</h:column>

66 Laboratório de Programação II
 Perceba na figura a seguir que esse novo botão está chaman-
do o método editar e passando via parâmetro a unidade federativa
selecionada.

Figura 14
Tela de listagem com os botões de edição e remoção

localhost:8080/projetoWeb/uf.xhtml

Cadastro de Unidades Federativas (UF)

Sigla Nome

TO TOCANTINS Editar Remover

PA Pará Editar Remover

Adicionar

Fonte: elaborada pelo autor.

2. Abra a classe UfBean.java e adicione o método editar:
public String editar(Uf uf) {
this.uf = uf;
return “cadastrarUf”;
}
Com essa alteração, já é possível abrir a tela cadastrarUf.xhtml com
os dados preenchidos.
3. Retorne a classe UfBean.java e substitua o código do método
salvar() pelo código a seguir:
public String salvar() {
if (this.uf.getId() != null) {
list.remove(this.uf);
list.add(this.uf);
} else {
Random random = new Random();
this.uf.setId(random.nextInt());
list.add(this.uf);
}
return “uf”;
}

Criando páginas avançadas com Java 67

 Dica Essa alteração no método salvar fará uma validação de preenchimento
Caso tenha alguma ou não do campo id de uma unidade federativa. Caso o campo id não
dificuldade nos códigos-
fonte, o projeto com o tenha valor, a ação que o usuário está executando é uma inserção. Caso já
qual estamos trabalhan- tenha um valor para o campo id, isso representa uma ação de edição por
do no livro está disponí-
vel no link a seguir. parte do usuário.
Disponível em: https://github.com/ Após essas alterações, pare a execução do Tomcat e realize um
wagnerfusca/ExemploCrudJSF.
Acesso em: 29 abr. 2021.
novo processo de build pelo Maven. Após a correta compilação e início
do Tomcat, faça testes de inserção, edição e remoção para garantir que
seu CRUD esteja trabalhando corretamente. Com a conclusão desse
passo a passo, você está apto a criar páginas dinâmicas e interativas
com o usuário.

3.3 Utilizando Scope

Vídeo Durante a criação do CRUD nos tópicos anteriores, criamos o arqui-
vo UfBean.java, que representa um arquivo do tipo controlador. Para
sinalizar isso, usamos a anotação @ManagedBean. E como utilizamos
mais de uma tela JSF, precisamos usar a anotação @ApplicationScoped
junto com o @ManagedBean, como é mostrado na figura a seguir.

Figura 15
Anotação ApplicationScoped usada na classe UfBean

Fonte: software Eclipse IDE.

Foi necessário inserirmos essa anotação para que os dados entre as

telas uf.xhtml e cadastrarUf.xhtml fossem mantidos à cada requisição.
Sem essa anotação, os dados seriam perdidos, pois, por padrão, um
ManagedBean trabalha com o @RequestScope, mesmo que esse não
esteja explicitado. Mas, afinal, o que são essas anotações? O que elas
representam?

Essas anotações representam o escopo que um Managed Bean irá

trabalhar durante o ciclo de vida de uso daquele site. Um escopo define o
tempo de vida daquele Managed Bean. Quando se usa @RequestScope,

68 Laboratório de Programação II
o Managed Bean só é enviado para a memória ao ser requisitado e,
logo depois, saindo da memória e perdendo todos os dados. Em outros
escopos os dados ficam armazenados para serem consultados poste-
riormente. Quanto mais tempo ou mais dados forem guardados, mais
pesada vai ficar a sua aplicação, por isso não é aconselhável guardar
tudo no escopo. Cada situação deve ser analisada com calma.

Os escopos são definidos pelas anotações presentes no paco-

te javax.faces.bean, e os escopos disponíveis são @RequestScoped,
@NoneScoped, @ViewScoped, @SessionScoped, @ApplicationScoped e
@CustomScoped. No Quadro 1 temos o detalhamento de cada um deles.

Quadro 1
Escopos do JSF

Nome do escopo Descrição

Quando um @ManagedBean não tem uma anotação de escopo definida, automa-
@RequestScoped ticamente é utilizado @RequestScoped. Ele tem curta duração e a informação do
bean dura o período de uma requisição HTTP.
É um escopo de curta duração, o qual só dura enquanto ele estiver sendo injetado
@NoneScoped
ou utilizado por uma requisição. Costuma ser pouquíssimo usado.
É muito parecido com o @RequestScoped, mas a duração desse escopo tem a ver
@ViewScoped com a quantidade de tempo que uma página JSF fica aberta, e não com a duração
da requisição HTTP.
É um escopo de longa duração. Ele é criado na primeira solicitação HTTP do site
@SessionScoped e é destruído quando a sessão HTTP é invalidada, o que não necessariamente
representa o fechamento do navegador.
É um escopo de longa duração, sendo criado na primeira requisição HTTP do site,
@ApplicationScoped mas destruído quando a página web é fechada, via mudança de url para um outro
site ou fechamento de aba do navegador.
É uma opção para customizar o uso de escopo. Usando-o você poderá personali-
@CustomScoped
zar o ciclo de vida de um Managed Bean.
Fonte: Elaborado pelo autor.
Vídeo
O JSF diferencia-se das outras linguagens de programação para No vídeo Curso de
web pelo uso do facelets e do escopo da aplicação. A maioria das JSF – Principais Scopos
ManagedBean, do canal
linguagens trabalha somente com escopos de sessão e de requisi- Alex - JDev Treinamento
on-line, conheça melhor
ção, diferentemente do JSF. Por isso, conhecer melhor esse tema é cada escopo do JSF.
tão importante, pois assim é possível extrair o máximo do potencial Disponível em: https://
dessa linguagem de programação, além de evitar problemas com www.youtube.com/
watch?v=uTR3ApYplho. Acesso
performance e consumo de memória. em: 1 abr. 2021.

Criando páginas avançadas com Java 69

 CONSIDERAÇÕES FINAIS
Neste capítulo tivemos um grande avanço na criação de páginas dinâ-
micas com JSF. Com base nos conhecimentos adquiridos com a criação
de CRUDs, é possível realizar a criação de softwares complexos, mas que
guardam informações importantes para o usuário. Além disso, vimos a
importância de conhecer os escopos do JSF para corretamente utilizar o
ciclo de vida da aplicação, evitando gastos de memória de maneira desne-
cessária. Com esses conceitos, alinhados ao uso do Bootstrap, será pos-
sível criar páginas que serão utilizadas tanto em computadores como em
dispositivos móveis.

ATIVIDADES
1. Ao tentar abrir a tela uf.xhtml, é apresentada uma mensagem de erro:
Vídeo “Message /uf.xhtml @15,20 <h:inpText> TagLibrary not
supporter”
Em qual linha está acontecendo o problema?

2. Bill deseja adicionar um botão em uma página JSF. Para isso, ele
adiciona o seguinte código:
<h:commandButton value=”Listar” action=”#{novoBean.
listar()}”/>
Testando a alteração, Bill percebe que o botão não está com a cor
verde. Como ele pode resolver esse problema por meio do Bootstrap?

3. Qual dos escopos do JSF deve ser utilizado quando o site tem uma
única página e não precisa armazenar dados durante muito tempo?
Justifique sua resposta.

70 Laboratório de Programação II
 4
Arquitetura e persistência
de dados com Java
Quando um software está sendo projetado, é necessário veri-
ficar se ele precisa ou não de armazenamento de dados de modo
temporário. Caso seja identificada a necessidade de armazena-
mento permanente, devemos definir qual solução tecnológica será
usada. A mais utilizada são os sistemas gerenciadores de banco de
dados (SGBD), softwares específicos que gerenciam o armazena-
mento, o acesso e a organização dos dados.
Um SGBD é um programa de computador instalado em uma
máquina específica, também chamada de servidor de banco de
dados. Esse servidor será acessado pelo software que está sendo
desenvolvido. Neste capítulo iremos estudar os conceitos referen-
tes à forma de acesso e como um programa Java Web armazena
dados em um SGBD.

4.1 Modelo MVC

Vídeo Ao tratarmos de banco de dados em programas Java Web, preci-
samos rever o modelo arquitetural MVC (Model-View-Controller), o
qual define como os dados e o código-fonte devem estar organizados,
mantendo as responsabilidades definidas e garantindo a coesão do
código-fonte e a facilidade de manutenção. Vamos exemplificar para
melhor entendimento desse conceito:
• Quando um usuário clica em um botão e este não faz nada, o
problema está em um arquivo controller, pois ele tem a respon-
sabilidade de receber os comandos de clique de mouse e execu-
tar a operação solicitada.

Arquitetura e persistência de dados com Java 71

 • Caso os dados estejam sendo apresentados de maneira errônea
em uma tela, o problema está em um arquivo model, pois ele
acessa a base e traz os dados.
• Se as informações estão sendo apresentadas de maneira não
amigável, o problema está em um arquivo view, que se refere às
telas acessadas pelo usuário.

Na Figura 1 encontramos a sequência de fluxo sugerida pela ar-

quitetura MVC. Percebemos que tudo começa com uma ação do
usuário em um navegador web. A sequência do fluxo vai para o con-
troller, que decidirá se retorna uma tela (view) para o usuário ou se
precisa de um processamento de dados no model. Por fim, o model
acessa o banco de dados, realizando pesquisas, atualizações, inser-
ções e remoções de dados.
Figura 1
Sequência de fluxo da arquitetura MVC

Navegador web

VIEW

CONTROLLER

MODEL

Banco de
dados

Fonte: Elaborada pelo autor.

Na Figura 2 observamos como é aplicado o modelo MVC em um

projeto Java Web (JavaEE). Percebemos que tudo começa com uma
ação do usuário em um navegador web, independentemente de siste-
ma operacional ou navegador. Essa ação pode ser a solicitação de um

72 Laboratório de Programação II
endereço na internet, como http://localhost:8080/seuProjeto, ou um
clique em algum componente apresentado na tela, como um botão.

Dada essa ação, é acionado um arquivo com a anotação

@ManagedBean, que é um controller. Este decidirá se retorna uma tela
em JSF (arquivo .xhtml) para o usuário ou se precisa de um processamen-
to de dados no model. Caso necessite de um acesso ao módulo model, o
@ManagedBean procurará outros arquivos com a extensão .java. Caso
seja uma ação que não precise de banco de dados, será acessado um ar-
quivo .java simples; do contrário, o @ManagedBean irá acessar um arqui-
vo do tipo DAO.java, que tem todas as maneiras de manipular dados em
uma base de dados.

O Data Access Object (DAO) é um padrão de projeto (design pattern),

representando uma convenção documentada de como resolver um
problema. Ao utilizá-lo, usaremos uma forma comum de organização
para o acesso aos dados e a sua manipulação dentro de um software,
independentemente da linguagem de programação empregada. Vídeo
Para saber mais do
Todo DAO precisa estar vinculado a um modelo de dados mapea-
padrão de projeto DAO,
do em uma classe Java. Esse modelo deve representar uma entida- assista ao vídeo Aula
2276: o padrão DAO Data
de, também chamada de tabela, na base de dados. Os arquivos que
Access Object, do canal
representam um modelo de dados terão a anotação @Entity logo no Neri Neitzke.

início do arquivo. Tanto o DAO quanto o arquivo contendo o @Entity Disponível em: https://youtu.
be/2jYssOFIPxY?t=67. Acesso
são considerados parte do módulo model do MVC. Observemos na
em: 8 abr. 2021.
Figura 2 a aplicação do MVC no Java Web.
Figura 2
Aplicação do MVC no projeto Java Web

Navegador web

Contêiner web – Apache Tomcat

Página JSF

@ManagedBean

DAO @Entity

Banco
de
Fonte: Elaborada pelo autor. dados

Arquitetura e persistência de dados com Java 73

 Para fechar o entendimento conceitual de como o MVC é aplicado
em um projeto web, vamos unir as duas figuras anteriores, gerando
a Figura 3, que solidifica os conceitos até aqui apresentados. Vale
ressaltarmos que o Apache Tomcat tem a responsabilidade de tor-
nar o software disponível para acesso, e não de executar o fluxo
MVC. A sequência do fluxo é a forma como programamos, ou seja,
é responsabilidade do desenvolvedor ou do arquiteto de software
implementá-la corretamente.
Figura 3
Especificação MVC com Java Web

Navegador web

VIEW Contêiner Web – Apache Tomcat

Página JSF

CONTROLLER

@ManagedBean

DAO @Entity
MODEL

Banco
de
dados

Fonte: Elaborada pelo autor.

É essencial que dominemos o conceito arquitetural MVC e o padrão

DAO, pois ambos serão muito utilizados durante as próximas seções
deste capítulo. Vale lembrarmos que MVC e DAO não são os únicos mo-
delos arquiteturais e padrões de projeto existentes. Estudar mais esses
temas nos tornará desenvolvedores mais profissionais e qualificados
para atuar diariamente.

4.2 Mapeamento objeto-relacional (ORM)

Vídeo Uma das características da linguagem Java é ela estar vinculada dire-
tamente ao paradigma orientado a objetos. Esse paradigma é diferente
da maioria dos sistemas gerenciadores de banco de dados (SGBD), que
geralmente trabalham com o modelo estruturado. Para que um pro-

74 Laboratório de Programação II
 grama Java e um SGBD consigam se comunicar, é necessária uma ca-
mada intermediária de tradução dos formatos de dados. Essa camada
é denominada ORM (Object-relational Mapping), ou mapeamento objeto
relacional, e implementada por diversos frameworks, em especial o
Hibernate. Na Figura 4 visualizamos a camada ORM entre o SGBD e as
classes do projeto Java Web.
Figura 4
ORM como um interpretador dos objetos e do SGBD

Objeto
A
O
Objeto Objeto
R SGBD
B C
M
Objeto
D

Fonte: Elaborada pelo autor.

Outro benefício que uma implementação de ORM traz ao software

é a independência de SGBD com programa Java Web. Vejamos um
exemplo para melhorar o entendimento: cada SGBD tem uma forma
de acessar e manipular dados, e se um arquiteto de software não esti-
ver atento a isso, o projeto ficará dependente de uma base de dados de
um fabricante específico. Além disso, caso seja necessário, trocar de
banco de dados será muito custoso. Com ORM, o código-fonte em
Java poderá utilizar uma base de dados da Oracle e facilmente trocar
por uma base de dados da Microsoft, sem muitas preocupações, já
que as implementações de ORM sabem como fazer as traduções para
os principais SGBD do mercado.

No Quadro 1 a seguir apresentamos uma lista de implementações

de ORM que podem ser utilizadas na linguagem de programação Java.
Quadro 1
Lista de implementações de ORM

Nome Licenciamento Link

ActiveJDBC Open source https://javalite.io/activejdbc
Apache Cayenne Open source https://cayenne.apache.org/
Apache OpenJPA Open source http://openjpa.apache.org/
(Continua)

Arquitetura e persistência de dados com Java 75

 Nome Licenciamento Link
DataNucleus Open source https://www.datanucleus.org
Ebean Open source https://ebean.io/
EclipseLink Open source http://www.eclipse.org/eclipselink/
Enterprise JavaBeans (EJB) – Presente no pacote JavaEE na JDK
Hibernate Open source http://hibernate.org/
Java Data Objects (JDO) – Presente no pacote JavaEE na JDK
JOOQ Object Oriented Querying Proprietário http://www.jooq.org/
TopLink Proprietário (Oracle) https://www.oracle.com/middleware/technologies/top-link.html

Fonte: Elaborado pelo autor.

Dessas implementações de ORM, a mais utilizada é o Hibernate, o

qual será objeto de estudo na próxima seção.

4.3 Hibernate e JPA

Vídeo O Hibernate é uma implementação de ORM com o seu código-fonte
aberto (open source). Ele foi criado pela empresa JBoss em 2001 e atual-
mente é mantido pela empresa Red Hat, que comprou a primeira.

Quando o Hibernate surgiu, rapidamente se popularizou entre os

desenvolvedores Java, pois resolvia a complexidade que o protocolo
JDBC tinha para trabalhar com bancos de dados. Com o Hibernate,
facilmente é possível vincular um objeto em Java para uma tabela na
base de dados. Além disso, ele implementa duas maneiras de manipu-
lação de dados: o HQL e o SQL. A diferença entre ambos está na forma
como são escritos comandos para o SGBD. No HQL, fazemos a escrita
chamando os objetos conforme os nomes do arquivo Java. Já no SQL,
escrevemos os comandos de modo nativo, como se estivéssemos ma-
nipulando dados em um SGBD.

O Hibernate é composto de diversos pacotes, cada um resolvendo

determinado problema, mas todos precisam estar interligados ao pa-
cote Hibernate ORM, que é considerado o core (núcleo) de todos os
demais. Os pacotes opcionais são:
• Hibernate Annotations: usado para facilitar a escrita do
Hibernate, deu origem ao JPA.
• Hibernate EntityManager: usado para gerenciar a persistência de
dados.

76 Laboratório de Programação II
 • Hibernate Envers: usado para auditoria e versionamento dos mo-
delos de classes.
• Hibernate OGM: usado para armazenamento em bases de dados
não relacionais (NoSQL).
• Hibernate Search: usado para integrar pesquisas em bibliotecas
de grandes textos.
• Hibernate Tools: suite de ferramentas acessórias para o Hibernate.
• Hibernate Validator: usado para criar validações nos campos de
um modelo.

Quando o pacote Hibernate Annotation surgiu em 2005, ele trou-

xe mais simplicidade para as complicadas configurações em XML
que o Hibernate utilizava. A seguir temos um exemplo das anota-
ções do Hibernate sendo usadas para mapear uma entidade e os
campos de um SGBD:

import javax.persistence.*;

@Entity
@Table(name = “Uf”)
public class Uf {
@Column(name = “nome_uf”)
private String nomeUf;

@Column(name = “sigla_uf”)
private String siglaUf;
}

Com o sucesso do Hibernate, tanto em estabilidade (ausência de Vídeo

falhas) quanto em número de desenvolvedores o utilizando, o JCP Para conhecer a diferen-

ça entre os protocolos
reuniu-se e entendeu que as boas experiências promovidas pelo JDBC e JPA assista ao
Hibernate deveriam fazer parte do pacote JavaEE. Assim, surgiu a vídeo JPA com Hibernate –
#02 – JDBC x JPA, do ca-
especificação JSR 220, a qual tornou possível usar nativamente as nal Descompila.
anotações que antes estavam somente no Hibernate Annotation. Disponível em: https://
Isso foi a base para a formulação do protocolo JPA, permitindo que www.youtube.com/
watch?v=B6RYZ5cgQ2I. Acesso
um desenvolvedor consiga manipular um SGBD sem usar uma fer- em: 8 abr. 2021.
ramenta específica de ORM. Porém, é bem comum encontrarmos
projetos utilizando JPA com Hibernate, pois ambos se complemen-
tam e tornam muito mais poderosas as manipulações e transações
de dados.

Arquitetura e persistência de dados com Java 77

 4.4 Configurando Hibernate e JPA
Vídeo
Agora vamos começar a configuração do Hibernate com JPA no
projeto que estamos desenvolvendo de cadastro de unidades fede-
rativas. Para isso, devemos retornar ao projeto ExemploCrudJSF, no
qual faremos duas alterações:
1. Alterar o arquivo pom.xml, adicionando as dependências do
Hibernate.
2. Criar um arquivo de configuração para o Hibernate, identificando
onde a base de dados está instalada.

Vamos à primeira alteração. Siga os passos a seguir para realizar a

configuração correta:
a. Abra o arquivo pom.xml.
b. Insira o seguinte código dentro das tags:

<dependencies></dependencies>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.30.Final</version>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.30.Final</version>
</dependency>
c. Salve as alterações para que o Maven realize o download dessas
novas dependências em sua máquina.

Perceba que adicionamos as bibliotecas do Hibernate Core e do

Hibernate EntityManager. Não precisamos adicionar o Hibernate
Annotation, pois ele faz parte do pacote Hibernate Core. O arquivo
pom.xml deve ficar do seguinte modo:
<project xmlns=”http://maven.apache.org/POM/4.0.0”
xmlns:xsi=”http://www.w3.org/2001/
XMLSchema-instance”

78 Laboratório de Programação II
 xsi:schemaLocation=”http://maven.apache.org/
POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd”>
<properties>
<maven.compiler.source>1.6</maven.compiler.
source>
<maven.compiler.target>1.6</maven.compiler.target>
</properties>
<modelVersion>4.0.0</modelVersion>
<groupId>br.com.aula</groupId>
<artifactId>ExemploCrudJSF</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>ExemploCrudJSF Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.30.Final</version>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</
artifactId>
<version>5.4.30.Final</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
<version>2.2.20</version>
</dependency>

<dependency>
<groupId>com.sun.faces</groupId>
(Continua)

Arquitetura e persistência de dados com Java 79

 <artifactId>jsf-impl</artifactId>
<version>2.2.20</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-web-api</artifactId>
<version>8.0.1</version>
<scope>provided</scope>
</dependency>
</dependencies>

<build>
<finalName>ExemploCrudJSF</finalName>
</build>
</project>
Para a segunda alteração, serão necessários os seguintes passos:
a. Clique com o botão direito do mouse no nome do projeto, selecione
a opção NEW e crie um source folder.
b. Dê o nome src/main/resources para o novo source folder. Seu
projeto deverá ficar conforme a Figura 5.

Figura 5
Criação do source folder src/main/resources

Hibernate Tools

c. Dentro do novo source folder, crie uma pasta chamada META-INF.

Para isso, clique com o botão direito do mouse no source folder
resources e selecione a opção NEW → FOLDER. Atenção, pois o
nome tem que estar em letras maiúsculas.
d. Dentro dessa pasta, crie um arquivo. Para isso, clique com o botão
direito do mouse na pasta META-INF e escolha a opção NEW →
FILE. Dê o seguinte nome para o novo arquivo: persistence.xml.

80 Laboratório de Programação II
O resultado você pode conferir na figura a seguir.
Figura 6
Criação do arquivo persistence.xml

Hibernate Tools
e. Abra o arquivo persistence.xml e insira o código a seguir:
<?xml version=”1.0” encoding=”UTF-8”?>

<persistence version=”2.1” xmlns=”http://xmlns.

jcp.org/xml/ns/persistence” xmlns:xsi=”http://
www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/
persistence http://xmlns.jcp.org/xml/ns/persistence/
persistence_2_1.xsd”>

<persistence-unit name=”id_persistencia”>
<provider>org.hibernate.ejb.
HibernatePersistence</provider>
<properties>
<property name=”javax.persistence.jdbc.driver”
value=”org.postgresql.Driver” />
<property name=”javax.persistence.jdbc.user”
value=”postgres” />
<property name=”javax.persistence.jdbc.
password” value=”123” />
<property name=”javax.persistence.jdbc.url”
value=”jdbc:postgresql://localhost:5432/postgres” />
<property name=”hibernate.hbm2ddl.auto”
value=”update” />
<property name=”hibernate.show_sql”
value=”true” />
<property name=”hibernate.format_sql”
value=”true” />
<property name=”hibernate.dialect” value=”org.
hibernate.dialect.PostgreSQLDialect” />
(Continua)

Arquitetura e persistência de dados com Java 81

 </properties>
</persistence-unit>
</persistence>
f. Salve as alterações realizadas no arquivo persistence.xml.

Com essas duas configurações, o projeto está pronto para utilizar

Vídeo JPA e Hibernate. O arquivo persistence.xml está configurado para uma
Para saber mais das di- base de dados local do tipo PostgreSQL. Para instalá-la, faça o download
ferenças entre Hibernate
e JPA e suas configu- no link https://www.postgresql.org/download/. Não se esqueça de criar
rações, bem como das um usuário chamado postgres e a senha 123 logo após a instalação.
configurações do arquivo
persistence.xml, assista Caso já tenha o PostgreSQL instalado na sua máquina, utilize o login e a
ao vídeo JPA Hibernate senha já configurados. Também não se esqueça de mudar as seguintes
| Gabriel Cestaro | Papo
Reto | T5E22, do canal linhas no arquivo persistence.xml:
Bluesoft Labs.
• <property name=”javax.persistence.jdbc.user”
Disponível em: https://www.youtube. value=”SEU_USUARIO” />
com/watch?v=daMRdytFdG0. Acesso
em: 8 abr. 2021. • <property name=”javax.persistence.jdbc.password”
value=”SUA_SENHA” />

CONSIDERAÇÕES FINAIS
Neste capítulo aprendemos os conceitos que envolvem o acesso aos
dados e a sua manipulação em um SGBD por meio de um software de-
senvolvido em Java Web. Além disso, configuramos o sistema para que
prossigamos o uso de JPA e Hibernate. Cada vez mais estamos tornando
o sistema completo e pronto para atender às necessidades dos usuários
que usam soluções na internet.

ATIVIDADES
1. Para qual finalidade utilizamos o padrão de projeto DAO em um
Vídeo
projeto web?

2. Qual é a função de um ORM?

3. Qual é a diferença entre HQL e SQL?

82 Laboratório de Programação II
 5
Anotações do JPA e
injeção de dependência
Estamos nos aproximando da finalização de um sistema com-
pleto utilizando JSF e banco de dados, o qual poderá ser acessado
por qualquer pessoa na internet.
Neste capítulo entenderemos como são realizadas as principais
operações por meio de comandos que o usuário realiza com um
código-fonte em Java. Para isso, usaremos a base de dados gratuita
H2. Caso você tenha familiaridade com outra, não há problemas
em utilizá-la, mas não se esqueça de colocar a configuração correta
no arquivo persistence.xml.
Além dos conceitos de base de dados, abordaremos o framework
Spring, que nos ajuda em diversos pontos da programação, em es-
pecial na injeção de dependência. Trata-se de um padrão de merca-
do, pois ele facilita o dia a dia de desenvolvimento, evitando que as
classes tenham muito acoplamento, ou seja, estejam vinculadas em
memória pela cláusula new NomeDaClasse().
Ao final deste capítulo, teremos os conhecimentos necessários
para criarmos softwares em Java Web que poderão ser utilizados
de qualquer dispositivo conectado à internet.

5.1 Anotações do Hibernate e JPA

Vídeo Para usarmos o JPA ou o Hibernate, precisamos relembrar o que são
as anotações em Java, também conhecidas como annotations. Trata-se
de um comando predefinido que executa diversas ações por meio dele
mesmo. Toda anotação começa com o símbolo @ (arroba) e costuma
ficar na parte superior ao código que irá utilizá-la. Elas não são exclu-
sividade da biblioteca JPA ou do framework Hibernate, já que as en-

Anotações do JPA e injeção de dependência 83

 Vídeo contramos quando queremos trabalhar com testes (@Test), além de
Para saber mais a respeito podermos criar as nossas próprias anotações.
das anotações, assista ao
vídeo Curso de Java 65: Exemplo de anotação:
annotations (anotações), do
canal Loiane Groner, que é @Test
Java champion pela Oracle. public void metodoTest() {
Disponível em: https://www. // codigo de teste a ser desenvolvido
youtube.com/watch?v=6M8EE_ }
oRwtM&t=5s. Acesso em: 28
abr. 2021. Há diversas anotações que podem ser utilizadas pelo JPA e pelo
Hibernate, algumas com o mesmo nome em ambos os pacotes, por isso
conhecer qual deve ser utilizada evita possíveis bugs (defeitos) no siste-
ma. A causa dessa duplicação de nomes deve-se à origem do ORM. O
Hibernate surgiu antes do JPA e, devido ao seu sucesso, uma biblioteca
nativa do Java foi criada para lidar com a técnica de ORM. Os criadores do
JPA decidiram manter os nomes já utilizados no Hibernate para evitar que
os programadores precisassem decorar outras nomenclaturas. Mas como
saber qual anotação é a correta?

A resposta para essa dúvida é sempre priorizar as anotações da bi-

blioteca javax.persistence (Figura 1), pois elas representam a biblio-
teca JPA. Quando a anotação é do pacote org.hibernate.annotations,
ela refere-se ao framework Hibernate. Já quando não existe no JPA,
não há problemas em utilizar a do Hibernate com as demais anota-
ções JPA. Ambas funcionam corretamente, sem criarem defeitos
Figura 1
Anotação @Entity do pacote javax.persistence
Eclipse

No Quadro 1 vemos as principais anotações do JPA e qual função

cada uma exerce.

84 Laboratório de Programação II
 Quadro 1
Principais anotações e respectivas funções do JPA

Anotação Função
Identifica que uma classe Java representará uma tabela no banco de dados, mas desde que o
@Entity
nome da classe seja o mesmo da tabela na base de dados.
Utilizada com a anotação @Entity, por meio dela é possível vincular uma classe Java com
@Table uma tabela do banco de dados mesmo que tenham nomes diferentes. Para isso, usamos:
@Table(name = ”nome_da_tabela”).
Sinaliza que um atributo da classe será utilizado como chave primária da base de dados, sendo
@Id
ele único e não nulo.
Usada com a anotação @Id, define a estratégia de numeração da chave primária, podendo ser:
• GenerationType.AUTO;
• GenerationType.IDENTITY;
@GeneratedValue
• GenerationType.SEQUENCE;
• GenerationType.TABLE.
Exemplo: @GeneratedValue(strategy = GenerationType.TABLE).
Sinaliza que um atributo da classe será referenciado como uma coluna na base de dados. Po-
demos personalizar essa anotação utilizando as propriedades que ficam dentro dos parênteses,
sendo todas de uso opcional.
@Column(name = “nome_coluna”, nullable = false, length = 10, precision = 10, scale = 2 )
• Name: usada quando o nome do atributo é diferente do nome da coluna na base de dados.
@Column
• Nullable: usada quando o campo na base de dados é de preenchimento obrigatório.
• Length: determina a quantidade de caracteres que será salva na base de dados.
• Precision: estabelece a quantidade de dígitos que um campo numérico tem (considerando
dígitos após a vírgula).
• Scale: determina a quantidade de dígitos após a vírgula. Exemplo: 123,45 (precision = 5; scale = 2).
Vincula campos que estão em tabelas distintas na base de dados e que têm a relação de cardi-
@OneToOne
nalidade UM PARA UM (1 – 1).
Vincula campos que estão em tabelas distintas na base de dados e que têm a relação de cardi-
@OneToMany
nalidade UM PARA MUITOS (1 – N).
Vincula campos que estão em tabelas distintas na base de dados e que têm a relação de cardi-
@ManyToOne
nalidade MUITOS PARA UM (N – 1).
Vincula campos que estão em tabelas distintas na base de dados e que têm a relação de cardi-
@ManyToMany
nalidade MUITOS PARA MUITOS (N – N).

Fonte: Elaborado pelo autor.

Agora vamos para a prática. Retorne ao projeto ExemploCrudJSF e

abra o arquivo Uf.java, que está no pacote br.com.aula.model. Em se-
guida, realize a seguinte sequência de passos:

Anotações do JPA e injeção de dependência 85

 Leitura 1. Adicione a anotação @Entity antes da declaração da classe:
Para conhecer as demais
anotações do JPA, acesse @Entity
o link a seguir e leia a public class Uf {
respeito do tema.

Disponível em: https://dzone. 2. Insira as anotações @Id e @GeneratedValue antes da

com/articles/all-jpa-annotations-
declaração do atributo id. Use a estratégia AUTO na anotação
mapping-annotations. Acesso em:
28 abr. 2021. @GeneratedValue:

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;

3. Adicione a anotação @Column antes da declaração do atributo

sigla. Não se esqueça de marcar esse campo como obrigatório e
garantir que ele receba somente dois caracteres:

@Column(nullable = false, length = 2)

private String sigla;

4. Insira a anotação @Column antes da declaração do atributo

nome. Não se esqueça de marcar esse campo como obrigatório e
garantir que ele receba somente 20 caracteres:

@Column(nullable = false, length = 20)

private String nome;

O código-fonte deverá ficar assim:

package br.com.aula.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Uf {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;

@Column(nullable = false, length = 2)

private String sigla;
(Continua)

86 Laboratório de Programação II
 @Column(nullable = false, length = 20)
private String nome;

public Integer getId() {

return id;
}

public void setId(Integer id) {

this.id = id;
}

public String getNome() {

return nome;
}

public void setNome(String nome) {

this.nome = nome;
}

public String getSigla() {

return sigla;
}

public void setSigla(String sigla) {

this.sigla = sigla;
}
}
Agora vamos exercitar o uso das anotações que representam a liga-
ção entre duas tabelas na base de dados. Para isso, devemos criar uma
classe que se chamará Cidade.java. A regra para a ligação entre unidade
federativa (UF) e cidade é que a primeira pode ter uma ou mais cidades,
ou seja, usaremos a anotação @OneToMany. O inverso será o fato de
muitas cidades fazerem parte de uma unidade federativa, dessa forma,
usaremos a anotação @ManyToOne. Confira o passo a passo:
1. Crie uma classe e dê a ela o nome de Cidade.java.
2. Insira o código a seguir.
package br.com.aula.model;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
(Continua)

Anotações do JPA e injeção de dependência 87

 import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;

@Entity
public class Cidade {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;

@Column(nullable = false, length = 50, name =

“nome_cidade”)
private String nomeCidade;

@ManyToOne
private Uf uf;

public Integer getId() {

return id;
}

public void setId(Integer id) {

this.id = id;
}

public String getNomeCidade() {

return nomeCidade;
}

public void setNomeCidade(String nomeCidade) {

this.nomeCidade = nomeCidade;
}

public Uf getUf() {
return uf;
}

public void setUf(Uf uf) {

this.uf = uf;
}
}

3. Retorne a classe Uf.java e adicione o seguinte código logo depois

do atributo private String nome.
@OneToMany(mappedBy = “uf”)
private List<Cidade> cidades;
4. Para o novo código inserido, utilize o tipo list do pacote java.util.

88 Laboratório de Programação II
 5. Não se esqueça de criar os métodos acessores desse novo
atributo na classe Uf.java:

public List<Cidade> getCidades() {

return cidades;
}
public void setCidades(List<Cidade> cidades) {
this.cidades = cidades;
}

Com esses novos códigos, temos duas classes representando duas

tabelas. Até o momento, as tabelas e os campos na base de dados não
existem, pois quem criará todo o modelo de dados será o Hibernate na
primeira execução do software. Assim, serão elaboradas duas tabelas
denominadas de uf e cidade, nomes esses que são os mesmos da classe,
pois não utilizamos a anotação @Table.

Na tabela uf teremos três campos, que são:

• Id: do tipo numérico, chave primária e com geração de números
controlada pelo banco de dados de maneira automática.
• Sigla: do tipo texto, não podendo ser nula e precisando ter o ta-
manho máximo de dois caracteres.
• Nome: do tipo texto, não podendo ser nulo e precisando ter o
tamanho máximo de 20 caracteres.

Notamos que não haverá um campo chamado de cidades na base

de dados, já que esse mapeamento é somente para a ligação das
tabelas no JPA.

Na tabela cidade teremos três campos, que são:

• Id: do tipo numérico, chave primária e com geração de números
controlada pelo banco de dados de modo automático.
• Nome_cidade: do tipo texto, não podendo ser nulo e precisando
ter o tamanho máximo de 50 caracteres.
• Uf: chave estrangeira, guardará o identificador numérico (cha-
ve primária da tabela uf) de qual unidade federativa pertence
aquela cidade.

Desse modo, encerramos o estudo de anotações e mapeamento de

objetos com as tabelas da base de dados. Na sequência, aprenderemos
como transformar esse mapeamento em uma base de dados real para,
em seguida, realizarmos as operações CRUD de unidade federativa e
cidade, as quais terão os dados persistidos na base de dados.
Anotações do JPA e injeção de dependência 89
 5.2 Gerenciando conexões
Vídeo Nesta seção criaremos as conexões entre a nossa aplicação e a base
de dados. Para isso, utilizaremos a base de dados H2 em memória,
assim, não precisaremos instalar um SGBD completo em nosso com-
putador. O H2 é gratuito e, por estarmos o usando em memória, cada
vez que o Apache Tomcat for parado, todos os dados serão perdidos.

Saiba mais Caso você tenha preferência por outro SGBD, será preciso realizar al-
Acesse o link a seguir terações no arquivo persistence.xml e no applicationContext.xml, os quais
para saber quais con-
criaremos na sequência.
figurações utilizar para
outros bancos de dados. Caso você decida continuar usando o PostgreSQL, que já está confi-
Disponível em: https://examples. gurado, não é necessário fazer as alterações descritas a seguir.
javacodegeeks.com/enterprise-java/
jpa/java-persistence-xml-example/. Começaremos a configuração da nossa aplicação com a base H2.
Acesso em: 29 abr. 2021.
Para isso, executaremos os seguintes passos:
1. Abra o arquivo pom.xml e inclua uma nova dependência.

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.200</version>
<scope>runtime</scope>
</dependency>

2. Abra o arquivo persistence.xml (ele encontra-se na pasta src/

main/resources/META-INF) e:

a. apague todo o conteúdo do arquivo;

b. inclua todo o código a seguir:

<?xml version=”1.0” encoding=”UTF-8”?>

<persistence version=”2.1” xmlns=”http://xmlns.
jcp.org/xml/ns/persistence” xmlns:xsi=”http://
www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/
persistence http://xmlns.jcp.org/xml/ns/persistence/
persistence_2_1.xsd”>

<persistence-unit name=”id_persistencia”>
<provider>org.hibernate.jpa.
HibernatePersistenceProvider</provider>
<properties>
(Continua)

90 Laboratório de Programação II
 <property name=”javax.persistence.jdbc.
driver” value=”org.h2.Driver” />
<property name=”javax.persistence.jdbc.
user” value=”sa” />
<property name=”javax.persistence.jdbc.
password” value=”” />
<property name=”javax.persistence.jdbc.url”
value=”jdbc:h2:mem:test;DATABASE_TO_UPPER=false;DB_
CLOSE_DELAY=-1” />
<property name=”hibernate.hbm2ddl.auto”
value=”update” />
<property name=”hibernate.show_sql”
value=”true” />
<property name=”hibernate.format_sql”
value=”true” />
<property name=”hibernate.dialect”
value=”org.hibernate.dialect.H2Dialect”/>
<property name=”hibernate.temp.use_jdbc_
metadata_defaults” value=”false”/>
</properties>
</persistence-unit>
</persistence>
Essa configuração é a mais básica para que o software trabalhe
corretamente com o JPA, o Hibernate e o banco de dados. Com o passar
do tempo, mais pessoas usarão o sistema e, a cada novo acesso, um vín-
culo com a base de dados será concretizado. Devido ao somatório de vín-
culos, o sistema se tornará lento, por isso aconselhamos usar a técnica de
pool de conexões, a qual restringe a quantidade de conexões na base de
dados a um valor determinado (por exemplo, 20 conexões simultâneas,
independentemente da quantidade de usuários conectados simultanea-
mente no sistema). Para implementar o pool de conexões, utilizaremos a
biblioteca C3P0, incluindo-a no pom.xml e adicionando novas proprieda-
des ao arquivo persistence.xml. Seguem os passos:
1. Abra o arquivo pom.xml e adicione a nova dependência.
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>5.4.30.Final</version>
</dependency>

Anotações do JPA e injeção de dependência 91

 2. Abra o arquivo persistence.xml e, dentro da tag <properties>,
adicione as propriedades a seguir:
Vídeo <property name=”connection.provider_
Para aprender mais class” value=”org.hibernate.connection.
sobre pool de conexões C3P0ConnectionProvider”/>
e C3P0, assista ao vídeo <property name=”hibernate.c3p0.min_size” value=”10” />
Pool de conexões C3P0 e
JPA, do canal Alex – JDev
<property name=”hibernate.c3p0.max_size” value=”20” />
Treinamento on-line. <property name=”hibernate.c3p0.acquire_increment”
Disponível em: https://www.youtube.
value=”1” />
com/watch?v=UfZ2Uc9hrEM. Acesso <property name=”hibernate.c3p0.idle_test_period”
em: 28 abr. 2021. value=”3000” />
<property name=”hibernate.c3p0.max_statements”
value=”50” />
<property name=”hibernate.c3p0.timeout” value=”1800”
/>
A seguir, na Figura 2, veja a tela do arquivo finalizado.
Figura 2
Arquivo persistence.xml finalizado

Fonte: Elaborada pelo autor.

Essa pequena alteração evitará diversos problemas de performance

que o software poderá ter no futuro. Desse modo, finalizamos as con-
figurações da base de dados H2 com o JPA. Na sequência, criaremos
um arquivo do tipo DAO para o modelo uf e o vincularemos ao @
ManagedBean.

92 Laboratório de Programação II
 5.3 Utilizando injeção de
Vídeo dependência com Spring
Para concluirmos as configurações e realizarmos as operações bá-
sicas de inserção, listagem, remoção e atualização em uma base de
dados, vincularemos o arquivo UfBean ao UfDao, que irá persistir os
dados na base H2.

Essa separação de arquivos é necessária para que o padrão MVC

seja seguido e as responsabilidades de cada classe sejam respeitadas.

Para reduzir o risco de acoplamento e o consumo excessivo de me-

mória entre os arquivos das camadas Controller e Model, costumamos
utilizar a técnica de injeção de dependência (DI, do inglês dependency
injection), que faz um relacionamento entre as classes envolvidas so-
mente quando elas de fato serão utilizadas, criando, assim, um víncu-
lo fraco, ou seja, uma injeção de dependência. Para tanto, usamos a
anotação @Inject ou a @Autowired, representando que aquele objeto
está sendo injetado na classe. Feito isso, não é necessário usar o co-
mando new NomeDaClasse(), pois, quando o utilizamos, criamos uma
dependência forte entre duas classes, o que queremos evitar.

Um dos primeiros frameworks que implementou esse conceito foi

o Spring, e é ele que empregaremos. Existe um pacote nativo do JEE
para tratar da injeção de dependência chamado de CDI, mas priori-
zaremos o Spring, por esse ser o líder de mercado e prover diversas
ferramentas de trabalho prontas.

O Spring é composto de vários pacotes, sendo o principal deles o

Spring Framework, que serve de base para os demais. No Quadro 2 temos
o nome e a descrição de algumas bibliotecas do Spring, as quais permitem
que o desenvolvimento de software seja mais leve.
Quadro 2
Descrição de bibliotecas do Spring

Nome da
Descrição
biblioteca
Pacote básico para o gerenciamento de transações, injeção de dependências e men-
Spring Framework
sagens e o controle de acesso a dados.

Utilizado para iniciar rapidamente um projeto com Spring, é uma ajuda muito boa
para quem está começando nesse framework. Com a experiência nessas bibliotecas,
Spring Boot
é possível escolher individualmente os pacotes que realmente serão utilizados e,
com isso, deixar de usar o Spring Boot.
(Continua)

Anotações do JPA e injeção de dependência 93

 Nome da
Descrição
biblioteca
Spring Data Apoia o acesso a dados em uma base de dados relacional ou não relacional.
Spring Cloud Usado para lidar mais facilmente com a computação distribuída.
Spring Security Gerencia as formas de autenticação e acesso ao sistema.
Spring Batch Facilita o trabalho de leitura de arquivos em batch.
Ajuda na autenticação de usuários em ferramentas específicas de validação de
Spring LDAP
acesso e que podem utilizar LDAP como protocolo de comunicação.
Spring for Android Ajuda programadores de Android no projeto de injeção de dependência.

Fonte: Elaborado pelo autor.

Leitura Agora vamos para as alterações:

Para saber mais a respei-
to dos projetos do Spring,
1. Inclua as novas dependências no arquivo pom.xml, adicionando,
acesse a documentação dentro da tag <dependencies>, as seguintes linhas:
oficial no link a seguir.

Disponível em: https://spring.io/ <dependency>

projects. Acesso em: 29 abr. 2021. <groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.5</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.5</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>5.3.5</version>
</dependency>

<dependency>

<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.5</version>
</dependency>

2. Altere o arquivo web.xml, que está na pasta src/main/webapp/WEB-

INF, e adicione a linha a seguir antes de fechar a tag </web-app>.

94 Laboratório de Programação II
 <listener>
<listener-class>org.springframework.web.context.
ContextLoaderListener</listener-class>
</listener>

A seguir, na Figura 3, confira a tela com configuração do arquivo web.xml.

Figura 3
Configuração do arquivo web.xml

Fonte: Elaborada pelo autor.

3. Crie o arquivo faces-config.xml em src/main/webapp/WEB-INF/:

<?xml version=”1.0” encoding=”UTF-8”?>
<faces-config xmlns=”http://xmlns.jcp.org/xml/
ns/javaee”
xmlns:xsi=”http://www.w3.org/2001/
XMLSchema-instance”
xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/
javaee/web-facesconfig_2_2.xsd”
version=”2.2”>
<application>
<el-resolver>org.springframework.web.jsf.
el.SpringBeanFacesELResolver</el-resolver>
</application>
</faces-config>

Anotações do JPA e injeção de dependência 95

 4. Crie o arquivo applicationContext.xml na pasta src/main/
webapp/WEB-INF e adicione a ele o seguinte código:
<?xml version=”1.0” encoding=”UTF-8”
standalone=”no”?>
<beans xmlns=”http://www.springframework.org/schema/
beans”
xmlns:p=”http://www.springframework.org/schema/p”
xmlns:tx=”http://www.springframework.org/schema/tx”
xmlns:context=”http://www.springframework.org/
schema/context”
xmlns:xsi=”http://www.w3.org/2001/
XMLSchema-instance”
xmlns:aop=”http://www.springframework.org/schema/aop”
xsi:schemaLocation=”http://www.springframework.
org/schema/beans
http://www.springframework.org/schema/beans/
spring-beans-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/
spring-tx-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/
spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/
spring-aop-3.0.xsd”>

<bean id=”dataSource”

class=”org.springframework.jdbc.datasource.
DriverManagerDataSource”>
<property name=”driverClassName” value=”org.
h2.Driver” />
<property name=”url”
value=”jdbc:h2:mem:test;DATABASE_TO_UPPER=false;DB_
CLOSE_DELAY=-1” />
<property name=”username” value=”sa” />
<property name=”password” value=”” />
</bean>

<bean
(Continua)

96 Laboratório de Programação II
 class=”org.springframework.orm.jpa.
LocalContainerEntityManagerFactoryBean”
id=”entityManagerFactory”>
<property name=”persistenceXmlLocation”
value=”classpath:./META-INF/persistence.xml” />

<property name=”dataSource” ref=”dataSource” />

<property name=”jpaVendorAdapter”>
<bean class=”org.springframework.orm.jpa.vendor.
HibernateJpaVendorAdapter”>
<property name=”databasePlatform” value=”org.
hibernate.dialect.H2Dialect” />
<property name=”showSql” value=”true” />
<property name=”generateDdl” value=”false” />
</bean>
</property>
<property name=”jpaProperties”>
<props>
<prop key=”hibernate.max_fetch_depth”>3</prop>
<prop key=”hibernate.jdbc.fetch_size”>50</prop>
<prop key=”hibernate.jdbc.batch_size”>10</prop>
<prop key=”hibernate.hbm2ddl.auto”>update</prop>
</props>
</property>
</bean>

<context:component-scan
base-package=”br.com.aula”>
</context:component-scan>

<bean class=”org.springframework.orm.jpa.
JpaTransactionManager”
id=”transactionManager”>
<property name=”entityManagerFactory”
ref=”entityManagerFactory” />
</bean>

<tx:annotation-driven
transaction-manager=”transactionManager” />

<context:annotation-config />
<aop:config proxy-target-class=”true”/>
</beans>
Para checagem, a Figura 4 apresenta a estrutura de pastas e ar-
quivos do projeto.

Anotações do JPA e injeção de dependência 97

 Figura 4
Estrutura de pastas e arquivos do projeto

Eclipse

5. Crie a interface DAO elaborando um novo pacote no src/main e

atribuindo a ele o nome br.com.aula.dao. Dentro desse pacote, crie
uma interface chamada DAO.java e adicione a ela o código a seguir.
package br.com.aula.dao;
import java.util.List;
public interface DAO<T> {
List<T> findAll();
T findById(Integer id);
List<T> findByName(String name);
boolean save(T t);
boolean delete(Integer id);
}

98 Laboratório de Programação II
6. Elabore um arquivo chamado UfDao, o qual deve implementar
áreas do banho. Para isso, crie um pacote no src/main e atribua
a ele o nome br.com.aula.dao.impl. Dentro desse pacote, crie
outro arquivo chamado UfDao.java e adicione o código a seguir:
package br.com.aula.dao.impl;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.
Transactional;
import br.com.aula.dao.DAO;
import br.com.aula.model.Uf;

@Repository
@Transactional
public class UfDao implements DAO<Uf> {

@PersistenceContext
public EntityManager entityManager;

@Override
public List<Uf> findAll() {
return entityManager.createQuery(“from Uf”).
getResultList();
}

@Override
public Uf findById(Integer id) {
Query query = entityManager.createQuery(“from Uf
where id = :pId”);
query.setParameter(“pId”, id);
return (Uf) query.getSingleResult();
}

@Override
public List<Uf> findByName(String name) {
Query query = entityManager.createQuery(“from
Uf where nome like :pNome”);
query.setParameter(“pNome”, “%” + name + “%”);
return query.getResultList();
}

@Override
public boolean save(Uf uf) {
(Continua)

Anotações do JPA e injeção de dependência 99

 try {
if (uf.getId() != null) {
entityManager.merge(uf);
} else {
entityManager.persist(uf);
}
} catch (Exception e) {
return false;
}
return true;
}

@Override
public boolean delete(Integer id) {
Uf uf = findById(id);
entityManager.remove(uf);
return true;
}

}
7. Altere o controlador UfBean para que ele consiga operar as
funcionalidades básicas, ou seja, para que faça uma inserção,
edição, listagem e remoção. Desse modo:

a. Insira a anotação @Component antes da anotação

@ManagedBean.
b. Depois da declaração da classe, insira o comando:
@Autowired
UfDao ufDao;
c. Substitua o método init, que tem um @PostConstruct, pelo
código a seguir:
@PostConstruct
public void init() {
if (list == null) {
list = ufDao.findAll();
}
}
d. Altere o método salvar() para o código:
public String salvar() {
if (ufDao.save(this.uf)) {
list = ufDao.findAll();
}
(Continua)

100 Laboratório de Programação II

 return “uf”;
}
e. Modifique o método remover() para o código:
public String remover(Uf uf) {
ufDao.delete(uf.getId());
list = ufDao.findAll();
return “uf”;
}
8. Salve todos os arquivos e suba o servidor Apache Tomcat.
Vídeo
Com essas alterações, agora temos um sistema em JSF que irá cha-
Para conhecer melhor o
mar um controller, o qual, por sua vez, irá chamar o modelo para per-
Spring Framework e de
sistir os dados em um SGDB. Esperamos que o sistema consiga listar, suas divisões, assista ao
vídeo Aula 3387 Spring
inserir, remover e atualizar dados.
– Introdução ao Spring
A seguir vemos as anotações utilizadas pelos arquivos: Framework.avi, do canal
Neri Neitzke, no link a
• Na classe UfDao, temos a anotação @Repository, que é utilizada seguir.

para o Spring identificar que a classe está na camada Model do Disponível em: https://youtu.
be/77O4zRagH2Y. Acesso em: 29
padrão MVC e que ela irá acessar a base de dados.
abr. 2021.
• Na classe UfDao, temos a anotação @Transactional e, por meio
dela, todas as operações são elegíveis para persistirem ou altera-
rem algo na base de dados.
• Na classe UfBean, temos a anotação @Component, maneira
mais simples de sinalizar que essa classe pode receber ou inje-
tar dependências.
• Por fim, na classe UfBean, temos a anotação @Autowired, que 1
serve para injetar uma dependência sem o vínculo de como. Todo o projeto está disponível
na plataforma GitHub (https://
Concluímos nosso estudo com um sistema web usando Java (JSF), github.com/wagnerfusca/
que tem persistência de dados (independentemente de qual seja), ExemploCrudJSF) para even-
1 tuais consultas.
injeção de dependência (DI) e controle de conexões (C3P0) .

CONSIDERAÇÕES FINAIS
Chegamos ao final deste capítulo e de nosso estudo. Agora temos a
base prática e todos os conceitos necessários para avançar na constru-
ção de sistemas web utilizando JSF e banco de dados. Para efeito prático,
desafiamos você a criar uma tela de cadastro de cidade e, posteriormen-
te, um cadastro de endereço que terá vínculo com as classes já criadas
(cidade e UF).

Anotações do JPA e injeção de dependência 101

 ATIVIDADES
1. Analise as especificações da tabela Pessoa e crie uma classe em Java
Vídeo
com o mapeamento objeto-relacional. Utilize as anotações do JPA e
do Hibernate. Para este exercício, não é necessário criar os métodos
acessores dos atributos (get e set).
As especificação são:
• campo id, do tipo numérico e com autoincremento;
• campo nome, do tipo texto, com preenchimento obrigatório e até
50 caracteres;
• campo RG, do tipo texto, com preenchimento não obrigatório e até
20 caracteres.

2. O que é o C3P0 e o que ele faz?

3. Descreva as vantagens de se usar a anotação @Autowired presente no

framework Spring.

102 Laboratório de Programação II

Gabarito
1 Introdução a Java Web
1. A especificação JPA é utilizada para configurar a persistência e o acesso
à base de dados. Já o JMS é uma especificação utilizada para troca de
mensagens assíncronas, podendo ser e-mails ou trocas de mensagens
dentro da aplicação. Ambas podem ser utilizadas dentro de um mesmo
projeto.

2. Apache Maven é o software que deverá ser baixado e configurado

pelo desenvolvedor em seu sistema operacional. Com ele, é possível
gerenciar as dependências do projeto e também construir o projeto
unificadamente, gerando independência das IDE. É incorreto afirmar
que o Maven é parte de um IDE ou, então, que ele é uma funcionalidade
de um IDE.

3. Para o desenvolvimento de um projeto Java Web, é necessário um

Java Developer Kit (JDK), uma IDE, como o Eclipse, um gerenciador de
dependências, como o Apache Maven, e um servidor web, como o
Apache Tomcat.

2 Criando páginas web com Java

1. Facelets é um padrão de código aberto que define uma possibilidade
de personalização do html, permitindo assim páginas de internet mais
dinâmicas.

2. Podemos utilizar os comandos h:commandLink ou h:outputLink para

referenciar páginas de um site. Já o h:commandLink faz essa função e
também consegue chamar um método presente no Managed Bean, ou
seja, o h:commandLink consegue acionar alguma validação realizada
com código Java antes de abrir uma tela.

3. MVC é um padrão arquitetural que visa separar as responsabilidades

de cada parte do código-fonte. No view, ficam os códigos referentes
à criação de telas. Já no controller ficam os códigos de comunicação
entre tela e a linguagem de programação e, no model, ficam as regras
de negócio da aplicação.

Gabarito 103
 3 Criando páginas avançadas com Java
1. O problema está acontecendo na linha 15, pois não existe o comando
<h:inpText>. O correto é <h:inputText>.

2. Bill precisa adicionar o código class=”btn btn-success” dentro da tag

<h:commandButton> para conseguir ter um botão verde.
<h:commandButton value=”Listar” action=”#{novoBean.listar()}” class=”btn
btn-success” />

3. Nesse caso devemos usar o escopo padrão, que é o mais leve de todos
e tem o ciclo de vida mais curto. O escopo padrão é o @RequestScoped.

4 Arquitetura e persistência de dados com Java

1. O padrão DAO propõe uma convenção na organização do código-fonte,
o que permite o reaproveitamento do código, facilitando sua manutenção.
A utilização do DAO independe de linguagem de programação.

2. ORM é a camada que faz a tradução de dois mundos distintos: o

do paradigma orientado a objetos e o dos SGBD. Existem diversas
implementações de ORM, sendo o Hibernate a mais conhecida.

3. SQL é o modo padronizado de escrever comandos para um SGDB,

sendo considerado a forma nativa de comunicação e manipulação de
dados. Já o HQL é uma forma de comunicação utilizada pelo Hibernate,
que usa os nomes de classes do Java para se comunicar com os SGBD.

5 Anotações do JPA e injeção de dependência

1.
@Entity
public class Pessoa {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Integer id;
@Column(nullable = false, length = 50)
private String nome;
@Column(name = “RG”, nullable = true, length =
20)
private String rg;
}

104 Laboratório de Programação II

2. O C3P0 é uma biblioteca que gerencia as conexões de um software em
uma base de dados, podendo ser encontrado na biblioteca hibernate-
c3p0. Ele utiliza a técnica de pool de conexões para fazer essa gestão,
prevendo que seja aberto um volume pequeno de conexões com a
base de dados e que elas sejam compartilhadas pelas diversas pessoas
que estão utilizando o sistema. Todo o gerenciamento é controlado
pelo C3P0.

3. Ao utilizarmos a anotação @Autowired, evitamos que as classes

tenham um vínculo forte entre elas, gerando, assim, um acoplamento
e um relacionamento forte entre ambas, dificultando a manutenção e
o crescimento do sistema. Essa anotação é utilizada para sinalizar uma
injeção de dependência.

Gabarito 105
 Referência
BOND, M. et al. Aprenda J2EE em 21 dias. Trad. de João Eduardo Nobrega. Ribeirão Preto:
Makron Books, 2003.

106 Laboratório de Programação II

 Laboratório de Programação I
Wagner Mendes Voltz

Código Logístico Fundação Biblioteca Nacional

ISBN 978-65-5821-025-2

I000018 9 786558 210252