Mais JSP,JSTL e MVC

JSP – Mais Recursos
Usando atributos

Quando o atributo é uma String


<%= request.getAttribute(“nome”) %>
Se nome for uma instância de Cliente

<%= request.getAttribute(“nome”) %>
O resultado será:


Cliente@521df6 (método toString da classe)
Precisamos usar:

<%=((Cliente) request.getAttribute(“nome”)).getNome() %>
Usando beans

JavaBeans são objetos escritos de acordo com um determinado
padrão que permite tratá-los como componentes de um framework



Ótimos para separar os detalhes de implementação de uma aplicação de
seus “serviços”
Permitem encapsular dados recebidos de outras partes da aplicação e tornálos disponíveis para alteração e leitura através de uma interface uniforme.
Podem ser usados com JSP para remover grande parte do código
Java de uma página JSP


Maior facilidade de manutenção e depuração
Separação de responsabilidade e reuso de componentes
Usando beans

Sem ações-padrão (com scripting)
<% Cliente c = (Cliente) request.getAttribute(“cliente”); %>
O nome do cliente é
<%= c.getNome() %>

Com ações-padrão (sem scripting)
<jsp:useBean id=“cliente” class=“Cliente” scope=“request” />
Ação-padrão
identificador
Tipo da classe
escopo
O nome do cliente é
<jsp:getProperty name=“cliente” property=“nome” />
Ação-padrão
Identificador
o id do useBean
propriedade
Como incluir um bean

Para que um bean possa ser usado por uma aplicação JSP, ele
deve estar compilado e localizado dentro do CLASSPATH
reconhecido pelo servidor


No subdiretório WEB-INF/classes do seu contexto
Para incluir:
<jsp:useBean id="nome_da_referência“
class="pacote.NomeDaClasse“
scope="page|session|request|application"/>

O atributo de escopo é opcional e indica o tempo de vida do Java
Bean. Se omitido, será page, que o limita à página


Com escopo de request, o bean pode ser recuperado com outra instrução
<jsp:useBean> que esteja em outra página que receber a mesma requisição
(via dispatcher)
Com escopo de session, o bean é recuperável em páginas usadas pelo
mesmo cliente, desde que <%@page> não tenha session=false
Como incluir um bean


O nome do bean (atributo id) comporta-se como uma referência a
um objeto Java
Incluir o tag
<jsp:useBean id="bean" class="bean.HelloBean"
scope="request" />
é o mesmo que incluir na página
<% Object obj = request.getAttribute("bean");
bean.HelloBean bean = null;
if (obj == null) {
bean = new bean.HelloBean();
request.setAttribute("bean", bean);
} else {
bean = (bean.HelloBean) obj;
} %>

O id pode ser usado em scriptlets para usar membros do bean
<% bean.setValor(12); %>
Propriedades


JavaBeans possuem propriedades que podem ser somente leitura
ou leitura-alteração.
O nome da propriedade é sempre derivada do nome do método
getXXX():
public class Bean {
private String mensagem;
public void setTexto(String x) {
mensagem = x;
}
public String getTexto() {
return mensagem;
}
}

O bean acima tem uma propriedade (RW) chamada texto
Propriedades

Páginas JSP podem ler ou alterar propriedades de um
bean usando os tags
<jsp:setProperty name="bean" property="propriedade"
value="valor"/>
que equivale a <%
bean.setPropriedade(valor); %> e
<jsp:getProperty name="bean" property="propriedade"/>


que equivale a <%=bean.getPropriedade() %>
Observe que o nome do bean é passado através do
atributo name, que corresponde ao atributo id em
<jsp:useBean>
Valores são convertidos de e para String automaticamente
Propriedades

Parâmetros HTTP com mesmo nome que as propriedades têm
valores passados automaticamente com <jsp:setProperty>

Se não, pode-se usar atributo param de <jsp:setProperty>
No HTML: <form action ...
nome : <input type=“text” name=“username”> ...
No JSP:
<jsp:setProperty name=“pessoa” property=“nome” param=“usename” >


As tags do bean convertem as propriedades primitivas
automaticamente


<jsp:setProperty ... property="*"/> lê todos os parâmetros
Ex: atributo do bean: int ID ( int getID() e void setID(int id) )
ID é <jsp:setProperty nome=“pessoa” property=“ID” >
Conversão automática não funciona se usar scripts
value=“<%= request.getParameter(“ID”) %>”
Inicialização de beans

A tag <jsp:useBean> simplesmente cria um bean chamando seu construtor. Para
inicializá-lo, é preciso chamar seus métodos setXXX() ou usar <jsp:setProperty>
após a definição
<jsp:useBean id="bean" class="bean.HelloBean" />
<jsp:setProperty name="bean" property="prop" value="valor"/>


Se um bean já existe, porém, geralmente não se deseja inicializá-lo.
Neste caso, a inicialização pode ser feita dentro do marcador <jsp:useBean> e o
sistema só a executará se o bean for novo (sejá existir, o código será ignorado)
<jsp:useBean id="bean" class="bean.HelloBean" >
<jsp:setProperty name="bean" property="prop" value="valor"/>
</jsp:useBean>

ou
<jsp:useBean id="bean" class="bean.HelloBean" >
<% bean.setProp(valor); %>
</jsp:useBean>
SEM
BARRA
Condicionais e iterações

Não é possível usar beans para remover de páginas Web o código
Java de expressões condicionais e iterações como for do-while e
while


Para isto, não há tags padrão. É preciso usar Taglibs (JSTL)
Beans, porém, podem ser usados dentro de iterações e
condicionais, e ter seus valores alterados a cada repetição ou
condição
<jsp:useBean id="mBean" class="MessageBean" scope="session" />
<% MessageBean[] messages = MessagesCollection.getAll();
for (int i = messages.length -1; i >= 0; i--) {
mBean = messages[i];
%>
<tr><td><jsp:getProperty name="mBean"
property="time"/></td>
<td><%=mBean.getHost()%></td>
<td><%=mBean.getMessage()%></td></tr>
<% } %>
(MessageBean tem propriedades: time, host, message)
Matando beans

Beans são sempre gravados em algum objeto de
escopo: page, request, session ou application


Persistem até que o escopo termine ou expirem devido
a um timeout (no caso de sessões)
Para se livrar de beans persistentes, use os
métodos removeAttribute(), disponíveis para cada
objeto de escopo:
session.removeAttribute(bean);
application.removeAttribute(bean);
request.removeAttribute(bean);
Polimorfismo em Beans

Uso de type
<jsp:useBean id=“pessoa” type=“Pessoa” class=“Cliente” scope = “page” />

Equivale a
Pessoa pessoa = null;
If (pessoa = null) {
pessoa = new Cliente();
}

Usando
type sem class
Se type for usado sem uma classe, o bean já deve existir.
<jsp:useBean id=“pessoa” type=“Pessoa” scope = “page” />
 Se
Se class
o atributo
existir,ou
funciona
forpessoa
usadajá(com
sem type), a classe NÃO deve
deve
possuir construtor padrão público.

Seser
nãoabstrata
existe dá eerro
Java.lang.InstantiationException
Composite View

Páginas Web complexas (ex: portais) frequentemente são divididas
em partes independentes




Algumas partes são altamente dinâmicas, mudando frequentemente até na
estrutura interna
Outras partes mudam apenas o conteúdo
Outras partes sequer mudam o conteúdo
Gerar uma página dessas usando apenas um template é
indesejável
Composite View

O padrão de projeto Composite View sugere que tais páginas
sejam separadas em blocos menores, que possam
ser alterados individualmente e
compostos durante
a publicação
(deployment)
ou exibição

JSP oferece duas
soluções para
obter esse efeito


Usando inclusão estática (no momento da compilação do servlet)
Usando inclusão dinâmica (no momento da requisição)
Inclusão estática


Mais eficiente: fragmentos são incluídos em único servlet
Indicada quando estrutura não muda com frequência (conteúdo pode mudar)



Menus, Logotipos e Avisos de copyright
Telas com mini formulários de busca
Implementada com <%@ include file="fragmento" %>
<!-- Menu superior -->
<table>
<tr><td><%@ include file="menu.jsp" %></td></tr>
</table>
<!-- Fim do menu superior -->
Fragmento menu.jsp
<a href="link1">Item 1</a></td>
<td><a href="link2">Item 2</a></td>
<a href="link3">Item 3</a>
Se tela incluída contiver novos fragmentos, eles serão processados recursivamente
Inclusão dinâmica


Mais lento: fragmentos não são incluídos no servlet mas
carregados no momento da requisição
Indicada para blocos cuja estrutura muda com freqüência



Bloco central ou notícias de um portal
Implementada com <jsp:include page="fragmento"/>
Pode-se passar parâmetros em tempo de execução usando
<jsp:param> no seu interior
<!-- Texto principal -->
<table>
<tr><td>
<jsp:include page="texto.jsp">
<jsp:param name="data" value="<%=new Date() %>">
</jsp:include>
</td></tr> </table>
<!-- Fim do texto principal -->
Repasse de requisições

Uma requisição pode ser repassada de uma página JSP para outra
página ou servlet usando RequestDispatcher
<% RequestDispatcher rd =
request.getRequestDispatcher("url");
rd.forward(request, response);
%>


O mesmo efeito é possível sem usar scriptlets com a ação padrão
<jsp:forward>
Assim como <jsp:include>, pode incluir parâmetros recuperáveis na
página que receber a requisição usando request.getParameter() ou
<jsp:getProperty> se houver bean
<% if (nome != null) { %>
<jsp:forward page="segunda.jsp">
<jsp:param name="nome" value="<%=nome %>">
</jsp:forward>
<% } %>
JSP – JSTL
JSP Standard Tag Library (JSTL)

Esforço de padronização do JCP: JSR-152


Oferece dois recursos



Baseado no Jakarta Taglibs (porém bem menor)
Conjunto padrão de tags básicos (Core, XML, banco de dados e
internacionalização)
Linguagem de expressões do JSP 1.3
Oferece mais controle ao autor de páginas sem necessariamente
aumentar a complexidade



Controle sobre dados sem precisar escrever scripts
Estimula a separação da apresentação e lógica
Estimula o investimento em soluções MVC
Como usar JSTL



1. Fazer o download da última versão do site da Sun
2. Copiar os JARs das bibliotecas desejadas para o diretório WEBINF/lib/ da sua aplicação Web
3. Incluir em cada página que usa os tags:
<%@ taglib uri="uri_da_taglib"
prefix="prefixo" %>

4. Usar os tags da biblioteca com o prefixo definido no passo
anterior
<prefixo:nomeTag atributo="..."> ...
</prefixo:nomeTag>
Cinco bibliotecas de tags

Core library: tags para condicionais, iterações, urls, ...
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

Exemplo: <c:if test="..." ... >...</c:if>

XML library: tags para processamento XML
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>

Exemplo: <x:parse>...</x:parse>

Internationalization library
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

Exemplo: <fmt:message key="..." />

SQL library
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>

Exemplo: <sql:update>...</sql:update>

Function library
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

Exemplo: ${fn:length(...)}
Linguagem de expressões (EL)

Permite embutir em atributos expressões dentro de delimitadores
${...}




Em vez de request.getAttribute("nome")
${nome}
Em vez de bean.getPessoa().getNome()
${bean.pessoa.nome}
Suporta operadores aritméticos, relacionais e binários
Converte tipos automaticamente
<tag item="${request.valorNumerico}" />

Valores default
<tag value="${abc.def}" default="todos" />
Linguagem de expressões (EL)

A primeira variável na expressão é um OBJETO IMPLÍCITO ou um
ATRIBUTO


$ { primeiro.segundo)
Objetos:






pageScope, requestScope, sessioScope,applicationScope
param, paramValues
header, headerValues
cookie
initParam
pageConext


Único que não é mapeamento (Map); é um bean
Atributo:

Em qualquer um dos escopos: page, request, session, application
Linguagem de expressões (EL)


Se a expressão possuir um avariável seguida por um ponto, a variável a
esquerda TEM QUE ser um MAP ou um BEAN
O que estiver do lado direito do ponto TEM QUE ser uma chave de MAP ou uma
propriedade do BEAN


Operador [] é similar ao ponto, mas melhor


Deve seguir regras normais do Java para nomenclatura dos identificadores
${pessoa[“nome“]} idem a ${pessoa.nome}
Se pessoa for List ou Array?


Só funciona com [] : ${listMusic[“Take“] } ou ${listMusic[0]}
O que vem dentro dos colchetes é uma String:



Chave Map
Propriedade Bean
Índice de um List ou Array
Principais ações

Suporte à impressão da linguagem expressões


<c:out value="${pessoa.nome}" />
Expressões condicionais

<c:if test="${pessoa.idade >= 18}">
<a href="adultos.html">Entrar</a>
</c:if>

<c:choose>
<c:when test="${dia.hora == 13}">
<c:out value="${mensagemEspecial}" />
</c:when>
<c:otherwise>
<c:out value="${mensagemPadrao}" />
</c:otherwise>
</c:choose>

Iteração

<c:forEach items="${pessoas}" var="p" varStatus="s">
<c:out value="${s.count}"/>. <c:out value="${p}"/>
</c:forEach>
PageContext

Objeto que permite a tag acessar informações
sobre o contexto da aplicação para leitura de
valores de formularios (request), variaveis de
sessao e gerar conteudo de saida (response)
PageContext





Acesso facil a parametros de entrada vindos de
get/post, variaveis de sessoes e cookies
$session:minhavariaveldesessao
$cookie:meucookie
$param:email
$param:nome
Dados vindos de
forms
set

Atribui valor a uma variável









Sintaxe 1
<c:set value="valor"
var=”nomeVariavel”
[scope=”{page|request|session|application}”] />
Sintaxe 2
<c:set var=” nomeVariavel”
[scope=”{page|request|session|application}”]>
Corpo do Conteúdo
</c:set>
Exemplo







<c:set var="nome"
value="${param.nome}" />
Olá ${nome}
<c:set var="nome">
${param.nome}
</c:set>
Olá ${nome}
remove

Remove uma variável



<c:remove var="nomeVar" [scope="{page|...}"]/>
Se o escopo for omitido a variável é removida do
escopo mais interno
Exemplo

<c:remove var="nome"
scope="page" />
out







Avalia e exibe uma expressão
Sintaxe
<c:out value="valor”
[escapeXml="{true|false}"]
[default="valorDefault"] />
Exemplo
Olá <c:out value="${nome}" />
if








Avalia o conteúdo se a condição for verdadeira
<c:if test="condição">
Conteúdo
</c:if>
Exemplo
<c:if test="${usuario.visitas eq 1}">
Esta é a sua Primeira Visita.
</c:if>
choose ... when ... otherwise

Avalia várias condições

semelhante a um if aninhado de Java
<c:choose>
<c:when test="condição">
</c:when>
...
<c:otherwise>
</c:otherwise>
</c:choose>
Exemplo
Situação Parcial:
<c:choose>
<c:when test="${nota lt 30}">
Reprovado
</c:when>
<c:when test="${nota lt 70}">
Recuperação
</c:when>
<c:otherwise>
Aprovado
</c:othewise>
</c:choose>

Exemplo : choose = if ... else
Situação Final:
<c:choose>
<c:when test="${nota lt 70}">
Reprovado
</c:when>

<c:otherwise>
Aprovado
</c:otherwise>
</c:choose>
forEach (1/2)
Percorre uma coleção (lista, array ou
mapeamento) de objetos
<c:forEach var=“variavel” itens=“colecao”
varStatus=“variavelStatus” />
conteúdo
</c:forEach>

Exemplo forEach
Exemplo:
<c:forEach var=“livro” itens=“${livros}”
varStatus=“status” />
${status.count} – ${livro.titulo}
</c:forEach>

1 - Java Como Programar
2 - Java Servlets
3 - HTML & XHTML
forEach (2/2)
Laço com início e fim
<c:forEach var=“variavel” begin=“inicio” end=“fim”
step=“passo” varStatus=“variavelStatus” />
conteúdo
</c:forEach>

Construindo uma Tabela
<%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head><title>Função Quadrado</title></head>
<body>
<table border="1">
<tr><th>x</th><th>x^2</th></tr>
<c:forEach var="counter" begin="1" end="10">
<tr>
<td>${counter}</td>
<td>${counter*counter}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
forTokens
Semelhante ao forEach mas os elementos estão
em um único String.
<c:forTokens items="stringOfTokens"
delims="delimitadores" [var=“nomeVar"]
[varStatus=“nomeVarStatus"]
[begin=“inicio"] [end=“fim"] [step=“passo"]>
Conteúdo
</c:forTokens>

Exemplo

Imprimir as letras do string "a,b/c,d/e,f" onde , e /
são delimitadores
<c:forTokens items="a,b/c,d/e,f" delims=",/"
var=“letra">
<p>${letra}</p>
</c:forTokens>
Arquitetura de Sistemas
Web
Modelo 2 Camadas
Modelo 2 Camadas
•Camada de Apresentação com Regras de Negócio Juntas.
•Camada de Persistência.
Problemas para o usuário, que não tem os programas funcionando
como deveriam; Problemas para a equipe de desenvolvimento que
não tem o seu trabalho reconhecido e, normalmente, tem que
trabalhar apenas "apagando incêndios"; e Problemas para a
Administração/Gerência da rede que não consegue gerar os
resultados esperados pela Administração da empresa, apesar dos
elevados valores já investidos.
Maior TCO – Custo Total de Propriedade
Modelo 3 Camadas
Modelo 3 Camadas
Modelo e códigos construídos para representar as
camadas.
Os servidores não precisam estar necessariamente
em máquinas diferentes, podem estar na mesma
máquina. Porem questões de performance são
relevantes.
• Camada de Apresentação
• Camada de Negócios
• Camada de Persistência
Modelo 3 Camadas c/ MVC
APRESENTAÇÃO
NEGÓCIO OU LÓGICA
PERSISTÊNCIA
(INTEGRAÇÃO)
Helper
classes
NAVEGADOR WEB
CLIENTE
C
V
M
CLIENTE - SERVIDOR
SERVIDOR WEB
SGDB
SERVIDOR
Modelo 4 Camadas
Modelo 4 Camadas
CLIENTE
(APRESENTAÇÃO)
GERENCIA DE
APRESENTAÇÃO
NEGÓCIO
PERSISTÊNCIA
SERVIDOR
APLICAÇÃO
NAVEGADOR WEB
SERVIDOR WEB
SGDB
EJB in
MVC
C
V
CLIENTE
CLIENTE - SERVIDOR
M
CLIENTE - SERVIDOR
SERVIDOR
J2EE - 4 TIER
MVC - FLUXOS
MVC