Apostila Java Web (Servlets e JSPs)

Ricardo Terra (rterrabh [at] gmail.com) Outubro, 2008
Java Web
Ricardo Terra
rterrabh [at] gmail.com
Java Web 1

Ricardo Terra (rterrabh [at] gmail.com) Outubro, 2008
CV
Java Web 2
Nome: Ricardo Terra
Email: rterrabh [at] gmail.com
www: ricardoterra.com.br
Twitter: rterrabh
Lattes: lattes.cnpq.br/ 0162081093970868
Ph.D. (UFMG/UWaterloo),
Post-Ph.D. (INRIA/Université Lille 1)
Background
Acadêmico: UFLA (desde 2014), UFSJ (1 ano), FUMEC (3 anos), UNIPAC (1 ano), FAMINAS (3 anos)
Profissional: DBA Eng. (1 ano), Synos (2 anos), Stefanini (1 ano)

Ricardo Terra (rterrabh [at] gmail.com) Outubro, 2008Java Web 3
Por que utilizar Servlets e JSP?
n  Muitos têm adotado esta estratégia de desenvolvimento (estão na
moda)
n  Existem diversas aplicações GUI que são utilizadas por milhões de
pessoas, porém essas aplicações possuem diversos problemas de
distribuição
q  Em uma aplicação web, você não precisará se prender aos problemas
de distribuição, pois sua aplicação funcionará em qualquer computador
que possua um browser, independente do S.O., memória, processador,
etc

Por que utilizar Servlets e JSP?
n  Nesta disciplina, vamos substituir as aplicações GUI por aplicações
Web
n  Uma aplicação web é composta de tecnologia:
q  No lado do cliente: HTML, XML, CSS, JS, etc
q  No lado do servidor: CGI, ASP, PHP, servlets, etc

Cliente e Servidor / HTTP e HTML
n  Quando um servidor responde a uma solicitação, ele geralmente
envia algum tipo de conteúdo para o browser, para que esse possa
exibí-lo
q  O formato HTML é o formato mais comum enviado como resposta para
um cliente pelo Servidor, pois esse é facilmente lido pelo browser no
cliente

n  A maioria das conversas que ocorre na web entre clientes e
servidores são mantidas através do protocolo HTTP, que possibilita
conversas de requisição e resposta
n  O cliente envia uma requisição HTTP e o servidor retorna uma
resposta HTTP
q  Enfim, se você é um servidor web você fala HTTP
n  Portanto, uma conversação HTTP é uma sequência de requisição/
resposta
q  Isto é, o cliente pede uma coisa, o servidor responde, o cliente pede
outra coisa, o servidor responde...

n  Requisição e resposta:

n  O HTTP roda no topo da arquitetura TCP/IP
n  O HTTP é um protocolo da camada de aplicação que tem
características específicas para a web, mas ele depende de toda a
arquitetura TCP/IP para garantir que tanto a solicitação e quanto a
resposta sejam transmitidas entre o cliente e o servidor

n  HTTP na camada de aplicação da arquitetura TCP/IP

Requisição e resposta
n  Principais elementos do fluxo de requisição:
q  método HTTP
q  endereço da página (URL) que está sendo acessada
q  parâmetros do formulário
n  Principais elementos do fluxo de resposta:
q  cabeçalho
n  código de status
n  Método HTTP
n  tipo do conteúdo (texto, imagem, HTML...)
q  conteúdo (o texto, a imagem, o HTML...)

n  Requisição HTTP
q  A primeira coisa que você encontrará é o nome do método HTTP
n  O nome do método informa ao servidor o tipo de solicitação que está sendo
feita e como o resto da mensagem será formatada.
q  O protocolo HTTP possui diversos métodos, mas usaremos e
aprenderemos os mais comuns: GET e POST

n  Método GET
q  É o método mais simples do HTTP e seu principal trabalho é pedir um
recurso
n  Pode ser qualquer tipo de recurso: uma página, uma imagem, um PDF, etc
q  O caminho até o recurso e quaisquer parâmetros adicionados à URL
serão incluídos na própria barra de endereços
q  Podemos usar o GET para formulários, porém com desvantagens:
n  O total de caracteres do GET é limitado
n  Os dados que você envia utilizando HTTP GET são anexados à URL,
portanto, seja o que for que você estiver transmitindo, ficará exposto

n  Método POST
q  É um método mais poderoso. É um GET++. Com o POST, você pode
solicitar algo e, ao mesmo tempo, enviar os dados de um formulário
para o servidor
q  Os dados a serem enviados ao servidor estão localizados na carga útil
(payload) da mensagem e podem ser bem extensos
Pacote IPv4
q  Por isto, o POST é considerado mais seguro que o GET

n  Enfim, para acesso a recursos utiliza-se GET e aplicações que utilizam
formulários utiliza-se POST

n  Resposta HTTP
q  uma resposta HTTP é composta de um cabeçalho (header) e o corpo
n  o cabeçalho informa ao browser o método que está sendo utilizado, se a
solicitação obteve êxito (código) e o tipo de conteúdo está incluído no corpo
n  corpo possui o conteúdo (por exemplo, HTML) que o browser exibirá
q  o código pode ser:
n  1xx: Informativa: requisição recebida, processo em continuidade…
n  2xx: Sucesso: a ação foi recebida, entendida e aceita com sucesso
n  3xx: Redirecionamento: ação futura ainda deve ser tomada para completar
a requisição
n  4xx: Erro no cliente: requisição contém sintaxe incorreta ou não pode ser
resolvida
n  5xx: Erro no servidor: O servidor falhou ao responder uma aparente
requisição válida

Páginas estáticas x Páginas dinâmicas
n  Servidores "amam" servir páginas estáticas
q  Uma página estática é apenas um HTML que está armazenado no
servidor. Quando o usuário pede a página, o servidor simplesmente
busca a página e a envia do mesmo modo que está lá. Não processa ou
dispende recursos para entregá-la ao cliente
n  Porém, às vezes você precisa mais do que uma página estática
q  Se você precisa de páginas dinâmicas (páginas criadas no momento da
requisição, isto é, não existiam antes da solicitação) e da capacidade de
escrever/salvar dados no servidor (seja em arquivos ou em SGBDs),
você precisa de uma aplicação rodando no servidor
q  Para isso, começaremos a ver aplicações web usando Java EE

Primeiro Projeto Web
n  Para entendermos melhor como criar uma aplicação web, observe o
material "Primeiro Projeto Web" que demostra como criar uma
aplicação web completa
n  Algumas considerações:
q  O principal arquivo de uma aplicação web é o Deployment Descriptor
(DD)
n  Deployment Descriptor (descritor de implantação) é um documento XML
único por aplicação chamado web.xml que fica abaixo do diretório WEB-INF
e que contém as informações de como sua aplicação deve ser implantada
q  O Tomcat geralmente utiliza a porta 8080 para executar as aplicações
n  Geralmente, quando a aplicação entra em produção é executada na porta 80,
que é a porta do protocolo HTTP (o protocolo da Internet)

Métodos Importantes Web
n  Uma aplicação web é basicamente um servlet
q  Um servlet é uma classe que estende HttpServlet
n  Os métodos importantes de um servlet são:
q  doGet à responsável por tratar requisições GET
q  doPost à responsável por tratar requisições POST
n  Quando criamos pelo wizard do Eclipse, a aplicação já é registrada
automaticamente no DD

n  Primeiramente devemos setar o tipo de conteúdo da resposta:
q  response.setContentType("text/html");
n  Para escrever no cliente devemos escrever na resposta:
q  PrintWriter out = response.getWriter();
n  Geralmente escrevemos todo o HTML:
q  out.print("<html><body>");
out.print("Agora: " + new Date());
out.print("</body></html>");
n  Mas sempre fechamos após escrever:
q  out.close();

n  Existem alguns métodos que são indispensáveis para o
desenvolvimento de servlets, pois são aqueles que manipulam os
parâmetros enviados por uma requisição:
q  public String getParameter(String nomeParam)
n  Retorna o valor string de um parâmetro específico
q  Exemplo:
§  Pegando um nome, uma idade, um peso, uma profissão, uma cidade...
q  public String[] getParameterValues(String nomeParam)
n  Retorna o vetor de string de um parâmetro específico
q  Exemplo:
§  Pegando nomes de um time de futebol, notas de uma turma...

n  A utilização trivial seria, logo após setar o tipo do conteúdo da
resposta, pegar todos os parâmetros da requisição e colocá-los
dentro de variáveis locais. Por exemplo:
q  String nome = request.getParameter("nome");
int idade = Integer.parseInt(
request.getParameter("idade"));
String nomes[] = request.getParameterValues("nomes");
String numeros[] = request.getParameterValues("n");

Uma metodologia simples
1.  Setar o tipo de conteúdo da resposta (setContentType)
2.  Colocar os parâmetros em variáveis locais (veja slide anterior)
3.  Obter a escrita na resposta (out = response.getWriter())
4.  Utilizar Java SE para gerar o HTML de resposta (out.print(...))
5.  Fechar a escrita na resposta (out.close())

Exemplo 01 – Exibir nome
n  Vamos submeter a seguinte URL, isso seria via o método GET:
q  /ExibirNome?nome=Carlos
n  Para iniciarmos a passagem de parâmetros, é inserido um ? e depois os
parâmetros são separados por &.
n  Ou talvez submeter via formulário, usando o método POST:
<form action="${pageContext.request.contextPath}/ExibirNome"
method="POST">
Nome: <input type="text" name="nome" /> <br />
<input type="submit" value="Enviar" />
<input type="reset" value="Limpar" />
</form>

Exemplo 01 – Exibir nome
n  Como seria o código interno do método doGet (caso seja via URL)
ou do método doPost (caso seja via formulário)?
public [doPost|doGet](...) throws ... {
response.setContentType("text/html");
String nome = request.getParameter("nome");
PrintWriter out = response.getWriter();
...
out.printf("Olá %s! Seja bem vindo!", nome);
...
out.close();
}

Exemplo 02 – Somar
q  /Somar?x=3&y=7
n  Para iniciarmos a passagem de parâmetros, é inserido um ? e depois os
parâmetros são separados por &.
<form action="${pageContext.request.contextPath}/Somar"
method="POST">
X: <input type="text" name="x" size="6" /> <br />
Y: <input type="text" name="y" size="6" /> <br />
<input type="submit" name="evento" value="Enviar" />
</form>

Exemplo 02 – Somar
response.setContentType("text/html");
int x = Integer.parseInt(request.getParameter("x"));
int y = Integer.parseInt(request.getParameter("y"));
PrintWriter out = response.getWriter();
...
out.printf("%d + %d = %d", x, y, (x+y));
...
out.close();
}

Exemplo 03a – Somar vários
n  Um único parâmetro pode receber diversos valores
q  /SomarVarios?n=3.2&n=7.1&n=3.7&n=2.7&n=5.1&n=4.7
q  A requisição acima envia vários valores no parâmetro n e o Servlet deve
ser capaz de recuperar todos eles usando não mais o método
getParameter(), mas sim, getParameterValues()
n  Recordando:
q  o método getParameter() retorna uma string
n  usado para recuperar parâmetros simples com apenas um valor
q  o método getParameterValues() retornar um vetor de string
n  usado para recuperar parâmetros com múltiplos valores

<form action="${pageContext.request.contextPath}/SomarVarios"
method="POST">
Números:<br />
<input type="text" name="n" size="6" />,
<input type="text" name="n" size="6" /> <br />
<input type="submit" name="evento" value="Enviar" />
</form>

...
String[] strNumeros = request.getParameterValues("n");
double soma = 0;
for (String s : strNumeros){
soma += Double.parseDouble(s);
}
...
out.printf("SOMA: %f, soma);
...
}

Exemplo 03b – Exibir maior/menor
n  Com base na idéia da URL ou do formulário do Exemplo 3a é
possível fazer a exibição do maior e do menor número. Observe:
...
double min, max;
min = max = Double.parseDouble(strNumeros[0]);
for (int i = 1; i < strNumeros.length; i++) {
double n = Double.parseDouble(strNumeros[i]);
if (n > max) {
max = n;
} else if (n < min) {
min = n;
}
}
...
out.printf("O menor valor é %f e o maior valor é %f", min, max);
...
}

Exemplo 03c – Exibir maior/menor
n  Uma observação bem importante é que o botão de submissão do
formulário também pode passar um parâmetro (como o evento a ser
realizado) e pode ser utilizado para indicar o que deve ser realizado
com os outros parâmetros passados
n  Por exemplo, vamos alterar o exemplo 03b para ter dois botões de
submissão:
n  Exibir Maior
n  Exibir Menor

n  Formulário do Exemplo 03a com alterações destacadas
q  o action do formulário
q  os botões de submissão
<form action="${pageContext.request.contextPath}/ExibirMM"
method="POST">
...
<input type="submit" name="evento" value="Exibir Maior" />
<input type="submit" name="evento" value="Exibir Menor" />
...
</form>

n  Como ficaria o Servlet:
...
String evento = request.getParameter("evento");
if (evento.equals("Exibir Maior")){
this.exibirMaior(strNumeros,out); //Chama um método local
}else if (evento.equals("Exibir Menor")){
this.exibirMenor(strNumeros,out); //Chama um método local
}
...
}

n  E assim ficariam os métodos exibirMaior e exibirMenor
private void exibirMenor(String[] strNumeros, PrintWriter out) {
double min = Double.parseDouble(strNumeros[0]);
for (int i=1; i<strNumeros.length; i++){
if (n < min){
min = n;
}
}
out.printf("O menor elemento é %f", min);
}
private void exibirMaior(String[] strNumeros, PrintWriter out) {
double max = Double.parseDouble(strNumeros[0]);
for (int i=1; i<strNumeros.length; i++){
if (n > max){
max = n;
}
}
out.printf("O maior elemento é %f", max);
}

n  Como se pôde observar, dependendo do botão de submissão do
formulário acionado, a ação realizada será diferente
n  Isto é bem utilizado quando tivermos um único servlet e várias
ações a serem realizadas
n  Por exemplo, uma tela que salva, atualiza, exclui e lista os
funcionários será vinculada a um mesmo servlet e dependendo do
botão de submissão acionado direcionará a ação desejada

Só Servlets?
n  Até agora estamos desenvolvendo aplicações somente utilizando
servlets
n  Qual o maior problema ou dificuldade encontrada em se
desenvolver um servlet?
q  Escrever todo o código HTML no próprio servlet
n  Imagina ainda se fosse um servlet cuja resposta seria uma enorme
página HTML?
n  Como resolver esse problema?

Utilizando JSP
n  A solução para não ficar escrevendo todo o código HTML dentro do
servlet é utilizar páginas JSP (Java Server Pages)
n  Muitos utilizam o servlet para fazer a lógica de negócio (query no
banco de dados, inserir um registro, registrar um empréstimo) e,
então, encaminham a solicitação para um JSP que apresentará o
HTML de resposta
n  Trabalhando da maneira acima, observa-se uma separação entre a
lógica de negócio que está sendo realizada pelos servlets e a
apresentação que está sendo realizada pelas páginas JSP
q  Isso pode parecer o MVC, mas ainda não é

Utilizando JSP
n  Uma página JSP é muito mais ágil para a geração de um
documento HTML como saída do que um servlet
q  Podemos pensar em uma página JSP como um documento HTML com
algumas tags especiais
n  Porém, na verdade, uma página JSP é um servlet
q  É interpretada em seu primeiro acesso é traduzida em um servlet
hello.jsp hello_jsp.java hello_jsp.class
Servlet
Carregado
pelo
container
Traduzido Compilado

Utilizando JSP
n  Uma página JSP facilita o desenvolvimento da camada de
apresentação uma vez que permite que os templates em HTML
possam ser reaproveitados pelo desenvolvedor
n  Já que é uma página JSP é um servlet e já que um servlet é uma
classe Java, então uma página JSP pode conter códigos Java
n  Uma página JSP é composta basicamente por elementos HTML e
tags que delimitam códigos Java (chamados scripts)

Utilizando JSP
n  São as tags JSP:
q  <%@ %> Diretiva JSP: define parâmetros para o container (no caso
para o Tomcat
q  <% %> Scriptlet: tudo o que tiver dentro desta região é considerado
código Java. Uso não recomendado, preferir EL ou JSTL
q  <%! %> Declaração: utilizada para definir métodos e declarar
variáveis. Uso não recomendado, preferir EL ou JSTL
q  <%= %> Expressão: o mesmo que chamar <% out.print(…) %>. Não
tem ponto-e-vírgula (;) no final. Uso não recomendado,
preferir EL ou JSTL

Tags JSP – Exemplo 01
n  O exemplo abaixo utiliza diretiva JSP para passar diversas
informações sobre aquela página, faz declaração de um vetor de
strings com diversos nomes, faz um scriplet para iterar o vetor e
utiliza expressão para exibir os nomes em caixa alta:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" %>
<%!String[] nomes = {"Adriana","Carlos","Evandro","Gabriel", "Marcos"};%>
<html>
<body>
<ul>
<%for(String nome : nomes){%>
<li><%=nome.toUpperCase()%></li>
<%}%>
</ul>
</body>
</html>
Resultado:

Tags JSP – Exemplo 02
n  O exemplo abaixo faz a declaração de uma função, faz um scriplet
para buscar o valor de um parâmetro da requisição e depois invoca
a função declarada passando o parâmetro:
q  Neste exemplo foi realizada a chamada ao JSP passando o parâmetro
diretamente via GET: /calcularPagamento.jsp?valor=1000.00
<%!
double incluiTaxas(double valor){
return valor*1.1;
}
%>
<html>
<body>
<%double valor = Double.parseDouble(request.getParameter("valor"));%>
O valor do pagamento é <%=this.incluiTaxas(valor)%>
</body>
</html>
Resultado:

Encaminhar ou redirecionar
n  Como já vimos que o JSP será responsável pela apresentação,
devemos saber como encaminhar uma requisição ou redicionar um
cliente
n  Portanto:
q  Você pode encaminhar (forward) a requisição para ser completada
n  Um exemplo é depois de realizar todos os processamentos no servlet
devemos encaminhar a requisição à uma página JSP para que ela apresente
os dados dessa requisição
q  Você pode redirecionar a requisição para outro lugar
n  Um exemplo é quando a requisição está sem autenticação e você não quer
tratá-la, mas sim, redirecionar o usuário para tela de login do sistema

Encaminhar (forward)
n  Ao encaminhar, o controle permanece dentro do container.
n  Um servlet envia a requisição para o próximo servlet ou JSP e os
objetos HttpServletRequest e HttpServletResponse são
encaminhados juntamente
n  Para o usuário, ele não conhece os servlets pelo qual ele foi
encaminhado, e sim, somente o que ele acessou
q  A URL do navegador não é alterada
n  Encaminhamentos (forwardings) podem ocorrer apenas dentro do
contexto web da aplicação, isto é, somente entre servlets e páginas
JSP

Encaminhar (forward)
...
request.getRequestDispatcher("/resultListagem.jsp")
.forward(request, response);
...
}
Response
Servlet
ou JSP
Servlet
ou JSP

Redirecionar (redirect)
n  O servlet envia um código HTTP 303 como resposta informando
uma nova URL deve ser acessada
n  Redirecionamento é usado quando precisa-se sair do contexto
(acessar um recurso externo como o site do google, por exemplo)
q  Com redirect, perde-se todas as variáveis que existiam dentro do
request, sendo necessário repassá-las à nova URL

Redirecionar (redirect)
...
response.sendRedirect("http://www.google.com.br");
return;
}
Request
Request
Redirect
Servlet
ou JSP

Exemplo encaminhamento
n  JSP com formulário de submissão (formSoma.jsp)
<html>
<body>
<font type="red">${requestScope.msgErro}</font> <br />
<form action="${pageContext.request.contextPath}/Somar"
method="POST">
X: <input type="text" name="x" value="${param.x}" size="6"/>
Y: <input type="text" name="y" value="${param.y}" size="6"/>
<input type="submit" name="evento" value="Somar"/>
<input type="reset" value="Limpar"/>
</form>
</body>
</html>

n  Servlet com a lógica de negócio
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
int x = 0, y = 0;
if (this.isNumber(request.getParameter("x"))) {
x = Integer.valueOf(request.getParameter("x"));
} else {
request.setAttribute("msgErro", "O atributo X é inválido");
request.getRequestDispatcher("/formSoma.jsp").forward(request,response);
return;
}
if (this.isNumber(request.getParameter("y"))) {
y = Integer.valueOf(request.getParameter("y"));
} else {
request.setAttribute("msgErro", "O atributo Y é inválido");
request.getRequestDispatcher("/formSoma.jsp").forward(request,response);
return;
}
request.setAttribute("z", x + y);
// Encaminho para a JSP de resposta
request.getRequestDispatcher("/resultSoma.jsp").forward(request,response);
}

n  Além do método doPost, a classe do servlet também terá o método
isNumber que verificará se é uma certa string é um número inteiro:
private boolean isNumber(String str) {
return str.matches("^-{0,1}[0-9]+");
}
n  JSP com a resposta a ser apresentada (resultSoma.jsp)
<html>
<body>
O resultado da soma de ${param.x} + ${param.y} = ${requestScope.z}
</body>
</html>

Escopos
n  No último exemplo vimos códigos como:
q  No servlet:
n  request.setAttribute(“z”,x+y)
q  Na JSP:
n  ${requestScope.z}
q  Porém, não sabemos exatamente o que era. Isso trata-se da utilização
de escopo para armazenamento de informações
n  Os escopos são áreas de armazenamento com propriedades
específicas e podem ser de:
q  Página (pageScope) à somente existe em páginas JSP
q  Requisição (requestScope)
q  Sessão (sessionScope)
q  Aplicação (applicationScope)

Escopo de página
n  Escopo de página (pageScope)
q  Esse escopo é o mais curto e só existe durante a renderização da
página JSP
q  Colocando variáveis neste escopo (somente dentro da página JSP):
n  <%pageContext.setAttribute("nomeAtributo",valor);%>
q  Buscando o valor de uma variável nesse escopo:
n  Usando EL:
q  ${pageScope.nomeAtributo}
n  Usando expressão JSP (preferir EL):
q  <%=pageContext.getAttribute("nomeAtributo")%>

Escopo de página
Escopo de página
pageScope
Cliente 1 JSP A
n  Uso comum:
q  Uso de variáveis temporárias usadas somente para a renderização da
página JSP

Escopo de requisição
n  Escopo de requisição (requestScope)
q  Este escopo só existe durante a requisição, isto é, seu armazenamento
inicia-se no momento em que uma requisição é realizada e termina junto
com o término requisição
q  Colocando variáveis neste escopo:
n  request.setAttribute("nomeAtributo",valor);
n  Usando EL:
q  ${requestScope.nomeAtributo}
q  <%=request.getAttribute("nomeAtributo")%>

set get
requestScope
Cliente 1 Servlet/JSP A Servlet/JSP B
n  Uso comum:
q  Passagem de informações adquiridas em um servlet para a página JSP
de resposta

Escopo de sessão
n  Escopo de sessão (sessionScope)
q  Este escopo é único por sessão (vínculo de um usuário utilizando a
aplicação), isto é, o escopo existe enquanto a sessão do usuário estiver
aberta
n  request.getSession().setAttribute("nomeAtributo",valor);
n  Usando EL:
q  ${sessionScope.nomeAtributo}
q  <%=request.getSession().getAttribute("nomeAtributo")%>

Escopo de sessão
Escopo de sessão
sessionScope
set
setCliente 1
Servlet/JSP A
Servlet/JSP B
n  Uso comum:
q  Armazenamento das informações do usuário. Por exemplo, nome,
histórico de páginas visitadas, permissões de acesso, disciplinas do
aluno...

Escopo de aplicação
n  Escopo de aplicação (applicationScope)
q  Este escopo é o mais abrangente. É o escopo comum às todos os
servlets/JSP independente de qual página, requisição ou sessão.
q  Pode-se realmente dizer que é o escopo da aplicação
n  this.getServletContext().setAttribute("nomeAtributo",valor);
n  Usando EL:
q  ${applicationScope.nomeAtributo}
q  <%=application.getAttribute("nomeAtributo")%>

applicationScope
get
get
Cliente 1
Cliente 2
Servlet/JSP A
Servlet/JSP B
n  Uso comum:
q  Armazenamento das informações que devem ser acessadas por
qualquer requisição de qualquer usuário. Por exemplo, lista de UF, lista
de cidades, lista do nome dos professores...

Escopos
n  Observação:
q  Usando EL (Expression Language), você pode não dizer qual o
escopo que está procurando o atributo, por exemplo:
n  ${x}
q  Caso seja feito assim, o container irá procurar o atributo com o nome x
a partir do escopo mais restrito até o mais amplo:
1.  pageScope
2.  requestScope
3.  sessionScope
4.  applicationScope
q  Por exemplo, se existir a variável x no escopo de requisição com o
valor 4 e no escopo de aplicação com valor 6, será exibido 4, pois o
escopo de requisição é mais restrito que o de aplicação

MVC
n  O modelo MVC oferece uma forma de separar as três camadas
principais de uma aplicação web:
q  Visão (responsável pela apresentação ao usuário)
q  Controle (responsável por gerenciar os eventos que notificam o
modelo)
q  Modelo (responsável pelas entidades e regras de negócio)
n  Para desenvolver uma aplicação Java Web no padrão arquitetural
MVC (Model View Controller), basta utilizar:
q  JSPs para o HTML (visão)
q  Servlets para controlar o comportamento da aplicação (controle)
n  Geralmente possuem o sufixo Servlet
q  Classes específicas para realizar acesso a um SGBD (modelo)
n  Geralmente possuem o sufixo DAO (Data Access Object)

MVC
Responsável pela apresentação da
resposta
Para exibir a resposta, acessa os
diversos dados disponibilizados pelo
Controle
Responsável por interpretar a
solicitação do usuário
Manipula os parâmetros, faz o
pedido de dados ao Modelo e,
então, os coloca acessível à
Visão
Responsável pelo acesso ao SGBD
Busca os dados conforme
solicitação
indireta da
Visão e os
entrega ao
Controle

MVC

MVC
n  Algumas são as vantagens da utilização do MVC:
q  Independência entre a camada de Visão e a camada de Modelo
n  O que permite a troca de um sem impacto ao outro
q  Manutenibilidade
n  Ocorre um erro na apresentação dos dados, portanto é em uma JSP
n  Ocorre um erro de fluxo ou comportamento, portanto é em um servlet
n  Ocorre um erro ao acesso ao SGBD, portanto é em uma classe de modelo

Aplicação usando MVC
n  De acordo com o diagrama de classes explicando o MVC, vamos
fazer uma pequena aplicação de exemplo usando o padrão
arquitetural MVC
q  Só será implementada a função de inserção de funcionários

Aplicação usando MVC
n  Será composta de:
q  /web/menuFuncionario.jsp
n  Exibição das ações em funcionários
q  /web/inserirFuncionario.jsp
n  Formulário de inserção do funcionário
q  com.terra.modelo.pojo.Funcionario
n  Armazenará as informações do funcionário
q  com.terra.controle.ManterFuncionarioServlet
n  Lógica de negócio
q  com.terra.modelo.FuncionarioDAO
n  Acesso ao modelo
q  /web/resultInsercao.jsp
n  Resultado da inserção do funcionário

/web/menuFuncionario.jsp
<html>
<body>
<h1>MENU</h1>
<a href="${pageContext.request.contextPath}/inserirFuncionario.jsp">
Inserir
</a> <br />
<a href="${pageContext.request.contextPath}/atualizarFuncionario.jsp">
Atualizar
</a> <br />
<a href="${pageContext.request.contextPath}/excluirFuncionario.jsp">
Excluir
</a> <br />
<a href="${pageContext.request.contextPath}/pesquisarFuncionario.jsp">
Pesquisar
</a> <br />
</body>
</html>

/web/inserirFuncionario.jsp
<html>
<body>
<h1>Inserir Funcionário</h1>
<font color="red"><b>${requestScope.msgErro}</b></font><br />
<form action="${pageContext.request.contextPath}/ManterFuncionario"
method="POST">
Nome: <input type="text" name="nome" size="60" maxlength="60"
value="${param.nome}" /> <br />
Cargo: <input type="text" name="cargo" size="60" maxlength="60"
value="${param.cargo}" /> <br />
<input type="submit" name="evento" value="Inserir" />
</form>
</body>
</html>

com.terra.modelo.pojo.Funcionario
public class Funcionario {
private String nome;
private String cargo;
public Funcionario(){}
public Funcionario(String nome, String cargo) {
this.nome = nome;
this.cargo = cargo;
}
public String getNome(){ return this.nome; }
public void setNome(String nome){ this.nome = nome; }
public String getCargo(){ return this.cargo; }
public void setCargo(String cargo){ this.cargo = cargo; }
}

com.terra.controle.ManterFuncionarioServlet
public class ManterFuncionarioServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
String evento = request.getParameter("evento");
if (evento.equals("Inserir")){
this.inserir(request,response);
}else if (evento.equals("Atualizar")){
this.atualizar(request,response);
}else if (evento.equals("Excluir")){
this.excluir(request,response);
}else if (evento.equals("Pesquisar")){
this.pesquisar(request,response);
}
} //Fim do doPost
//Continua no próximo slide

com.terra.controle.ManterFuncionarioServlet
private void inserir(HttpServletRequest request, HttpServletResponse response)
String nome = request.getParameter("nome");
String cargo = request.getParameter("cargo");
if (nome==null || nome.equals("")){
request.setAttribute("msgErro", "O campo 'nome' é obrigatório.");
request.getRequestDispatcher("/inserirFuncionario.jsp").forward(request, response);
return;
}else if (cargo==null || cargo.equals("")){
request.setAttribute("msgErro", "O campo 'cargo' é obrigatório.");
request.getRequestDispatcher("/inserirFuncionario.jsp").forward(request, response);
return;
}
Funcionario f = new Funcionario(nome,cargo);
FuncionarioDAO.insert(f);
request.setAttribute("f", f);
request.getRequestDispatcher("/resultInsercao.jsp").forward(request, response);
} //Fim do inserir
...
} //Fim da classe servlet

com.terra.modelo.FuncionarioDAO
public class FuncionarioDAO {
public static void insert(Funcionario f){
//Código de inserção do funcionário no SGBD
}
...
}

/web/resultInsercao.jsp
<html>
<body>
<h1>Inserção de Funcionário</h1>
O funcionário <b>${requestScope.f.nome}</b> foi inserido com sucesso
no cargo de <b>${requestScope.f.cargo}</b>.
<br /><br />
<a href="${pageContext.request.contextPath}/menuFuncionario.jsp">
Voltar ao menu
</a> <br />
</body>
</html>

Referência Bibliográfica
n  BASHAM, Brian; SIERRA, Kathy; BATES, Bert. Head First Servlets
and JSP. Sebastopol: O'Reilly, 2008.
n  BASHAM, Brian; SIERRA, Kathy; BATES, Bert. Use a Cabeça.
Servlets & JSP. Rio de Janeiro: Alta Books, 2005.

Apostila Java Web (Servlets e JSPs)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Apostila Java Web (Servlets e JSPs)

Semelhante a Apostila Java Web (Servlets e JSPs) (20)

Mais de Ricardo Terra

Mais de Ricardo Terra (20)

Último

Último (20)

Apostila Java Web (Servlets e JSPs)