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:
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.httpprovem 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.departmentNames}">
</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 paracriar e acessar objetos, definir métodos, egerenciar fluxo de controle.
Muitas tarefas que usam scripts podem sereliminadas 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– <!-- 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– 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
servidores não eram obrigados a suportá-la.
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 emaplicaçõ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âmicosPara carregar dados localizados temos que:1. Registrar o resource bundle2. 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.IntegerConverter" />
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ãoDoubleRangeValidator
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 fornecidospelo usuário farão com que o JSF tome a de qualpagina 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