seminário javaserver 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.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. ●


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

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 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.IntegerConverter" />


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ã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 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

seminário javaserver faces

Documents