Seminário JavaServer Faces
Paulo Venancio Lopes
Daniel Sguillaro
Tópicos
Introdução
● Aplicação Web
● Tecnologia Java Servlet
● Custom Tags
● JavaServer Pages
● JavaServer Faces
●
Aplicação Web
Aplicação web é a extensão dinâmica da web ou
application server, e são divididas em dois tipos:
● Presentation-oriented: Cria páginas interativas contendo
HTML, XML, e outros, e conteúdos dinâmicos em
resposta a uma requisição.
● Service-oriented: Implementa a parte final de um web
service. Aplicações presentation-oriented são
frequentemente clientes de uma aplicação serviceoriented web.
Aplicação web (continuação)
Interação entre um cliente e uma aplicação web:
Aplicação web (continuação)
Servlets: são classes java que dinamicamente
processam requisições e constroem respostas.
●
Paginas JSP: são documentos textos que são
executados como servlets e são apropriados para
geração de markup language tais com HTML,
SVG, WML, e XML.
●
Aplicação web (continuação)
Relação entre as tecnologias de aplicação java web
Ciclo de vida da aplicação Web
●
Desenvolvimento do código do componente
web.
● Desenvolvimento do descritor de implantação.
● Compilar componentes da aplicação web e
classe auxilares.
● Opcionalmente empacotar a aplicação em uma
unidade de implantação.
● Implantar a aplicação em um web container.
● Acessar a URL que referência a aplicação web.
●
Módulo Web
Empacotando Módulos Web
Um módulo web pode ser empacotado num
arquivo
*.war que é simplesmente um arquivo *.jar
renomeado,
para ser implantado em um web container. Mas
pode se
implantar o módulo diretamente.
Implantando Módulo Web
Pode-se implantar o módulo de duas forma:
1. Copiando o módulo web para o diretório de
implantação do web container.
2. Copiando o pacote do módulo web (arquivo
*.war) no diretório de implantação do web
container.
Obs1: Pode-se ainda no caso do Tomcat configurar o descritor
server.xml para que identifique o módulo web.
Obs2: Um context root identifica a aplicação web num JEE server
(ex: http://host:port/context_root/alias).
Tecnologia Java Servlet
Um servlet é uma classe java que extende as
capacidades do servidor que acessam aplicações
num modelo de programa requisição e resposta.
Todos os servlets podem responder qualquer tipo
de requisição, para cada aplicação a tecnologia
java servlet define classes servlet especificas para
HTTP.
Tecnologia Java Servlet (cont.)
Os pacotes javax.servlet e javax.sservlet.http
provem interfaces e classes para escrever
servlets. Todos servlets devem implementar a
interface Servlet, a qual define os métodos de
ciclo de vida
Ciclo de Vida do Servlet
O ciclo de vida de um servlet é controlado pelo
container no qual o servlet tenha sido implantado.
Quando uma requisição é mapeada para o
servlet, o container performa os seguintes
passos.
1. Se uma instância do servlet não existe, o web
container :
a. Carrega a classe do servlet.
Ciclo de Vida do Servlet (cont.)
b. Cria uma instância da classe do servlet.
c. Inicializa a instância do servlet
chamando o método init.
2. Invoca o método service, passando os
objetos request e response .
Obs: Se o container necessitar remover o
servlet , ele finaliza o servlet chamando o
método destroy.
Custom Tags numa página JSP
É o elemento da linguagem JSP definida por um Usuário.
<%@ taglib uri="/tlt" prefix="tlt" %>
<html>
<body bgcolor="white">
<tlt:iterator var="departmentName"
type="java.lang.String"
group="${myorg.department
Names}">
</body>
</html>
Tecnologia JavaServer Pages
JavaServer Pages (JSP) permite fácil criação de
conteúdos web sendo ambos componentes
dinâmicos e estáticos.
Página JSP é um documento texto que contém
dois tipos de textos: dados estáticos (HTML, SVG,
WML, XML, e outros), e elementos JSP, para
construir conteúdos dinâmicos (recomenda-se a
extensão *.jsp).
Ciclo de vida da Pagina JSP
São determinadas pela tecnologia Java Servlet.
Quando um request é mapeado para uma página
JSP, o web container primeiro checa se o servlet
da pagina JSP é mais velha do que a pagina JSP.
Se for o web container traduz a pagina JSP para
uma classe servlet e a compila. Durante o
desenvolvimento , uma das vantagens das
paginas JSP sobre o servlet é que o processo de
construção é feito automáticamente
Ciclo de vida da Pagina JSP (Cont.)
Tradução e compilação
Durante a fase de tradução cada tipo de dado na
pagina JSP é tratado diferentemente. Dados
estáticos são transformados em código que
emitirão dados para o stream de resposta.
●
Ciclo de vida da Pagina JSP (Cont.)
Os elementos JSP são tratados como a seguir:
Diretivas são usadas para controlar como o
web container traduz e executa a pagina JSP.
Elementos scripts são inseridos no servlet da
pagina JSP.
Ciclo de vida da Pagina JSP (Cont.)
Expressões Expression Language são
passadas comparâmetros para as chamadas
para o JSP expressionevaluator.
●
jsp:[set|get]Property elemento é convertido
numa chamada para método no componente
JavaBeans.
●
Ciclo de vida da Pagina JSP (Cont.)
•
•
•
O jsp:plugin elemento é convertido num
específico browser markup para ativação num
applet.
Custom tags são convertidas em chamadas
para o tag handler que implementa a custom
tag.
jsp:[include|forward] elemento é convertido
numa invocação da API Java Servlet.
Scripts nas paginas JSP
Elementos scripts são usados tipicamente para
criar e acessar objetos, definir métodos, e
gerenciar fluxo de controle.
Muitas tarefas que usam scripts podem ser
eliminadas usando custom tag library.
Scripts nas paginas JSP (cont.)
<!DOCTYPE HTML PUBLIC
"-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>JSP Expressions</TITLE>
<META NAME="author" CONTENT="Marty Hall">
<META NAME="keywords"
CONTENT="JSP,expressions,JavaServer,Pages,servlets">
<META NAME="description"
CONTENT="A quick example of JSP expressions.">
<LINK REL=STYLESHEET
HREF="JSP-Styles.css"
TYPE="text/css">
</HEAD>
Scripts nas paginas JSP (cont.)
<BODY>
<H2>JSP Expressions</H2>
<UL>
<LI>Current time: <%= new java.util.Date() %>
<LI>Your hostname: <%= request.getRemoteHost() %>
<LI>Your session ID: <%= session.getId() %>
<LI>The <CODE>testParam</CODE> form parameter:
<%= request.getParameter("testParam") %>
</UL>
</BODY>
</HTML>
Sintaxe básica - JSP
Texto HTML
–
–
<H1>Blah</H1>
Passado para o cliente. Transformado em código servlet:
Comentários HTML
–
–
out.print("<H1>Blah</H1>");
<!-- Comentário -->
Mesmo que um outro HTML: Passado para o cliente
Comentário JSP
–
–
<%-- Comment --%>
Não envia para o cliente
Tipos de elementos scripts
Expressões
–
–
Scriptlets
–
–
Formato: <%= expression %>
Avaliada e inserida na saída do servlet:
out.print(expression)
Formato: <% code %>
Incorporado ao método do servlet _jspService
Declarações
–
–
Format: <%! code %>
Inserido no corpo de uma classe servlet, fora de
qualquer método.
Expressões JSP
Formato
–
Result
–
–
Expressão avaliada, convertida para String, e colocada na
página HTML no local onde ocorre na página JSP.
Expressão colocada no método _jspService dentro do
out.print
Exemplos
–
–
<%= Java Expression %>
Data: <%= new java.util.Date() %>
Hostname: <%= request.getRemoteHost() %>
Sintaxe XML
–
–
<jsp:expression>Expressão Java</jsp:expression>
Versão XML não suportada pelo TomCat 3. Deste JSP 1.2 os
Correspondência JSP/Servlet
JSP Original
<H1>A Random Number</H1>
<%= Math.random() %>
Código do servlet
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
HttpSession session = request.getSession(true);
JspWriter out = response.getWriter();
out.println("<H1>A Random Number</H1>");
out.println(Math.random());
...
}
JavaServer Faces (JSF)
Introdução
Ciclo de vida
Usando JSF em paginas JSP
Usando tags JSF
Usando dados localizados
Conversores e validadores.
Backing Bean
JSF – Introdução
É um framework do lado servidor baseado em
aplicações WEB.
JSF – Introdução (cont.)
JSF contém:
•
•
•
•
•
•
JavaBeans
Event Listener
Páginas JSP
Classes auxiliares do lado do servidor
Biblioteca de componentes UI
Biblioteca de event handlers, validators, e etc...
JSF – Introdução (cont.)
Backing Beans
Arquivo de configuração da aplicação
JSF – Ciclo de vida
JSF – Usando JSF em páginas JSP
Definir entrada para JSF HTML render kit
Definir entrada para JSF Core tag lib
<%@ taglib uri="http://java.sun.com/jsf/html"
prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core"
prefix="f" %>
Usando JSF em páginas JSP (cont.)
As tags suportam os seguintes atributos:
•
Id: Único identificador do componente.
•
Imediate: Se true, indica que qualquer evento,
validação, e conversão associado a um
componente será aplicada na fase request
value ou nas próximas fases.
Usando JSF em páginas JSP (cont.)
Style: Especifica um cascading style sheet
(css) para a tag.
styleClass: Especifica um css styleshet que
contém definições de estilo.
Value: Identifica uma fonte de dados externa e
associa seu valor a ele.
Usando JSF em páginas JSP (cont.)
Binding: identifica um bean property e associa
o componente instanciado por ele.
Usando dados localizados
Textos estáticos(labels, textos
alternativos,etc)
Mensagens de erro
Dados dinâmicos
Para carregar dados localizados temos que:
1. Registrar o resource bundle
2. Carregar o resource bundle
<f:loadBundle var=“b1” basename=“m.mens” />
Conversores e Validadores (cont.)
Para registrar conversores padrões:
• Associar value do componente para o backing
bean do mesmo tipo.
• Referenciar o converter pela classe ou pelo
atributo ID da tag do componente.
• Usar tag converterId ou tag binding aninhado
no componente.
Conversores e Validadores (cont.)
Via backing bean
Integer age = 0;
public Integer getAge(){ return age;}
public void setAge(Integer age) {this.age =
age;}
Via atributo converter
<h:inputText converter="javax.faces.convert.I
ntegerConverter" />
Conversores e Validadores (cont.)
BigDecimalConverter, BigIntegerConverter,
BooleanConverter,
ByteConverter,CharacterConverter
DateTimeConverter, DoubleConverter,
FloatConverter,
IntegerConverter,
LongConverter,NumberConverter,
ShortConverte
Conversores e Validadores (cont.)
DataTimeConverter
<h:outputText value="#{cashier.shipDate}">
<f:convertDateTime dateStyle="full" />
</h:outputText>
NumberConverter
<h:outputText value="#{cart.total}" >
<f:convertNumber type="currency"
</h:outputText>
Conversores e Validadores (cont.)
Registrando value-change listener
<h:inputText value="#{c.name}">
<f:valueChangeListener
type="l.NameChanged" /> </h:inputText>
Registrando action listener no componente
<h:commandLink action="bookstore">
<f:actionListener
type="listeners.LocaleChange" />
</h:commandLink>
Conversores e Validadores (cont.)
Validadores padrão
DoubleRangeValidator
LengthValidator
LongRangeValidator
Exemplo:
<h:inputText id="q" size="4"
value="#{item.quantity}" required=“true”>
<f:validateLongRange minimum="1"/>
</h:inputText>
<h:message for="quantity"/>
Backing Bean
Suas propriedades devem referenciar:
Um valor do componente
Uma instância do componente
Uma instância do converter
Uma instância do listener
Uma instância do validator
Backing Bean (cont.)
private Integer userNumber = null;
public void setUserNumber(Integer
user_number)
{ userNumber = user_number; }
public Integer getUserNumber()
{ return userNumber; }
public String getResponse() { ... }
Backing Bean (cont.)
Configuração:
<managed-bean>
<managed-beanname>UserNumberBean</managed-beanname>
<managedbean-class>g.UserNumBean</managed-beanclass> <managed-beanscope>session</managed-bean-scope>
</managed-bean>
Fórmula p/ usar JSF
1. Criar um bean representando os dados de
um formulário
2. Usar as tags do JSF para criar o formulário
3. Especificar na tag h:commandButton um
método a ser chamado quando o formulário for
enviado (ActionController)
Fórmula p/ usar JSF (cont.)
4.Criar o Action Controller - suas responsabilidades
são:
Ler os dados do formulário
●Chamar a lógica de negócio
●Popular os beans que contém os resultados
●Devolver uma condição
●
Fórmula p/ usar JSF (cont.)
5. Declarar o form bean e as regras de
navegação no descritor faces-config.xml
6. Criar as páginas JSP para cada condição
devolvida
Exemplo
Formulário de cadastro, onde os dados fornecidos
pelo usuário farão com que o JSF tome a de qual
pagina será mostrada a seguir.
Exemplo (cont.)
<%@ taglib uri="http://java.sun.com/jsf/core"
prefix="f" %>
<%@ taglib uri="http://java.sun.com/jsf/html"
prefix="h" %>
<f:view>
…
<h:form>
Nome: <h:inputText value=“#{bean.nome”/><BR>
Exemplo (cont.)
Sobrenome: <h:inputText
value=“#{bean.sobrenome}”/><BR> ...
<h:commandButton
value=“Cadastrar Dados"
action="#{bean.cadastrar}"/>
</h:form>…
</f:view>
Exemplo (cont.)
Criando um action controller
package exemplo;
public class CadastroBean {
private String nome = “”;
private String sobrenome = “”;
// getters e setters
...
Exemplo (continuação)
public String cadastrar() {
if (nome.trim().equals(“”) ||
sobrenome.trim().equals(“”) ) {
return(“rejeitado");
} else {
return(“aceito");
}
}
}
Exemplo (cont.)
Declarando o action controller
<faces-config>
<managed-bean>
<managed-bean-name>
bean
</managed-bean-name>
<managed-bean-class>
exemplo.CadastroBean
</managed-bean-class>
Exemplo (cont.)
<managed-bean-scope>
request
</managed-bean-scope>
</managed-bean>
…
</faces-config>
Exemplo
Especificando regras de navegação
<faces-config>
<navigation-rule>
<from-view-id>/cadastro.jsp</from-view-id>
<navigation-case>
<from-outcome>
aceito
</from-outcome>
<to-view-id>
Exemplo
(continuação)
/WEB-INF/result/aceito.jsp
</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>
rejeitado
</from-outcome>
<to-view-id>
/WEB-INF/results/rejeitado.jsp
Exemplo
(continuação)
</to-view-id>
</navigation-case>
</navigation-rule>
…
</faces-config>
Exemplo (cont.)
<HTML>
<HEAD>…</HEAD>
<BODY>
Cadastro do usuário ${bean.nome}
${bean.sobrenome} aceito. Parabéns.
</BODY></HTML>
Exemplo (cont.)
<HTML>
<HEAD>…</HEAD>
<BODY>
Cadastro rejeitado.<br/>
<A HREF=“cadastro.faces">Tente de novo</A>.
</BODY></HTML>
Referências
•
•
•
•
Tutorial JEE da Sun:
http://java.sun.com/javaee/5/docs/tutorial/doc/
www.coreservlets.com
Geary, David; Horstmann Cay - Core
JavaServer Faces, 2004
Bergsten, Hans; JavaServer Faces, O’Reilly,
2004
Download
