desenvolvimento_de_software_para_web

Prévia do material em texto

L
U
IZ
 R
O
B
E
R
T
O
 B
A
R
A
C
H
O
 R
O
C
H
A
D
E
S
E
N
V
O
L
V
IM
E
N
T
O
 D
E
 S
O
F
T
W
A
R
E
 P
A
R
A
 W
E
B
Código Logístico
59547
Fundação Biblioteca Nacional
ISBN 978-85-387-6676-6
9 7 8 8 5 3 8 7 6 6 7 6 6
Desenvolvimento de 
Software para Web 
 Luiz Roberto Baracho Rocha
IESDE BRASIL
2020
© 2020 – 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: twenty20photos/ Rawpixel/EnvatoElements
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
CIP-BRASIL. CATALOGAÇÃO NA PUBLICAÇÃO 
SINDICATO NACIONAL DOS EDITORES DE LIVROS, RJ
R574d
Rocha, Luiz Roberto Baracho
Desenvolvimento de software para web / Luiz Roberto Baracho 
Rocha. - 1. ed. - Curitiba [PR] : Iesde, 2020. 
240 p. : il.
Inclui bibliografia
 ISBN 978-85-387-6676-6
1. Informatica (Sistemas de informação). 2. Programação de sistemas 
(Computação). 3. Programação para Internet. 4. Java (Linguagem de progra-
mação de computador). I. Título.
20-65729 CDD: 005.4
CDU: 004.45
Luiz Roberto 
Baracho Rocha
Mestre e graduado em Física pela Universidade Federal 
do Paraná (UFPR). Professor no ensino superior, 
ministrando as disciplinas de Programação Estruturada, 
Programação Orientada a Objetos, Programação para 
Web, Programação Cloud Computing, Algoritmos, 
Estrutura de Dados, Introdução à Informática, Engenharia 
de Software, Análise de Sistemas e Engenharia de 
Requisitos. Desenvolvedor e pesquisador no Laboratório 
de Ótica de Raios-X na UFPR e no Laboratório Sincroton 
no LNLS/CNPq. Atua também como desenvolvedor 
no Centro de Engenharia Biomédica na Universidade 
Estadual de Campinas (Unicamp).
SUMÁRIO
1 Fundamentos da programação para web 9
1.1 Criação da estrutura de um sistema web 9
1.2 Criação de um Dynamic Web Project 13
1.3 Gerenciamento das dependências do projeto 21
1.4 Arquitetura do sistema 23
1.5 Criação da camada de controller 25
1.6 Desenvolvimento da camada de apresentação 28
1.7 Realização de teste unitário para as classes do sistema 33
2 Desenvolvimento do back-end do sistema 40
2.1 Criação das classes de regra de negócio 40
2.2 Implementação da regra de negócio do sistema 43
2.3 Realização de teste unitário do back-end 51
3 Desenvolvimento da camada de persistência de dados 62
3.1 Desenvolvimento da camada de persistência de dados 62
3.2 Implementação da camada de persistência 69
3.3 Implementação das operações CRUD 79
3.4 Realização de teste unitário da camada de persistência 100
4 Segurança do software 116
4.1 Administração dos dados do sistema 116
4.2 Implementação do sistema de segurança 133
4.3 Realização de teste de funcionalidade 139
5 Publicação do sistema em servidor na nuvem 153
5.1 Criação de uma conta em um servidor 153
5.2 Configuração do banco de dados no servidor 155
5.3 Implantação do software no servidor 166
5.4 Definindo a identidade visual do sistema 172
 Gabarito 188
 Apêndice 237
APRESENTAÇÃOVídeo
O desenvolvimento de sistemas de informação baseados na Tecnologia 
Web tem evoluído de maneira significativa desde o início dos anos 1990, 
tornando-se uma tecnologia predominante da informática. A World Wide Web 
(WWW), ou simplesmente Web, conecta pessoas e empresas e gera novas 
oportunidades de negócios.
O desenvolvimento de sistemas Web utilizando a Programação Orientada 
a Objetos (POO) é baseado em Padrões de Projetos Orientados a Objetos 
(PPOO), os quais organizam e facilitam muito o desenvolvimento de aplicações. 
A arquitetura de um sistema Web utiliza o padrão MVC (Model, Controller, 
View), que separa as responsabilidades de um sistema, permitindo que as 
suas partes sejam desenvolvidas de modo independente.
A Plataforma Java EE (Java Enterprise Edition – em português, Edição 
Empresarial do Java) fornece suporte para o desenvolvimento Web por 
meio da criação de sistemas corporativos de missão crítica e distribuídos. O 
ecossistema Java EE é formado por diversos frameworks que possibilitam o 
desenvolvimento de sistemas profissionais de fácil entendimento, os quais 
facilitam a sua manutenção e contêm alto grau de escalabilidade, o que é um 
requisito fundamental para os sistemas atuais. 
Assim, nesta obra é proposto o desenvolvimento de um sistema Web que 
aplique os conceitos fundamentais do Desenvolvimento de Software para 
Web. Os frameworks utilizados na obra incluem: (a) JavaServer Faces (JSF), 
para o desenvolvimento da interface gráfica do sistema; (b) Servlet, para o 
tratamento das requisições e respostas que o sistema deve processar para 
o cliente do sistema; (c) Enterprise Java Bean (EJB), para o desenvolvimento 
da regra de negócio do sistema; (d) Java Database Connectivity (JDBC), para o 
desenvolvimento da persistência dos dados do sistema; e (e) Spring Security, 
para a implementação do sistema de autenticação e autorização do sistema.
O desenvolvimento da aplicação é realizado com a criação de um Dynamic 
Web Project do Eclipse, que contém uma estrutura de projeto adequada 
para o desenvolvimento Web. O servidor Tomcat é utilizado para executar 
a aplicação e a persistência de dados é feita com o banco de dados MySQL. 
Então, a aplicação é publicada na plataforma Heroku, permitindo que qualquer 
pessoa possa acessar e utilizar essa aplicação.
Dessa maneira, apesar de os desafios do desenvolvimento Web serem 
enormes, o produto obtido por essa tecnologia oferece um cenário de inovação, 
integração e facilidade de comunicação. O impacto do desenvolvimento Web 
na sociedade é muito grande e definitivo, visto que as relações entre pessoas, 
clientes-empresas e empresas-empresas foram modificadas de uma forma 
nunca pensada. Hoje, mais do que nunca, estamos separados, mas juntos, 
abertos para novas e interessantes possibilidades.
Fundamentos da programação para web 9
1
Fundamentos da 
programação para web
Os sistemas de informação evoluíram de sistemas desktop executa-
dos localmente para sistemas executados pela web. A arquitetura de um 
sistema para a web é baseada no modelo cliente-servidor (client-server) 
e requisição-resposta (request-response), e no desenvolvimento de um 
software para a web é necessário fazer dois sistemas: o aplicativo back-
-end, que é executado em um servidor, e o aplicativo front-end, que é 
executado em um navegador ou em um dispositivo móvel.
Tendo isso em vista, este capítulo apresenta os primeiros conceitos 
do desenvolvimento de software para web, que serão implementados 
com a linguagem de programação Java e com a plataforma Java EE. 
O Eclipse será utilizado como ambiente de desenvolvimento e iremos 
criar um Dynamic Web Project para implementar um aplicativo web, 
o qual depende de diversos recursos que devem ser fornecidos ao 
projeto. Assim, é necessário resolver as dependências do projeto for-
necendo as APIs. O framework EJB será utilizado para o desenvolvi-
mento do back-end do sistema e o framework JSF será utilizado para o 
desenvolvimento do front-end. Por fim, o Tomcat será utilizado como 
servidor para publicar e testar o sistema, levando em conta que, em um 
aplicativo web, é necessário realizar configurações no projeto para que 
o servidor possa saber como executá-lo.
1.1 Criação da estrutura de um sistema web
Vídeo Um aplicativo executado pela web tem arquitetura baseada no modelo 
cliente-servidor, no qual o usuário do sistema, utilizando um navegador, faz uma 
requisição que é enviada para o servidor. O servidor, por sua vez, processa a requi-
sição e devolve uma resposta para o usuário (DEITEL, P.; DEITEL, H., 2017). A comuni-
cação entre o cliente e o servidor é feita pela web (Figura 1).
10 Desenvolvimento de Software para Web
Figura 1
Sistema cliente-servidor
requisição resposta
ServidorClienteWeb
Fonte: Elaborada pelo autor.
No desenvolvimento web temos que elaborar dois programas: um que é exe-
cutado no servidor, denominado back-end da aplicação, e outro que é executado 
no navegador, denominado front-end da aplicação. Ambos os programas serão de-
senvolvidos com a linguagem de programação Java 1 e com a plataforma Java EE 2 
(Java Enterprise Edition, Edição Corporativa do Java, em português), que possui as 
ferramentas necessárias para o desenvolvimento web.
O framework EJB (Enterprise Java Bean, Componente Corporativo do Java, em 
português) será utilizado para o desenvolvimento do back-end, e o framework 
JSF (JavaServer Faces, tecnologia padrão do Java baseada em componentes e 
orientada a eventos) será utilizado para o desenvolvimento do front-end. Ambos os 
frameworks fazem parte da plataforma Java EE.
O Eclipse 3 será utilizado como ambiente de desenvolvimento e foi configurado 
para executar a versão 14.0.1 do JDK. O servidor Tomcat 4 será utilizado para publi-
car e executar os aplicativos desenvolvidos e será executado localmente.
Para a instalação do Java, do Java EE, do Eclipse e do Tomcat, consulte o Apêndi-
ce B (Configuração do ambiente de desenvolvimento).
1.1.1 O ambiente de desenvolvimento Eclipse
O Eclipse utiliza a estratégia de implementar diferentes funcionalidades de acor-
do com o tipo de desenvolvimento que se queira fazer. Nesse ambiente, uma janela 
é chamada de view. Um conjunto de views, que implementam uma determinada 
funcionalidade, é chamado perspectiva, a qual é composta das seguintes views: 
Text Editor, Task List, Outline e uma view que permite ao usuário interagir 
com o sistema operacional e que mostra a aba Console, entre outras opções.
A perspectiva Java é utilizada para o desenvolvimento de um programa Java no 
modo console e mostra a view Package Explorer.
Java SE – Oracle Corporation 
disponível em: https://www.
oracle.com/java/. Acesso em: 22 
jul. 2020.
1
Java EE – Oracle Corporation 
disponível em: https://www.
oracle.com/java/technologies/
java-ee-glance.html. Acesso em: 
22 jul. 2020.
2
Eclipse Foundation disponível em: 
https://www.eclipse.org/. Acesso 
em: 22 jul. 2020.
3
Apache Software Foundation dis-
ponível em: https://www.apache.
org/. Acesso em: 22 jul. 2020.
4
https://www.oracle.com/java/
https://www.oracle.com/java/
https://www.oracle.com/java/technologies/java-ee-glance.html
https://www.oracle.com/java/technologies/java-ee-glance.html
https://www.oracle.com/java/technologies/java-ee-glance.html
https://www.eclipse.org/
https://www.apache.org/
https://www.apache.org/
Fundamentos da programação para web 11
A perspectiva Java EE é utilizada para o desenvolvimento de uma aplicação Java 
Web e mostra a view Project Explorer.
A perspectiva Debug é utilizada para testar e corrigir erros de lógica de progra-
mação e mostra as views: Debug, Text Editor e uma view que permite ao usuário 
interagir com o programa e que mostra as tags Variables e Breakpoints. Para 
criar ou remover um breakpoint, na linha que contém a instrução, dê um clique du-
plo na margem esquerda do editor de texto. Para executar uma instrução, acesse 
Run→Step Over ou clique em F6. Para executar uma função, acesse Run→Strep 
Into ou clique F5.
As views de uma perspectiva podem ser alteradas. Para tanto, no menu prin-
cipal, acesse a opção Window e selecione Show View. Para voltar a configuração 
inicial da perspectiva, selecione Window→Perspective→Reset Perspective. As 
opções do menu principal mudam de acordo com a perspectiva selecionada.
Para o desenvolvimento de software para web, o Eclipse utiliza a perspectiva 
Java EE (Figura 2).
Figura 2
Ambiente de desenvolvimento Eclipse
Ec
lip
se
O ambiente de desenvolvimento Eclipse permite diversas configurações, o que 
o torna um IDE bastante versátil e profissional.
1.1.2 Integração do Tomcat no Eclipse
O servidor Tomcat pode ser integrado no Eclipse, permitindo que o servidor seja 
executado dentro do Eclipse. Para isso, na aba Servers, clique no link No servers 
are avaliable. Click this link to create a new server (Figura 2). 
Alternativamente, selecione File→New→Other e clique na opção Server→Server. 
O assistente Define a New Server será exibido (Figura 3).
12 Desenvolvimento de Software para Web
Figura 3
Assistente Define a New Server
Ec
lip
se
Na lista Select the server type, selecione a opção Apache→Tomcat v9.0 
Server. O campo Server’s host name informa o endereço do servidor: localhost. 
O campo Server name informa o nome do servidor: Tomcat v9.0 Server at 
localhost. Clique em Next. O assistente Tomcat Server será exibido (Figura 4).
Figura 4
Assistente Tomcat Server
Ec
lip
se
Fundamentos da programação para web 13
Clique no botão Browse para localizar a pasta de instalação do Tomcat. No cam-
po JRE, selecione a opção jdk-14.0.1 e clique em Finish. O servidor Tomcat é 
exibido na aba Servers (Figura 5). Na view Project Explorer podemos ver que 
foi criada a pasta Servers, que contém os arquivos de configuração do servidor 
Tomcat. Também é possível integrar vários servidores no Eclipse ao mesmo tempo.
Figura 5
Tomcat integrado ao Eclipse
Ec
lip
se
O Tomcat será utilizado como um servidor local, ou seja, o programa que está sendo 
desenvolvido e o servidor que irá executar o programa estão no mesmo computador.
A comunicação entre o programa e o Tomcat é feita pela web. O endereço de 
um servidor local é o localhost e o seu IP é 127.0.0.1. Para receber requisições, 
o Tomcat foi configurado para utilizar a porta 8090, assim é possível evitar um 
conflito de endereço HTTP com outros aplicativos que possam estar sendo execu-
tados no computador. Na aba Servers, dê um clique duplo no servidor Tomcat. No 
editor de texto é exibido o arquivo de configuração do Tomcat. Verifique, na opção 
Ports, o endereço do campo HPPT/1.1 configurado para o número 8090.
1.2 Criação de um Dynamic Web Project 
Vídeo No Eclipse, o desenvolvimento de um projeto web é implementado com um 
Dynamic Web Project, visto que ele tem uma estrutura de pastas adequada para 
uma aplicação web. Para conhecer e aplicar os conceitos de programação web, va-
mos criar um Dynamic Web Project denominado MensagemWeb. O aplicativo exibe 
uma página em navegador que mostra a mensagem “Seja Bem-Vindo!” e mos-
tra a data e o horário, obtidos do sistema operacional.
Para criar um Dynamic Web Project, selecione File→New→Dynamic Web 
Project. Então, o assistente New Dynamic Web Project é exibido (Figura 6).
14 Desenvolvimento de Software para Web
Figura 6
Assistente New Dynamic Web Project
Ec
lip
se
No campo Project name, informe o nome do pro-
jeto: MensagemWeb. No campo Project location, 
marque a opção Use default location que apon-
ta para a pasta do workspace. No campo Target 
runtime, selecione a opção Apache Tomcat v9.0. 
No campo Dynamic web module version, selecio-
ne a opção 4.0. No campo Configuration, selecione 
a opção Default Configuration for Apache 
tomcat v9.0. Clique em Finish. O Eclipse cria o 
projeto MensagemWeb que é mostrado no Project 
Explorer. O projeto tem uma estrutura de pastas 
adequadas para o desenvolvimento web e, neste mo-
mento, as pastas de interesse são: Java Resources, 
que é utilizada para o desenvolvimento do back-end; 
e WebContent, que é utilizada para o desenvolvimen-
to do front-end (Figura 7).
Ec
lip
se
Figura 7
Estrutura de um Dynamic Web Project
Fundamentos da programação para web 15
Figura 8
Estrutura de um Dynamic Web Project
Ec
lip
se
Para fazer o desenvolvimento, é necessário fazer as configurações iniciais do pro-
jeto. Selecione o projeto no Project Explore e clique com o botão direito. Selecio-
ne Properties. O assistente Properties for MensagemWeb é exibido (Figura 8).
Figura 9
Assistente Properties for MensagemWeb
Ec
lip
se
16 Desenvolvimento de Software para Web
Selecione as opções:
 • CDI (Contexts and Dependency Injection: 2.0;
 • Dynamic Web Module: 4.0;
 • Java: 1.8;
 • JavaScript: 1.0;
 • JavaServer Faces: 2.3;• na aba Runtimes, selecione: Apache Tomcat v9.0.
Selecionando a opção CDI, o link Further configuration available é exibi-
do e são solicitadas configurações adicionais para o CDI. Clique no link. O assistente 
Contexts and Dependency Injection (CDI) Facet é exibido. Selecione a 
opção Generate Beans.xml. Clique em OK e, no assistente Properties for 
MensagemWeb, clique em Apply.
Selecionando a opção JavaServer Faces, o link Further configuration 
available é exibido e são solicitadas configurações adicionais para o JSF. Clique 
no link. O assistente JSF Capabilities é exibido (Figura 9).
Figura 10
Assistente JSF Capabilities
Ec
lip
se
O conceito de injeção de 
dependência é um tema 
bastante importante na 
programação web e é 
um assunto que deve ser 
melhor entendido. Esse 
recurso tem vantagens 
para o desenvolvimento, 
automatizando operações 
para o usuário do sistema. 
No vídeo O que é Injeção de 
Dependências e como fun-
ciona no Spring?, publicado 
pelo canal AlgaWorks, é 
feita uma introdução sobre 
a injeção de dependência CDI.
Disponível em: https://www.youtube.
com/watch?v=GaOxliPuQtA. Acesso 
em: 7 ago. 2020.
Vídeo
https://www.youtube.com/watch?v=GaOxliPuQtA
https://www.youtube.com/watch?v=GaOxliPuQtA
Fundamentos da programação para web 17
Faça as seguintes configurações:
 • no campo JSF Implementation Library e em Type selecione a opção 
Disable Library Configuration;
 • no campo Configure JSF servlet in deployment descriptor selecio-
ne as seguintes opções:
 • JSF Configuration File: /WEB-INF/faces-config.xml;
 • JSF Servlet Name: Faces Servlet;
 • JSF Servlet Class Name:
javax.faces.webapp.FacesServlet
 • URL Mapping Patterns: selecione a opção /faces/*, clique em Remove 
e, em seguida, clique em Add. O assistente Specify URL Pattern é 
exibido. Digite o padrão *.jsf (Figura 10).
Ec
lip
se
Figura 11
Assistente Specify URL Pattern
Clique em OK e, no assistente JSF Capabilities 
(Figura 9), clique em Finish. Retornando para o assis-
tente Properties for WelcomeWeb, clique em 
Apply e, para completar o processo de configurações 
iniciais do projeto, clique em Apply and Close (Figu-
ra 8).
A estrutura da pasta Java Resources tem duas 
pastas: src e Libraries. Os arquivos com extensão 
.java são criados na pasta src. A pasta Libraries 
é virtual e permite visualizar as bibliotecas disponíveis 
para o projeto, como a pasta Apache Tomcat v9.0, 
que mostra as bibliotecas fornecidas pelo servidor, e a 
pasta JRE System Library, que mostra as bibliote-
cas fornecidas pelo JDK do Java (Figura 11).
A estrutura da pasta WebContent tem duas pastas: 
META-INF e WEB-INF (Figura 12).
Figura 12
Estrutura da pasta Java 
Resources
Ec
lip
se
18 Desenvolvimento de Software para Web
Figura 13
Estrutura da pasta WebContent
Ec
lip
se
Os arquivos com extensão .html, .xhtml, .jsp, por exemplo, são criados di-
retamente na pasta WebContent. Podemos criar outras pastas dentro da pasta 
WebContent para organizar o desenvolvimento.
Os arquivos de configuração que serão utilizados pelo servidor são colocados 
na pasta META-INF, como o arquivo MANIFEST.MF. Entretanto, os arquivos da pas-
ta META-INF não são acessíveis para o usuário do sistema.
A pasta WEB-INF tem a pasta lib e os arquivos de configuração da aplicação 
(beans.xml, faces-config.xml e web.xml). Vale ressaltar que, de acordo com a 
configuração que é feita no projeto, podemos ter outros arquivos de configuração. 
A pasta lib contém os arquivos de biblioteca fornecidos pelo programa, e os ar-
quivos com extensão .jar, copiados na pasta lib, são mostrados na pasta Java 
Resources/Libraries.
1.2.1 Arquivos de configuração do aplicativo
Uma aplicação que é executada em um servidor precisa de arquivos de configu-
ração para informar ao servidor o que e como deve ser feito. O arquivo web.xml é 
o principal arquivo de configuração da aplicação. Quando o servidor executa a apli-
cação, as primeiras ações do servidor são: localizar o arquivo web.xml e executar 
as configurações que estão no arquivo.
Fundamentos da programação para web 19
O arquivo web.xml tem as configurações do JSF (Figura 13).
Figura 14
Arquivo web.xml
1 <?xml version=”1.0” encoding=”UTF-8”?>
2
3 <web-app xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
4 xmlns=”http://xmlns.jcp.org/xml/ns/javaee”
5 xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/javaee
6 http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd”
7 id=”WebApp_ID” version=”3.1”>
8
9 <!-- Nome da aplicação -->
10
11 <display-name>MensageWeb</display-name>
12
13 <!-- Arquivo de inicialização da aplicação -->
14
15 <welcome-file-list>
16 <welcome-file>index.jsp</welcome-file>
17 </welcome-file-list>
18 
19 <!-- Configurações do JSF -->
20
21 <servlet>
22 <servlet-name>Faces Servlet</servlet-name>
23 <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
24 <load-on-startup>1</load-on-startup>
25 </servlet>
26
27 <servlet-mapping>
28 <servlet-name>Faces Servlet</servlet-name>
29 <url-pattern>*.jsf</url-pattern>
30 </servlet-mapping>
31
32 </web-app>
Fonte: Elaborada pelo autor.
O elemento <?xml?> cria o cabeçalho do documento; o elemento <web-app> é 
a tag raiz do documento; o elemento <display-name> cria um nome para a aplica-
ção, que será utilizado pelo servidor para reconhecer toda a aplicação; o elemento 
<welcome-file-list> cria uma lista de arquivos que podem iniciar a aplicação; e 
o elemento <welcome-file> inclui o nome de um arquivo para iniciar a aplicação, 
não existindo mais o método main().
O elemento <servlet> configura a API do JSF; o elemento <servlet-name> 
configura um nome para a API do JSF e esse nome será utilizado pelo servidor 
para referenciar a API do JSF; o elemento <servlet-class> informa o nome da 
classe que implementa a API do JSF; e o elemento <load-on-startup> determina 
a prioridade para carregar a API, sendo que a prioridade 1 significa que a API será 
executada imediatamente, logo após a aplicação ser iniciada no servidor.
 
20 Desenvolvimento de Software para Web
O elemento <servlet-mapping> realiza o mapeamento da API do JSF para o lado 
do cliente. Isso significa que as funcionalidades do JSF que são implementadas no lado 
do servidor podem ser acessadas no lado do cliente. O elemento <servlet-name> 
informa o nome da API que se quer fazer o mapeamento. O elemento <url-pat-
tern> determina o padrão de mapeamento da API. No aplicativo MensagemWeb, foi 
criado o padrão *.jsf, que disponibiliza as funcionalidades do JSF para o lado do 
cliente e estabelece que qualquer arquivo configurado para executar comandos do 
JSF será tratado como um documento JSF, mesmo que, fisicamente, o arquivo tenha 
outra extensão. No momento de execução, a aplicação transforma o documento em 
um documento com a extensão .jsf.
O arquivo beans.xml é o arquivo de configuração do EJB e o arquivo 
faces-config.xml é o arquivo de configuração do JSF. Até então, esses arquivos não 
têm configurações para a aplicação.
1.2.2 Execução do aplicativo
Para executar o projeto MensageWeb no servidor, criamos o arquivo index.jsp 
na pasta WebContent. Esse arquivo consta na lista de arquivos que podem inicializar 
a aplicação, configurado no arquivo web.xml (Figura 13). O arquivo JSP é um docu-
mento HTML que permite executar comandos Java, os quais são inseridos no docu-
mento com a tag denominada scriptlet <% %>.
No arquivo index.jsp é informado o título da página Mensagem Web e criamos 
uma mensagem Seja Bem-Vindo! com a tag <h1> (Figura 14).
Figura 15
Página index.jsp
1 <%@ page language=”java” contentType=”text/html; charset=ISO-8859-1”
2 pageEncoding=”ISO-8859-1”%>
3 <!DOCTYPE html>
4 <html>
5 <head>
6 <meta charset=”ISO-8859-1”>
7 <title>Mensagem Web</title>
8 </head>
9 <body>
10 <h1>Seja Bem-Vindo!</h1>
11 </body>
12 </html>
Fonte: Elaborada pelo autor.
Para executar o aplicativo, no Project Explorer, selecione o projeto e clique 
com o botão direito. Selecione Run AS→Run On Server. A saída do programa émos-
trada no Web Browser do Eclipse (Figura 15).
Fundamentos da programação para web 21
Figura 16
Saída do programa MensagemWeb
Ec
lip
se
No Web Browser a página é exibida sem erros. Verifique o título da página e a 
mensagem exibida.
Weld é a implementação de 
referência do CDI (contextos 
e injeção de dependência) 
para a plataforma Java 
EE. É um padrão JCP (Java 
Community Process) para 
injeção de dependência e 
gerenciamento do ciclo de 
vida contextual. O Weld é in-
tegrado a muitos servidores 
de aplicativos Java EE, como 
WildFly, JBoss, GlassFish, 
entre outros. A integração 
também pode ser usada 
em containers servlet web, 
como o Tomcat. Devido a 
sua importância, sugerimos 
a leitura da documentação 
oficial da implementação 
Weld, especialmente o 
Capítulo 3, que apresenta 
um exemplo de aplicação 
web JSF.
Disponível em: https://docs.jboss.org/
weld/reference/1.1.5.Final/pt-BR/
html/example.html. Acesso em: 7 
ago. 2020.
Leitura
1.3 Gerenciamento das 
dependências do projetoVídeo
Para desenvolver o projeto, é necessário fornecer a API do JSF e 
do CDI, tendo em vista que o JSF implementa a interface gráfica do apli-
cativo e o CDI é um framework que integra a interface gráfica do 
aplicativo com o back-end do sistema.
Para obter a API do JSF, faça o download do arquivo javax.fa-
ces-2.3.0.jar no site Java.net (Disponível em: https://maven.java.
net/content/repositories/releases/org/glassfish/javax.faces/2.3.0/. 
Acesso em: 5 ago. 2020).
Para obter a API do CDI, faça o download do arquivo weld-ser-
vlet.jar no site SeamFramework.org (Disponível em: http://seam 
framework.org/Weld/WeldDistributionDownloads.html. Acesso em: 
5 ago. 2020).
Os arquivos .jar são copiados na pasta WebContent\WEB-INF\
lib. Na pasta Java Resources\Libraries\Web App Libraries 
podemos verificar as APIs adicionadas ao projeto (Figura 16).
https://docs.jboss.org/weld/reference/1.1.5.Final/pt-BR/html/example.html
https://docs.jboss.org/weld/reference/1.1.5.Final/pt-BR/html/example.html
https://docs.jboss.org/weld/reference/1.1.5.Final/pt-BR/html/example.html
https://maven.java.net/content/repositories/releases/org/glassfish/javax.faces/2.3.0/
https://maven.java.net/content/repositories/releases/org/glassfish/javax.faces/2.3.0/
http://seamframework.org/Weld/WeldDistributionDownloads.html
http://seamframework.org/Weld/WeldDistributionDownloads.html
22 Desenvolvimento de Software para Web
Figura 17
Gerenciamento das dependências do projeto
Ec
lip
se
Além de adicionar as APIs no projeto, é necessário acrescentar configurações 
no arquivo web.xml: (a) para que o aplicativo obtenha a data e o horário do sis-
tema operacional; (b) para determinar como campos sem valores em um formu-
lário serão interpretados pelo servidor; e (c) para configurar o aplicativo para que 
possa interceptar eventos gerados pelo CDI. A data e o horário são obtidos do sis-
tema operacional, configurando o parâmetro javax.faces.DATETIMECONVER-
TER_DEFAULT_TIMEZONE_IS_SYSTEM_TIMEZONE. como o valor true (Figura 17, 
linhas 34-39). Os campos sem valores em um formulário devem ser interpretados 
com o valor nulo, configurando o parâmetro javax.faces.INTERPRET_EMPTY_
STRING_SUBMITTED_VALUES_AS_NULL como o valor true (Figura 17, linhas 41-
46). O aplicativo intercepta eventos gerados pelo CDI adicionando o listener do CDI 
org.jboss.weld.environment.servlet.Listener (Figura 17, linhas 50-52).
Figura 18
Configurações adicionais do arquivo web.xml
32 <!-- Context parameters configuration -->
33
34 <context-param>
35 <param-name>
36 javax.faces.DATETIMECONVERTER_DEFAULT_TIMEZONE_IS_SYSTEM_TIMEZONE
(Continua)
Fundamentos da programação para web 23
37 </param-name>
38 <param-value>true</param-value>
39 </context-param>
40
41 <context-param>
42 <param-name>
43 javax.faces.INTERPRET_EMPTY_STRING_SUBMITTED_VALUES_AS_NULL
44 </param-name>
45 <param-value>true</param-value>
46 </context-param>
47
48 <!-- Listener of the JBoss Weld (CDI) -->
49
50 <listener>
51 <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>
52 </listener>
Fonte: Elaborada pelo autor.
O gerenciamento das dependências do projeto é fundamental para o correto 
funcionamento do aplicativo no servidor, que inclui as seguintes etapas: (a) deter-
minação das propriedades do aplicativo; (b) configurações feitas no arquivo web.
xml; e (c) fornecimento das APIs da aplicação.
@
1.4 Arquitetura do sistema 
Vídeo A arquitetura de um sistema determina a maneira como um projeto será desen-
volvido e, portanto, tem um impacto muito grande no desenvolvimento do projeto. 
Duas decisões serão tomadas para o desenvolvimento dos nossos exemplos: (a) 
o sistema será desenvolvido com o padrão MVC; e (b) as classes do sistema serão 
escritas com o padrão POJO.
1.4.1 Padrão MVC
O padrão MVC (Model, View, Controller) gerencia a complexidade do sistema sepa-
rando as responsabilidades do sistema em camadas (GAMMA et al., 2007) (Figura 18).
A Camada View é responsável pela implementação da interface do sistema com 
o usuário, também denominada Camada de Apresentação. A Camada Controller é 
responsável pelo controle e gerenciamento do fluxo de execução do sistema. A 
Camada Model é responsável pela implementação da regra de negócio do sistema.
Figura 19
Padrão MVC
Camada View Camada ModelCamada Controller
Fonte: Elaborada pelo autor.
24 Desenvolvimento de Software para Web
O padrão MVC determina também como as camadas devem interagir entre si: 
a Camada View interage com a Camada Controller e não tem acesso à Camada 
Model; a Camada Controller interage com a Camada View e com a Camada Model; 
e a Camada Model interage com a Camada Controller e não tem acesso à Camada 
View (LUCKOW; MELO, 2015).
1.4.2 Padrão POJO
As classes do sistema são criadas com o padrão POJO (Plain Old Java Objects, ou 
Objetos Comuns do Java, em português), definido pela Java Community Process 
(JCP), que é uma entidade cujo objetivo é fazer a especificação da linguagem Java 
de acordo com o interesse do mercado e da própria linguagem Java (LUCKOW; 
MELO, 2015).
O padrão POJO especifica uma norma para declarar: o nome da classe, o 
nome dos atributos da classe e o nome dos métodos de acesso aos atributos da 
classe, denominados métodos getters e setters. A classe deve declarar a função 
construtora, mesmo que a construtora esteja vazia.
O nome da classe começa com a primeira letra maiúscula. O nome dos atributos 
e dos métodos começam com a primeira letra minúscula. Para o nome da classe, 
dos atributos e dos métodos, se houver mais palavras, as palavras começam com a 
primeira letra maiúscula. Todas as palavras são escritas por extenso e sem nenhum 
tipo de caractere de separação, nem mesmo o caractere sublinhado (underscore). 
Os métodos de acesso aos atributos da classe são chamados de métodos getters e 
setters. O método getter começa com a palavra get e o método setter começa com 
a palavra set, depois vem o nome do atributo (Figura 19).
Figura 20
Exemplo do padrão POJO
1 package com.cadastro.vo.pessoa;
2
3 import java.util.Date;
4
5 public class Pessoa {
6
7 private String nome;
8 private Date dataNascimento;
9
10 public Pessoa() {
11
12 }
13
14 public String getNome() {
15 return nome;
16 }
17
18 public void setNome(String nome) {
19 this.nome = nome;
20 }
(Continua)
Fundamentos da programação para web 25
21
22 public Date getDataNascimento() {
23 return dataNascimento;
24 }
25
26 public void setDataNascimento(Date dataNascimento) {
27 this.dataNascimento = dataNascimento;
28 }
29
30 public int calcularIdade() {
31
32 Date dataAtual = new Date();
33 int idade = dataAtual.getYear() - dataNascimento.getYear();
34
35 if (dataAtual.getMonth() < dataNascimento.getMonth() ) {
36 idade--;
37 } else {
38 if (dataAtual.getMonth() == dataNascimento.getMonth()) {
39 if (dataAtual.getDay() < dataNascimento.getDay()) {
40 idade--;
41 }
42 }
43 }
44
45 return idade;46 }
47 }
Fonte: Elaborada pelo autor.
O padrão POJO cria a propriedade de acessar os atributos de uma classe em 
uma página HTML por meio do nome dos atributos, em lugar de usar o nome dos 
métodos de acesso getters e setters. Na verdade, essa propriedade acessa os mé-
todos getters e setters utilizando o nome do atributo. Essa propriedade só pode ser 
aplicada se a classe implementar o padrão POJO.
1.5 Criação da camada de controller 
Vídeo A integração entre a Camada View e a Camada Controller é feita por meio do 
framework CDI, que cria uma classe denominada backing bean. A classe é anotada 
com a instrução @Name do pacote javax.inject. A anotação @Name injeta a classe 
no servidor, passando a gerenciar objetos dessa classe. A anotação @Name também 
aceita um atributo para especificar o nome do objeto criado pelo servidor. A classe 
backing bean é escrita com o padrão POJO.
Na Camada View, o JSF tem acesso ao objeto injetado no servidor. Com esse 
mecanismo, estamos disponibilizando as funcionalidades da classe backing bean 
para as páginas JSF.
26 Desenvolvimento de Software para Web
Para o backing bean, é necessário informar o escopo de vida do objeto inje-
tado utilizando as anotações do pacote javax.enterprise.context. O escopo 
de vida, de modo geral, tem duração: durante a existência da requisição feita pelo 
usuário, a existência da seção do usuário, a existência da aplicação no servidor, 
entre outras possibilidades (Quadro 1).
Quadro 1
Escopo de vida de um objeto injetado no servidor
Anotação Momento de instancialização Momento de destruição
@Application
No momento em que a aplicação é 
inicializada.
No momento em que a aplicação é 
finalizada.
@SessionScoped
No momento em que o usuário ini-
cia uma seção.
No momento em que a seção do 
usuário é finalizada.
@RequestScoped
No momento em que o usuário ini-
cia uma requisição.
No momento em que a requisição 
do usuário é finalizada.
Fonte: Elaborado pelo autor.
O projeto MensagemWeb cria o backing bean MensagemBean no pacote com.
mensagem.web na pasta Java Resource/src anotado com as instruções 
@Named(“mensagemBean”) e @RequestScoped. O backing bean deve fornecer 
uma mensagem, a data e o horário do sistema (Figura 20).
Figura 21
Classe MensagemBean
1 package com.mensagem.web;
2
3 import java.io.Serializable;
4 import java.util.Date;
5 import java.util.Objects;
6 import javax.annotation.PostConstruct;
7 import javax.enterprise.context.RequestScoped;
8 import javax.inject.Named;
9
10 @Named(“mensagemBean”)
11 @RequestScoped
12 public class MensagemBean implements Serializable {
13
14 private static final long serialVersionUID = -630103058135353597L;
15
16 private Date data;
17 private String saudacao;
18
19 public MensagemBean() {
20 this.data = new Date();
21 this.saudacao = “Seja Bem-Vindo!”;
22 }
23
(Continua)
Fundamentos da programação para web 27
24 @PostConstruct
25 public void init() {
26 System.out.println(
27 “\nBacking Bean MensagemBean executado!”);
28 }
29
30 public Date getData() {
31 return data;
32 }
33
34 public void setData(Date data) {
35 this.data = data;
36 }
37
38 public String saudacao() {
39 return this.saudacao;
40 }
41 }
Fonte: Elaborada pelo autor.
A classe declara os atributos data da classe Date do pacote java.util e o atri-
buto saudacao da classe String do pacote java.lang. Também declara a função 
construtora que instancializa o objeto data e atribui a string “Seja Bem-Vindo!” 
para o objeto saudacao.
O método init() está anotado com a instrução @PostConstruct, que faz 
com que o método seja automaticamente executado logo após a função construto-
ra ter sido executada. O método imprime uma mensagem informado que o backing 
bean foi executado.
A classe gera os métodos getters e setters somente para o atributo data e de-
clara o método saudacao(), que retorna a mensagem.
A classe implementa a interface Serializable do pacote java.io e gera o 
atributo serialVersionUDI, que é o identificador da classe. Esse atributo é obri-
gatório para que o servidor possa identificar a classe de forma única. Para gerar o 
serialVersionUDI, clique com o botão direito no ícone em amarelo na margem 
esquerda do editor de texto (na linha que declara a classe) e selecione a opção 
Generate serial version ID (Figura 21).
28 Desenvolvimento de Software para Web
Figura 22
Gerando o atributo serialVersionUID
Ec
lip
se
A classe backing bean também deve gerar o método hashCode(), que gera um 
identificador único para cada objeto da classe, e o método equals(), que realiza a 
comparação entre dois objetos. Esses métodos não são mostrados na Figura 20. En-
tão, para gerá-los, clique com o botão direito na classe e selecione Source→Generate 
hashCode() and equals().
1.6 Desenvolvimento da camada de apresentação
Vídeo Para executar o aplicativo, vamos criar uma página para mostrar a mensa-
gem, a data e o horário do sistema. Inicialmente, vamos criar uma pasta cha-
mada publico para organizar o desenvolvimento. Na sequência, vamos criar 
o documento homepage.xhtml.
Para criar a pasta, selecione a pasta WebContent, clique com o botão direito e 
selecione New→Folder e informe o nome da pasta. Para criar o arquivo, selecio-
ne a pasta, clique com o botão direito e selecione New→HTML File. O assistente 
New HTML File é exibido. No campo File name, informe o nome do arqui-
vo homepage e acrescente a letra x na extensão html, transformando a exten-
são em xhtml. Clique em Next. O assistente Select HTML Template é exibido. 
Selecione o template New XHTML File (1.0 Transitional) – xhtml 1.0 
transitional. Clique em Finish. Esse modelo cria um documento XHTML com 
um cabeçalho apropriado para o propósito do programa (Figura 22).
Fundamentos da programação para web 29
Figura 23
Assistente Select HTML Template
Ec
lip
se
Para que o documento homepage.xhtml possa executar comandos do JSF é 
necessário fazer as seguintes configurações:
a. na linha 5, adicione na tag <html> o atributo xmlns:h=http://xmlns.jcp.
org/jsf/html. Esse atributo permite que o documento utilize as tags do JSF 
que geram comandos HTML. As tags devem ser prefixadas com a letra h;
b. na linha 6, adicione na tag <html> o atributo xmlns:f=http://xmlns.
jcp.org/jsf/core. Esse atributo permite que o documento utilize as tags 
do JSF que geram comandos de controle e configuração. As tags devem ser 
prefixadas com a letra f;
c. as tags <head> e <body> devem ser, obrigatoriamente, prefixadas com a 
letra h: <h:head> e </h:head>, <h:body> e </h:body>.
Essas configurações transformam o documento XHTML em um documento JSF 
e o servidor irá tratar o arquivo como JSF, mesmo que, fisicamente, a extensão do 
documento seja XHTML (Figura 23).
30 Desenvolvimento de Software para Web
Figura 24
Página homepage.xhtml
1 <?xml version=”1.0” encoding=”ISO-8859-1” ?>
2 <!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”
3 http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd>
4 <html xmlns=”http://www.w3.org/1999/xhtml”
5 xmlns:h=”http://xmlns.jcp.org/jsf/html”
6 xmlns:f=”http://xmlns.jcp.org/jsf/core”>
7 <h:head>
8 <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8” />
9 <title>Mensagem Web</title>
10 </h:head>
11 <h:body>
12
13 <hr />
14
15 <h:outputLabel value=”Homepage”
16 style=”font-size: xx-large; color: blue;” />
17 
18 <hr />
19
20 <h:outputText value=”#{mensagemBean.saudacao()}”
21 style=”font-size: xx-large; color: green;” />
22
23 <hr />
24
25 <h:outputLabel value=”Data: “ style=”font-size: xx-large; color: red;” />
26 <h:outputText value=”#{mensagemBean.data}”
27 style=”font-size: xx-large; color: red;”>
28 <f:convertDateTime pattern=”EEEE, dd MMMM yyyy HH:mm:ss z” />
29 </h:outputText>
30
31 <hr />
32
33 </h:body>
34 </html>
Fonte: Elaborada pelo autor.
As tags do JSF estão organizadas em dois grupos: (a) grupo de tags que geram 
comandos HTML e (b) grupo de tags do núcleo do JSF (JSF core) que geram coman-
dos decontrole, comandos de conversão de tipo de dados, comandos de passagem 
de parâmetros, entre outros tipos de comandos de formatação. Esses comandos 
do JSF core não geram comandos HTML.
O grupo de tags do JSF que geram comandos HTML é prefixado com a letra h 
e o grupo de tags do JSF que geram formatação é prefixado com a letra f. Nesse 
documento utilizamos as seguintes tags do JSF:
a. a tag <h:outputLabel>, que gera uma label cujo conteúdo é fornecido pelo 
atributo value. A formatação de estilo da tag é fornecida pelo atributo style;
Fundamentos da programação para web 31
b. a tag <h:outputText>, que gera um texto cujo conteúdo é fornecido 
pelo atributo value. A formatação de estilo da tag também é fornecida pelo 
atributo style;
c. a tag <f:convertDateTime>, que converte uma data de acordo com um 
padrão informado. O atributo pattern informa o padrão de formatação.
Para a codificação do documento homepage.xhtml, inicialmente, na linha 9, 
informamos o título da página Mensagem Web.
Nas linhas 15-16 é gerado uma label com a tag <h:outputLabel 
value=”Homepage”>.
Nas linhas 20-21 é gerado um texto com a tag <h:outputText value=”# 
{mensagemBean.saudacao()}”>. O valor do texto é obtido a partir do valor da ex-
pressão regular da Linguagem de Expressão (EL – Expression Language, em inglês).
Uma expressão regular da Linguagem de Expressão começa com o símbolo # 
e é delimitada por chaves { }. A expressão regular devolve o valor do seu con-
teúdo. No aplicativo MensagemWeb, o conteúdo da expressão regular é uma string 
obtida da chamada do método mensagemBean.saudacao(). Na expressão regu-
lar, o documento JSF se comunica com o objeto mensagemBean da classe backing 
bean MensagemBean. O valor da expressão é obtido pela chamada da função 
saudacao(), que fornece uma string.
Na linha 25 é gerado uma label com a tag <h:outputLabel value=”Data: “>.
Nas linhas 26-29 é gerado um texto com a tag <h:outputText value=”# 
{mensagemBean.data}”>, que mostra a data e o horário. A expressão regular da 
EL obtém a data do objeto mensagemBean da classe backing bean MensagemBean.
A página JSF acessa os métodos getters e setters do objeto pela propriedade 
que utiliza somente o nome do atributo da classe. Isso significa que o comando 
mensagemBean.getData() é substituído pela expressão mensagemBean.data 
e o comando mensagemBean.setData() também é substituído pela expressão 
mensagemBean.data.
A questão de determinar qual método está sendo utilizado é resolvida pelo con-
texto no qual a expressão regular está sendo usada. Em um contexto no qual um 
comando está exibindo um valor, a expressão regular #{mensagemBean.data} 
está, na verdade, utilizando o método mensagemBean.getData(), como mostra-
do no exemplo a seguir:
<h:outputText value=”#{mensagemBean.data}” />
Em um contexto no qual um comando está atribuindo um valor, a expressão 
regular #{mensagemBean.date} está, na verdade, utilizando o método 
mensagemBean.setDate(), como mostrado no exemplo a seguir:
<h:inputText value=”#{mensagemBean.date}” />
A propriedade de utilizar os métodos getters e setters utilizando o nome do atri-
buto simplifica a anotação e é intuitivo para o usuário. Essa propriedade só pode 
ser utilizada se a classe for escrita no padrão POJO.
32 Desenvolvimento de Software para Web
Para a tag <h:outputText value=”#{mensagemBean.data}”> exibir uma 
data, é necessário converter o valor da data para uma string, que será exibida na 
página. A tag <f:convertDateTime>, que é um comando do JSF Core, converte e 
formata uma data. O atributo pattern=”EEEE, MMMM dd, yyyy HH:mm:ss z” /> 
informa o padrão de formatação, em que:
 • EEEE mostra o dia da semana por extenso;
 • MMMM mostra o nome do mês por extenso;
 • dd mostra o dia do mês com dois dígitos;
 • yyyy mostra o ano com quatro dígitos;
 • HH mostra a hora com dois dígitos;
 • mm mostra o minuto com dois dígitos;
 • ss mostra o segundo com dois dígitos;
 • z mostra o fuso horário.
A codificação realizada no documento homepage.xhtml gera um documento 
JSF que mostra uma mensagem, a data e o horário. O aplicativo pode ser executado 
no Web Browser do Eclipse (Figura 24).
Figura 25
Execução do aplicativo no Web Browser do Eclipse
Ec
lip
se
Podemos também executar a aplicação em um navegador externo (Figura 25).
Fundamentos da programação para web 33
Figura 26
Execução do aplicativo em um navegador externo
Go
og
le
Conforme explicam Geary e Horstmann (2012), o JSF é um framework baseado 
em componentes, permitindo criar componentes novos. O JSF é um padrão de mer-
cado e empresas invertem no desenvolvimento de componentes, como a 
PrimeFaces, a RichFaces, a ICEFaces, entre outras.
JUnit disponível em: https://
junit.org/junit5/. Acesso em: 5 
ago. 2020.
1
1.7 Realização de teste unitário 
para as classes do sistemaVídeo
O desenvolvimento do sistema deve ser testado para garantir a 
sua funcionalidade. O desenvolvimento orientado a teste (test-driven 
development, em inglês) é um procedimento padrão para validar um 
sistema (LECHETA, 2015). O Eclipse implementa testes unitários por 
meio do framework JUnit 1 . Para o sistema desenvolvido, podemos 
testar a classe MensagemBean.
1.7.1 Pasta source folder
Para criar testes unitários no projeto, precisamos criar uma nova 
pasta de fontes (source folder). Selecione o projeto MensagemBean 
no Project Explorer e clique com o botão direito. Selecione Ne-
w→Source Folder. O assistente Source Folder é exibido. No 
campo Project name, verifique o nome do projeto. No campo 
Folder name, informe o nome da pasta src-test e clique em 
Finish (Figura 26).
https://junit.org/junit5/
https://junit.org/junit5/
34 Desenvolvimento de Software para Web
Figura 27
Assistente New Source Folder
Ec
lip
se
1.7.2 Classe TestMensagemBean
Para criar um teste unitário, selecione a pasta src-test. Clique com o botão 
direito e selecione New→Other. O assistente Select a Wizard é exibido. Na caixa 
de pesquisa, digite junit e, na lista de opções, selecione JUnit Test Case. Cli-
que em Next. O assistente New JUnit Test Case é exibido. No campo Package 
informe o nome do pacote com.mensagem.web.test e, no campo Name, informe 
o nome da classe TestMensagemBean. Clique em Finish (Figura 27).
Figura 28
Assistente New JUnit Test Case
Ec
lip
se
Fundamentos da programação para web 35
Na primeira vez que o projeto cria uma classe do JUnit, o Eclipse solicita adicio-
nar a API do JUnit 5 ao path do projeto. Clique em OK para confirmar (Figura 28).
Figura 29
Configuração do JUnit 5 Test Case
Ec
lip
se
Uma classe de teste do JUnit herda a classe TestCase do pacote junit.
framework. Um método que implementa um teste é anotado com a instrução 
@Test do pacote org.junit.jupiter.api (Figura 29).
Figura 30
Classe TestMensagemBean
1 package com.mensagem.web.test;
2
3 import org.junit.jupiter.api.Test;
4 import com.mensagem.web.MensagemBean;
5 import junit.framework.TestCase;
6
7 class TestMensagemBean extends TestCase {
8
9 @Test
10 void testMensagemBean() {
11
12 String saudacao = “Seja Bem-Vindo!”;
13
14 MensagemBean mensagemBean = new MensagemBean();
15
16 assertTrue(mensagemBean != null);
17
18 assertTrue(mensagemBean.getSaudacao() != null
19 && mensagemBean.getSaudacao().length() > 0);
20
21 assertTrue(mensagemBean.getData() != null);
22
23 assertEquals(saudacao, mensagemBean.getSaudacao());
24
25 }
26 }
Fonte: Elaborada pelo autor.
36 Desenvolvimento de Software para Web
O framework JUnit possui diversos recursos para implementação de testes uni-
tários. Na classe TestMensagemBean, utilizamos o método assertTrue(boolean 
condition) e o método assertEquals(String expected, String ac-
tual). Ambos os métodos são da classe TestCase do pacote junit.framework. 
O método assertTrue(boolean condition) verifica uma condição e o método 
assertEquals(String expected, String actual) compara um valor espe-
rado com um valor atual.
Para executar o teste, selecione a classe TestMensagemBean. Clique com obo-
tão direito e selecione Run As→JUnit Test. Na view console do JUnit podemos 
verificar o resultado do teste. A cor verde indica que o teste foi realizado com su-
cesso e não há mensagens de erros (Figura 30).
Figura 31
Execução do teste unitário
Ec
lip
se
Um teste não válido é mostrado em vermelho e apresenta mensagens de erros 
(Figura 31).
Figura 32
Resultado de um teste não-válido
Ec
lip
se
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework(TestCase.class%E2%98%83TestCase~assertEquals~Ljava.lang.String;~Ljava.lang.String;%E2%98%82java.lang.String
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework(TestCase.class%E2%98%83TestCase~assertEquals~Ljava.lang.String;~Ljava.lang.String;%E2%98%82java.lang.String
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework(TestCase.class%E2%98%83TestCase
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework(TestCase.class%E2%98%83TestCase~assertEquals~Ljava.lang.String;~Ljava.lang.String;%E2%98%82java.lang.String
file:///I:/EAD/03_Disciplinas/01_em_producao/desenvolvimento_de_software_para_web_id101726_lv59547/01_livro/04_edicao/06_editado/eclipse-javadoc:%E2%98%82=MensagemWeb/C:%5C/Users%5C/lbara%5C/.p2%5C/pool%5C/plugins%5C/org.junit_4.13.0.v20200204-1500.jar=/javadoc_location=/http:%5C/%5C/junit.org%5C/junit4%5C/javadoc%5C/latest%5C/=/%3Cjunit.framework(TestCase.class%E2%98%83TestCase~assertEquals~Ljava.lang.String;~Ljava.lang.String;%E2%98%82java.lang.String
Fundamentos da programação para web 37
Na view console do JUnit, clique na mensagem junit.framework.
ComparisonFailure: expected:<[Bom Dia Brasil]!> but was:<[Seja 
Bem-Vindo]!> para verificar o valor esperado e o valor atual (Figura 32).
Figura 33
Resultado de um teste de comparação
Ec
lip
se
A utilização de teste unitário permite avaliar a lógica do sistema por meio de 
testes automatizados, que criam classes para testar classes do sistema. Nas classes 
de teste, as funcionalidades das classes dos sistemas são verificadas por meio de 
testes de validação, nos quais uma determinada condição é verificada, e testes 
de comparação, em que é verificado o valor esperado de uma variável com o valor 
atual. Conforme Bezerra (2015), testes automatizados substituem os testes ma-
nuais do sistema, nos quais o desenvolvedor tem que executar o sistema, realizar a 
entrada de dados e verificar o resultado obtido.
CONSIDERAÇÕES FINAIS
O desenvolvimento para web criou um paradigma novo de programação e, atual-
mente, não podemos mais pensar no mundo sem o uso da internet. Nesse contexto, 
são envolvidos novos conceitos de programa e tecnologias que dão suporte para o 
desenvolvimento para a web. Assim, a primeira questão que surge ao desenvolver um 
software é como criar uma página em um navegador ou em um dispositivo móvel. 
A segunda, é como criar um programa que vai funcionar em um servidor.
No momento que o programa está sendo desenvolvido, podemos utilizar um 
servidor local para executar e testar o sistema, mas quando esse sistema for para 
a produção, temos que pensar em qual servidor ele será executado. Uma solução 
pode ser contratar uma empresa que ofereça o serviço de publicação de um site na 
web ou de um aplicativo na nuvem. De qualquer modo, é preciso questionar qual 
será a melhor forma e a opção mais viável e mais em conta.
Atualmente, existem diversas linguagens de programação que dão suporte à 
programação para web. Com isso, é comum questionamentos sobre qual lingua-
gem usar e por onde começar. As plataformas de desenvolvimento para web são 
ferramentas poderosas e oferecem suporte para o desenvolvimento para web. 
Entretanto, a linguagem de programação Java é uma ferramenta bem estabelecida 
e com uma maturidade de pelo menos 25 anos. Essa linguagem criou um paradig-
38 Desenvolvimento de Software para Web
ma de programação baseado em orientação a objetos, que é seguido extensiva-
mente por quase todas as linguagens de programação atuais.
O desenvolvimento web é um enorme desafio, entretanto, é extremamente 
instigante e encorajador. Os resultados obtidos são excelentes e as possibilidades 
de criar produtos novos são lucrativamente interessantes.
ATIVIDADES
1. Cadastro de pessoa. Escreva um Dynamic Web Project para cadastrar uma pessoa 
com os seguintes atributos: nome e data de nascimento (como exemplificado na 
figura a seguir). O programa deve fazer validação da entrada de dados.
O que acontece se o usuário não informar um nome? O que acontece se for digitada 
uma data inválida? Faça o teste unitário para a classe Pessoa.
Sugestão: para a entrada e saída da data utilize o padrão: pattern=”dd/MM/yyyy”.
Ec
lip
se
2. Calcular idade. Utilizando o exemplo de cadastro de pessoa, inclua no programa a 
funcionalidade de calcular a idade da pessoa.
Ec
lip
se
Fundamentos da programação para web 39
3. Reescreva o programa de cadastro de pessoa para permitir o cadastro de várias 
pessoas (conforme exemplificado na figura a seguir).
Sugestão: para mostrar a lista de pessoas no arquivo homepage.xhtml, utilize o 
componente <h:dataTable>. No backing bean do projeto, adicione um atributo 
para armazenar uma lista de pessoas e mude a anotação de escopo do backing 
bean para @SessionScoped do pacote javax.enterprise.context.
Ec
lip
se
REFERÊNCIAS
BEZERRA, E. Princípios de análise e projeto de sistemas com UML. Rio de Janeiro: Campus, 2015.
DEITEL, P., DEITEL, H. Java: como programar. 10. ed. São Paulo: Pearson, 2017.
GAMMA, E. et al. Padrões de Projeto: soluções reutilizáveis de software orientado a objetos. Porto Alegre: 
Bookman, 2007.
GEARY, D.; HORSTMANN, C. Core JavaServer Faces. 3. ed. Rio de Janeiro: Alta Books, 2012.
JAVA COMMUNITY PROCESS. Community Development of Java Technology Specifications. 2020. Disponível 
em: https://www.jcp.org/en/home/index. Acesso em: 4 ago. 2020.
LECHETA, R. R. Web Services RESTful. São Paulo: Novatec, 2015.
LUCKOW, D. H.; MELO, A. A. Programação Java para Web. São Paulo: Novatec, 2015.
40 Desenvolvimento de Software para Web
2
Desenvolvimento do 
back-end do sistema
O desenvolvimento de um sistema web é realizado em dois programas: 
o back-end e o front-end. O primeiro implementaas funcionalidades do siste-
ma que é executado em um servidor; e o segundo implementa uma interface 
gráfica para o cliente-usuário interagir com o sistema.
Para conhecer e aplicar as competências e bases tecnológicas utilizadas 
para o desenvolvimento de software para web, iremos desenvolver um sistema 
de cadastro de clientes. No back-end do sistema são criadas as classes de enti-
dade que representam a regra de negócio do sistema. A seguir, será realizado 
o teste unitário para garantir que as classes de entidade forneçam as suas fun-
cionalidades de maneira correta. Para tanto, o desenvolvimento de qualquer 
sistema utiliza a programação orientada a teste (test-driven development) para 
validar o sistema.
2.1 Criação das classes de regra de negócio
Vídeo A arquitetura de um sistema web utiliza o padrão MVC que separa as responsabili-
dades do sistema (GAMMA et al., 2007). Para o programa de cadastro de clientes, será 
acrescentado no padrão MVC a camada Value Objects (VO) – Objetos de Valores, em 
português –, que tem a responsabilidade de implementar funcionalidades de apoio à 
regra de negócio (LECHETA, 2015). A figura a seguir mostra que a camada VO é uma 
camada utilitária que pode ser utilizada por todas as demais camadas do sistema.
Figura 1
Arquitetura do sistema
Camada
View
Camada
Controller
Camada
VO
Camada
Model
Fonte: Elaborada pelo autor.
Desenvolvimento do back-end do sistema 41
As classes que representam as entidades do sistema, como a classe Cliente, 
serão implementadas na camada VO (DEITEL, P.; DEITEL, H., 2017).
O sistema de cadastro de cliente é desenvolvido para web e tem como 
propósito, como o próprio nome diz, realizar e gerenciar o cadastro de clientes. 
Sendo assim, para representar as entidades do sistema, serão definidas as classes 
Pessoa, Cliente e Usuario. A classe Pessoa representa uma pessoa no sistema 
de cadastro de cliente; a classe Usuario representa um usuário do sistema; e a 
classe Cliente representa um cliente, que herda a classe Pessoa e declara um 
atributo da classe Usuario. Como é explicado na figura a seguir, o diagrama de 
classe do back-end mostra o relacionamento entre as classes.
 A
st
ah
Figura 2
Diagrama de classe do back-end
A classe Pessoa declara os seguintes atributos:
 • Long id
 • String nome
 • Date dataNascimento
 • String cpf
A classe Pessoa declara a função construtora, os métodos getters e setters e o mé-
todo toString(). A figura a seguir mostra o diagrama de classe da classe Pessoa.
 A
st
ah
Figura 3
Diagrama de classe da classe Pessoa
Na fase de planejamento 
de um sistema, existem de-
cisões sobre o projeto que 
impactam o seu desenvol-
vimento. Uma questão que 
surge, já no início do plane-
jamento, está relacionada 
às classes de entidades 
(ou classes de domínio), 
que representam as regras 
de negócio do sistema. As 
classes de entidade são uti-
lizadas por todas as partes 
do sistema e, no padrão 
MVC, fica o questionamen-
to: em qual camada elas 
devem ser criadas? Existem 
diversas abordagens sobre 
essa questão e uma dis-
cussão sobre o tema, que 
vale a pena ser assistida, é 
feita pelo canal DevMedia, 
no vídeo A regra é clara! 
MVC, onde fica a regra de 
negócio?.
Disponível em: https://www.youtube.
com/watch?v=0FRMuk4RVS4. Acesso 
em: 5 nov. 2020.
Vídeo
https://www.youtube.com/watch?v=0FRMuk4RVS4
https://www.youtube.com/watch?v=0FRMuk4RVS4
42 Desenvolvimento de Software para Web
A classe Cliente define os seguintes atributos:
 • String email
 • String endereco
 • List<String> telefones
 • Date dataCadastro
 • Boolean ativo
 • Usuario usuario
Assim como a classe Pessoa, a classe Cliente declara a função construtora, os 
métodos getters e setters e o método toString(). A Figura 4 mostra o diagrama 
de classe da classe Cliente.
A classe Usuario define os seguintes atributos:
 • Long idCliente
 • String nomeUsuario
 • String senha
Assim como nas classes anteriores, a classe Usuario declara a função constru-
tora, os métodos getters e setters e o método toString(). O diagrama de classe da 
classe Usuario está apresentado na Figura 5.
 A
st
ah
Figura 4
Diagrama de classe para a classe Cliente
Figura 5
Diagrama de classe da classe Usuario
 A
st
ah
As classes Pessoa, Cliente e Usuario são criadas com base no padrão POJO 
e definem a estrutura básica das classes de entidade do sistema de cadastro de 
clientes.
Desenvolvimento do back-end do sistema 43
2.2 Implementação da regra de negócio do sistema 
Vídeo Para o desenvolvimento do sistema de cadastro de clientes é criado um Dynamic 
Web Project denominado CadastroClienteWeb.
Na pasta Java Resources\src é criado o pacote com.cadastro.vo, onde 
serão criadas as classes Pessoa, Cliente e Usuario.
Para realizar o teste unitário, serão criadas as classes TestPessoa, TestCliente 
e TestUsuario no pacote com.cadastro.vo.test. Para realizar um teste 
unitário é necessário criar uma nova pasta de arquivos fontes. Esta será criada na 
pasta Java Resources e será denominada src-test (LECHETA, 2015).
A Figura 6 mostra a estrutura do projeto CadastroClienteWeb, as pastas e os 
arquivos do back-end do sistema.
Uma pasta de fontes (Source Fol-
der) permite criar arquivos com ex-
tensão .java. A pasta src-test será 
criada na pasta Java Resources. No 
Project Explorer, selecione a pasta 
Java Resources do projeto Cadas-
troClienteWeb e clique com o botão 
direito. No menu de contexto, selecione 
File→ New→Source Folder e informe 
o nome do projeto e o nome da pasta. 
Clique em Finish.
Além do padrão POJO, de acordo 
com Luckow e Melo (2015), as classes 
de entidade do sistema criadas em um 
projeto web seguem um modelo de es-
trutura, conforme explicado a seguir.
A classe declara o método 
toString() do pacote java.lang 
para imprimir os valores dos atributos 
da classe. Depois, a classe implementa o 
atributo serialVersionUID e os 
métodos hashCode() e equals().
Para gerar o atributo serialVersionUID, identificador serial 
de versão do usuário (serial version user identifier, em inglês), a 
classe implementa a interface Serializable do pacote java.io. 
Esse número identifica de maneira única cada classe do sistema. 
O serialVersionUID é utilizado pelo servidor para identificar e 
referenciar cada classe do sistema. O Eclipse tem um algoritmo 
interno que gera o serialVersionUID. No editor de texto, na linha 
que declara a classe (na margem esquerda), clique no ícone em 
amarelo, como apresentado na Figura 7.
Uma determinada necessi-
dade de um sistema deve 
ser classificada como uma 
regra de negócio ou como 
um requisito do sistema? 
No vídeo Regra ou requisito, 
publicado pelo canal do 
consultor Fabrício Laguna, 
é esclarecida a diferencia-
ção desses dois conceitos. 
Disponível em: https://www.youtube.
com/watch?v=QyJDkR1Ejt4. Acesso 
em: 5 nov. 2020.
Vídeo
Figura 6
Estrutura do projeto CadastroClienteWeb
 E
cl
ip
se
https://www.youtube.com/watch?v=QyJDkR1Ejt4
https://www.youtube.com/watch?v=QyJDkR1Ejt4
44 Desenvolvimento de Software para Web
Figura 7
Gerando o atributo serialVersionUID
 E
cl
ip
se
Figura 8
Método para gerar o serialVersionUID
 E
cl
ip
se
Clique na opção Add generated serial version ID para 
selecionar o método que irá gerar o atributo serialVersionUID:
Figura 9
Assistente Generate hashCode() and 
equals()
 E
cl
ip
se
O método hashCode() gera um identificador único de cada ob-
jeto criado da classe com base nos valores dos atributos do objeto. 
O método equals() realiza o teste de igualdade entre dois objetos 
com base nos valores dos atributos dos objetos. O Eclipse tem uma 
funcionalidade para gerar os métodos hashCode() e equals(). No 
Project Explorer, selecione a classe, ou, alternativamente, no edi-
tor de texto que mostra o código da classe, selecione a opção Source 
→ Generate hashCode() and equals(). O assistente Generate 
hashCode() and equals() é exibido (Figura 9). Selecione os atri-
butos e todas as opções e clique em Generate.
O padrão adotado de escrita de uma classe normalizaa codifi-
cação e facilita a sua leitura e o entendimento por partes de outras 
pessoas. Esse padrão de codificação cria um código que possibilita a sua manuten-
ção e escalabilidade.
2.2.1 Classe Pessoa
A classe Pessoa é criada no pacote com.cadastro.vo.pessoa. A classe imple-
menta a interface Serializable e gera o atributo serialVersionUID.
A classe Pessoa declara a função construtora padrão public Pessoa() e a 
função construtora parametrizada public Pessoa(Long id, String nome, 
Date dataNascimento, String cpf).
A função construtora padrão é um método sem argumentos, enquanto a função 
construtora parametrizada é um método com argumentos e é utilizada para instan-
cializar um objeto, atribuindo valores iniciais para os atributos da classe.
Desenvolvimento do back-end do sistema 45
A classe Pessoa declara os atributos da classe e gera os métodos getters e setters. A 
classe Pessoa também declara os métodos toString(), hashCode() e equals().
A Figura 10 mostra o código da classe Pessoa. Os métodos hashCode() e 
equals() não são mostrados.
Figura 10
Classe Pessoa
1 package com.cadastro.vo.pessoa;
2
3 import java.io.Serializable;
4 import java.text.SimpleDateFormat;
5 import java.util.Calendar;
6 import java.util.Date;
7 import java.util.Objects;
8
9 public class Pessoa implements Serializable {
10
11 private static final long serialVersionUID = 2070994788708349019L;
12
13 private Long id;
14 private String nome;
15 private Date dataNascimento;
16 private String cpf;
17
18 public Pessoa() {
19 }
20
21 public Pessoa(Long id, String nome, Date dataNascimento, String cpf) {
22 super();
23 this.setId(id);
24 this.setNome(nome);
25 this.setDataNascimento(dataNascimento);
26 this.setCpf(cpf);
27 }
28
29 public Long getId() {
30 return id;
31 }
32
33 public void setId(Long id) {
34 this.id = id;
35 }
37 public String getNome() {
38 return nome;
39 }
40
41 public void setNome(String nome) {
42
(Continua)
46 Desenvolvimento de Software para Web
43 if (nome != null && nome.length() > 0) {
44 this.nome = nome.toUpperCase();
45 } else {
46 this.nome = null;
47 }
48 }
49
50 public Date getDataNascimento() {
51 return dataNascimento;
52 }
53
54 public void setDataNascimento(Date dataNascimento) {
55 this.dataNascimento = dataNascimento;
56 }
57
58 public String getCpf() {
59 return cpf;
60 }
61
62 public void setCpf(String cpf) {
63 this.cpf = cpf;
64 }
65
66 public String toString() {
67 
68 SimpleDateFormat simpleDateFormat =
69 new SimpleDateFormat(“dd/MM/yyyy”);
70 String saida = String.format(“\n%s:”, “Pessoa”);
71 saida += String.format(“\n\tId: %s”,
72 this.id != null ? this.id.toString() : “”);
73 saida += String.format(“\n\tNome: %s”,
74 this.nome != null ? this.nome : “”);
75 saida += String.format(“\n\tData de nascimento: %s”,
76 this.dataNascimento != null
77 ? simpleDateFormat.format(this.dataNascimento) : “”);
78 saida += String.format(“\n\tCPF: %s”, this.cpf != null ? this.cpf : “”);
79 
80 return saida;
81 }
82 }
Fonte: Elaborada pelo autor.
A classe Pessoa foi definida de acordo com as necessidades do programa, entre-
tanto sua estrutura permite sua reutilização em outras situações. Também é possível 
criar outras versões da classe Pessoa para atender à necessidade de outro programa.
Desenvolvimento do back-end do sistema 47
2.2.2 Classe Cliente
A classe Cliente é criada no pacote com.cadastro.vo.cliente, herda 
a classe Pessoa, implementa a interface Serializable, e gera o atributo 
serialVersionUID e os métodos hashCode() e equals().
A classe Cliente declara a função construtora padrão public Cliente() e a 
função construtora parametrizada public Cliente(Long id, String nome, 
Date dataNascimento, String cpf, String email, String endereco, 
List<String> telefones, Date dataCadastro, Boolean ativo, Usuario 
usuario). A classe Cliente declara os atributos da classe e gera os métodos getters 
e setters. A Figura 11 mostra o código da classe Cliente. Os métodos hashCode() 
e equals() não são mostrados.
Figura 11
Classe Cliente
1 package com.cadastro.vo.cliente;
2
3 import java.io.Serializable;
4 import java.text.SimpleDateFormat;
5 import java.util.Date;
6 import java.util.List;
7 import java.util.Objects;
8
9 import com.cadastro.vo.pessoa.Pessoa;
10 import com.cadastro.vo.usuario.Usuario;
11 
12 public class Cliente extends Pessoa implements Serializable {
13
14 private static final long serialVersionUID = -7602423407068491900L;
15
16 public Cliente() {
17 }
18
19 private String email;
20 private String endereco;
21 private List<String> telefones;
22 private Date dataCadastro;
23 Boolean ativo;
24 private Usuario usuario;
25
26 public Cliente(Long id, String nome, Date dataNascimento,
27 String cpf, String email, String endereco, List<String> telefones,
28 Date dataCadastro, Boolean ativo, Usuario usuario) {
29
(Continua)
48 Desenvolvimento de Software para Web
30 super(id, nome, dataNascimento, cpf);
31 this.setEmail(email);
32 this.setEndereco(endereco);
33 this.setTelefones(telefones);
34 this.setDataCadastro(dataCadastro);
35 this.setAtivo(ativo);
36 this.setUsuario(usuario);
37 }
38
39 public void setEmail(String email) {
40 this.email = email;
41 }
42
43 public String getEmail() {
44 return email;
45 }
46
47
48 public String getEndereco() {
49 return endereco;
50 }
51 
52 public void setEndereco(String endereco) {
53 this.endereco = endereco;
54 }
55
56 public List<String> getTelefones() {
57 return telefones;
58 }
59
60 public void setTelefones(List<String> telefones) {
61 this.telefones = telefones;
62 }
63
64 public Date getDataCadastro() {
65 return dataCadastro;
66 }
67
68 public void setDataCadastro(Date dataCadastro) {
69 this.dataCadastro = dataCadastro;
70 }
71
71
72 public Boolean getAtivo() {
73 return ativo;
74 }
75
(Continua)
Desenvolvimento do back-end do sistema 49
76 public void setAtivo(Boolean ativo) {
77 this.ativo = ativo;
78 }
79
80 public Usuario getUsuario() {
81 return usuario;
82 }
83
84 public void setUsuario(Usuario usuario) {
85 this.usuario = usuario;
86 }
87
88 @Override
89 public String toString() {
90
91 SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“dd/MM/yyyy”);
92
93 String saida = super.toString();
94 saida += String.format(“\n%s:”, “Cliente”);
95 saida += String.format(“\n\tE-mail: %s”, this.email != null ? this.email 
: “”);
96 saida += String.format(“\n\tEndereço: %s”, this.endereco != null
97 ? this.endereco : “”);
98 saida += String.format(“\n\t%s:”, “Telefones”);
99 
100 if (this.telefones != null && this.telefones.size() > 0) {
101 for (String telefone : this.telefones) {
102 saida += String.format(“\n\t\t%s”, telefone);
103 }
104 }
105
106 saida += String.format(“\n\tData cadastro: %s”,
107 this.dataCadastro != null
108 ? simpleDateFormat.format(this.dataCadastro) : “”);
109 saida += String.format(“\n\tAtivo: %s”,
110 this.ativo != null ? this.ativo.equals(true)
111 ? “Verdadeiro” : “Falso” : “”);
112 saida += this.usuario.toString();
113 return saida;
114 }
115 }
Fonte: Elaborada pelo autor.
A classe Cliente herda a classe Pessoa, sendo assim, podemos dizer que um 
cliente é também uma pessoa. O processo de herança é bastante interessante 
pois permite criar uma classe com base em outra classe. Entretanto, o processo de 
herança impacta no processo de modelagem do banco de dados. Existem várias 
possibilidades de se implementar o processo no banco de dados e teremos 
que fazer uma escolha em relação ao mapeamento objeto-relacional.
50 Desenvolvimento de Software para Web
2.2.3 Classe Usuario
A classe Usuario é criada no pacote com.cadastro.vo, implementa a inter-
face Serializable, gera o atributo serialVersionUID e declara os métodos 
toString(), hashCode() e equals().
A classe Usuario declara a função construtora padrão public Usuario() e a 
função construtora parametrizada public Usuario(LongidCliente, String 
nomeUsuario, String senha).
A classe Usuario declara os atributos da classe e gera os métodos getters e 
setters. A Figura 12 mostra o código da classe Usuario. Os métodos hashCode() e 
equals() não são mostrados.
Figura 12
Classe Usuario
1 package com.cadastro.vo.usuario;
2 
3 import java.io.Serializable;
4 import java.util.ArrayList;
5 import java.util.List;
6 import java.util.Objects;
7
8 import com.cadastro.vo.permissao.Permissao;
9
10 public class Usuario implements Serializable {
11
12 private static final long serialVersionUID = -2283331576870325660L;
13
14 private Long idCliente;
15 private String nomeUsuario;
16 private String senha;
17
18 public Usuario() {
19 }
20
21 public Usuario(Long idCliente, String nomeUsuario, String senha) {
22 super();
23 this.setIdCliente(idCliente);
24 this.setNomeUsuario(nomeUsuario);
25 this.setSenha(senha);
26 }
27
28 public Long getIdCliente() {
29 return idCliente;
30 }
31
32 public void setIdCliente(Long idCliente) {
33 this.idCliente = idCliente;
34 }
35
(Continua)
Desenvolvimento do back-end do sistema 51
36 public String getNomeUsuario() {
37 return nomeUsuario;
38 }
39
40 public void setNomeUsuario(String nomeUsuario) {
41 this.nomeUsuario = nomeUsuario;
42 } s
43
44 public String getSenha() {
45 return senha;
46 }
47
48 public void setSenha(String senha) {
49 this.senha = senha;
50 }
51
52 public String toString() {
53 
54 String saida = String.format(“\n%s:”, “Usuário”);
55 saida += String.format(“\n\tId cliente: %s”, this.idCliente != null
56 ? this.idCliente.toString() : “”);
57 saida += String.format(“\n\tNome usuário: %s”, this.nomeUsuario != null
58 ? this.nomeUsuario : “”);
59 saida += String.format(“\n\tSenha: %s”, this.senha != null ? this.
senha : “”);
60 saida += String.format(“\n\t%s:”, “Permissões”);
61
62 return saida;
63 }
64 }
Fonte: Elaborada pelo autor.
A definição da classe Usuario permite que o sistema implante mais à frente o 
sistema de autenticação e de autorização para acessar o sistema.
2.3 Realização de teste unitário do back-end
Vídeo Para validar as classes que representam as entidades do sistema (Pessoa, 
Cliente e Usuario), realizaremos o teste unitário com o JUnit.
Para tanto, selecione a pasta de fontes src-test na pasta Java Resources, clique 
com o botão direito e selecione New→Other. No assistente Select a wizard, digite 
junit e selecione JUnit Test Case. No assistente New Junit Test Case, informe 
o nome do pacote e o nome da classe e clique em Finish. Na primeira vez que é criada 
uma classe com o JUnit no projeto é preciso informar a versão do JUnit que será utilizada. 
Como na Figura 13, selecione Add JUnit 5 library to build path e clique em OK.
52 Desenvolvimento de Software para Web
Figura 13
Versão do JUnit
 E
cl
ip
se
A classe de teste herda a classe TestCase do pacote junit.framework e deve 
implementar um método anotado com a instrução @Test do pacote org.junit.
jupiter.api. Quando a classe de teste for executada, o JUnit executa todos os 
métodos anotados com @Test.
O método assertTrue() da classe TestCase do pacote junit.framework rea-
liza um teste de validade verificando se uma determinada condição é verdadeira. Já o 
método assertEquals() da classe TestCase do pacote junit.framework realiza 
o teste de igualdade comparando um valor esperado com o valor atual.
Execute o teste com a opção Run As→JUnit Test. Na janela console do JUnit, 
se o teste for bem sucedido, o resultado estará em verde, caso contrário, estará em 
vermelho e serão mostrados os erros.
2.3.1 Classe TestPessoa
A classe TestPessoa, que realiza o teste unitário para a classe Pessoa, é criada 
no pacote com.cadastro.vo.test.pessoa. A classe TestPessoa declara o mé-
todo testPessoa() anotado com a instrução @Test (Figura 14).
Figura 14
Classe TestPessoa
1 package com.cadastro.vo.test.pessoa;
2
3 import java.util.Calendar;
4 import java.util.Date;
5 import org.junit.jupiter.api.Test;
6 import com.cadastro.vo.pessoa.Pessoa;
7 import junit.framework.TestCase;
8
9 class TestPessoa extends TestCase {
10
11 @Test
12 void testPessoa() {
13
14 Long id = 1L;
15 String nome = “ana paula padrão”;
16 Calendar calendar = Calendar.getInstance();
(Continua)
Desenvolvimento do back-end do sistema 53
17
18 calendar.set(1987, 2, 15);
19 Date dataNascimento = calendar.getTime();
20 String cpf = “123.456.789-00”;
21 Pessoa pessoa = new Pessoa(id, nome, dataNascimento, cpf);
22
23 assertTrue(pessoa != null);
24 assertTrue(pessoa.getId() != null);
25 assertTrue(pessoa.getNome() != null && pessoa.getNome().length() > 0);
26 assertTrue(pessoa.getDataNascimento() != null);
27 assertTrue(pessoa.getCpf() != null && pessoa.getCpf().length() > 0);
28
29 assertEquals(id, pessoa.getId());
30 assertEquals(nome.toUpperCase(), pessoa.getNome());
31 assertEquals(dataNascimento, pessoa.getDataNascimento());
32 assertEquals(cpf, pessoa.getCpf());
33
34 }
35 }
Fonte: Elaborada pelo autor.
Na Figura 14 (linhas 14-21), é declarado e instancializado o objeto pessoa da 
classe Pessoa e são atribuídos valores para os atributos do objeto.
Na classe TestPessoa são realizados os seguintes testes de validade:
 • na linha 23, é verificado se o objeto pessoa existe;
 • na linha 24, é verificado se o atributo id existe;
 • na linha 25, é verificado se o atributo nome existe e se não é vazio;
 • na linha 26, é verificado se o atributo dataNascimento existe;
 • na linha 27, é verificado se o atributo cpf existe.
Na classe TestPessoa, são realizados os seguintes testes de igualdade:
 • na linha 29, é comparado o valor da variável id com o valor do atributo id do 
objeto pessoa;
 • na linha 30, é comparado o valor da variável nome com o valor do atributo 
nome do objeto pessoa;
 • na linha 31, é comparado o valor da variável dataNascimento com o valor 
do atributo dataNascimento do objeto pessoa;
 • na linha 32, é comparado o valor da variável cpf com o valor do atributo cpf 
do objeto pessoa.
O teste unitário realizado com a classe TestPessoa validou a classe Pessoa 
garantindo a sua funcionalidade.
54 Desenvolvimento de Software para Web
2.3.2 Classe TestCliente
Como apresenta a figura a seguir, a classe TestCliente, que realiza o teste 
unitário para a classe Cliente, é criada no pacote com.cadastro.vo.test.
cliente e declara o método testCliente() anotado com a instrução @Test.
Figura 15
Classe TestCliente
1 package com.cadastro.vo.cliente.test;
2
3 import java.util.List;
4 import org.junit.jupiter.api.Test;
5 import com.cadastro.vo.cliente.Cliente;
6 import com.cadastro.vo.usuario.Usuario;
7 import junit.framework.TestCase;
8
9 class TestCliente extends TestCase {
10
11 @Test
12 void testeCliente() {
13
14 Long id = 1L;
15 String nome = “ana paula padrão”;
16 String nomeUsuario = “ana.padrao”;
17 String senha = “paulaAP@123”;
18 Usuario usuario = new Usuario(id, nomeUsuario, senha);
19 Cliente cliente = new Cliente();
20 cliente.setId(id);
21 cliente.setNome(nome);
22 cliente.setUsuario(usuario);
23
24 assertTrue(cliente != null);
25 assertTrue(cliente.getId() != null);
26 assertTrue(cliente.getNome() != null && cliente.getNome().
length() > 0);
27 assertTrue(cliente.getUsuario() != null);
28 assertTrue(cliente.getUsuario().getIdCliente() != null);
29 assertTrue(cliente.getUsuario().getNomeUsuario() != null
30 && cliente.getUsuario().getNomeUsuario().length() > 0);
31 assertTrue(cliente.getUsuario().getSenha() != null
32 && cliente.getUsuario().getSenha().length() > 0);
33
34 assertEquals(id, cliente.getId());
35 assertEquals(nome.toUpperCase(), cliente.getNome());
36 assertEquals(id, cliente.getUsuario().getIdCliente());
37 assertEquals(nomeUsuario, cliente.getUsuario().
getNomeUsuario());
38 assertEquals(senha, cliente.getUsuario().getSenha());
39 }
40 }
 Fonte: Elaborada pelo autor.
Desenvolvimento do back-end do sistema 55
Na Figura