Java Server Faces

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 service-
oriented web.
Aplicação web (continuação)
Interação entre um cliente e uma aplicação web:
●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.
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.
●
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.
●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.
• 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:
 out.print("<H1>Blah</H1>");
 Comentários HTML
– 
– 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
– Formato: <%= expression %>
– Avaliada e inserida na saída do servlet:
out.print(expression)
 Scriptlets
– 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
– <%= Java Expression %>
 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
– 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.
 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.
 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.
 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" />
 BigDecimalConverter, BigIntegerConverter,
BooleanConverter,
ByteConverter,CharacterConverter
DateTimeConverter, DoubleConverter,
FloatConverter,
IntegerConverter,
LongConverter,NumberConverter,
ShortConverte
 DataTimeConverter
<h:outputText value="#{cashier.shipDate}">
<f:convertDateTime dateStyle="full" />
</h:outputText>
 NumberConverter
<h:outputText value="#{cart.total}" >
<f:convertNumber type="currency"
</h:outputText>
 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>
 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-bean-
name>UserNumberBean</managed-bean-
name> <managed-
bean-class>g.UserNumBean</managed-bean-
class> <managed-bean-
scope>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

Java Server Faces

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java Server Faces

Enviado por

Direitos autorais:

Formatos disponíveis

Seminário JavaServer Faces

 Paulo Venancio Lopes

● Tecnologia Java Servlet

Aplicação web é a extensão dinâmica da web ou

HTML, XML, e outros, e conteúdos dinâmicos em

service. Aplicações presentation-oriented são

●Servlets: são classes java que dinamicamente

●Paginas JSP: são documentos textos que são

● Desenvolvimento do código do componente

● Compilar componentes da aplicação web e

● Acessar a URL que referência a aplicação web.

Um módulo web pode ser empacotado num

*.war que é simplesmente um arquivo *.jar

para ser implantado em um web container. Mas

implantar o módulo diretamente.

Pode-se implantar o módulo de duas forma:

2. Copiando o pacote do módulo web (arquivo

Os pacotes javax.servlet e javax.sservlet.http

O ciclo de vida de um servlet é controlado pelo

1. Se uma instância do servlet não existe, o web

b. Cria uma instância da classe do servlet.

Obs: Se o container necessitar remover o

É o elemento da linguagem JSP definida por um Usuário.

<%@ taglib uri="/tlt" prefix="tlt" %>

São determinadas pela tecnologia Java Servlet.

Durante a fase de tradução cada tipo de dado na

Os elementos JSP são tratados como a seguir:

 Diretivas são usadas para controlar como o

 Elementos scripts são inseridos no servlet da

●Expressões Expression Language são

●jsp:[set|get]Property elemento é convertido

• O jsp:plugin elemento é convertido num

Elementos scripts são usados tipicamente para

Muitas tarefas que usam scripts podem ser

É um framework do lado servidor baseado em

 Definir entrada para JSF HTML render kit

<%@ taglib uri="http://java.sun.com/jsf/html"

<%@ taglib uri="http://java.sun.com/jsf/core"

As tags suportam os seguintes atributos:

• Id: Único identificador do componente.

• Imediate: Se true, indica que qualquer evento,

 Style: Especifica um cascading style sheet

 styleClass: Especifica um css styleshet que

 Value: Identifica uma fonte de dados externa e

 Binding: identifica um bean property e associa

 Textos estáticos(labels, textos

Para registrar conversores padrões:

 Via backing bean

 Via atributo converter

 Registrando value-change listener

Suas propriedades devem referenciar:

private Integer userNumber = null;

public void setUserNumber(Integer

public Integer getUserNumber()

1. Criar um bean representando os dados de

2. Usar as tags do JSF para criar o formulário

3. Especificar na tag h:commandButton um

4.Criar o Action Controller - suas responsabilidades

●Ler os dados do formulário

●Popular os beans que contém os resultados

●Devolver uma condição

5. Declarar o form bean e as regras de

6. Criar as páginas JSP para cada condição

Formulário de cadastro, onde os dados fornecidos

.war que é simplesmente um arquivo .jar