Java Server Faces

Basicamente o JSF permite que o desenvolvedor possa utilizar componentes pré-definidos, como caixas de texto, sliders e etc, capturar eventos para esses componentes, validar essa entrada e manter o estado deles.

O JSF dispõe dos principais recursos:

v

• Componentes
• Listeners
• Validadores
• Conversores
• Navegabilidade
• Backbeans

Exemplo de Componentes do JSF

As aplicações em JSF

Um conjunto de páginas JSP para tratar as requisições dos componentes ( Embora outra tecnologia possa ser utilizada )

Os Back Beans: componentes JavaBeans que definem as propriedades e funções para os componentes de interface.

Um descritor de aplicação: web.xml

Objetos criados pelo desenvolvedor, além daqueles que o JSF dispõe, que pode ser novos componentes, eventos, conversores ou listeners de eventos.

Os objetos são representados na página JSP por tags JSF.

Exemplo:
<h:inputSecret value="#{form.passwd}" redisplay="true"/>   irá gerar   


Criando uma aplicação JSF

1. Mapear uma instância de um FaceServlet que será responsável por receber as requisições WEB e inicializar os recursos.

Esquema do FaceServlet

2. Criar a página usando os componentes de interface e as tags do Java Server Faces.



Para utilizar JSF nas páginas JSP você precisa importar duas bibliotecas de tags do JSF, deste modo:

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

As tags de HTML têm um namespace h, e as tags de Core têm um namespace f.


View é o nome que se dá a árvore de componentes contidos em uma página JSF.

Uma aplicaçãozinha JSF básica.

<!-- isso é um comentário, aqui importamos as tagslibs necessárias, que são 2, a de html e a de core -->
<% taglib uri="http://java.sun.com/jsf/html" %> <!-- namespace h -->
<% taglib uri="http://java.sun.com/jsf/core" %> <!-- namespace f -->


<!-- aqui definimos a view em que ficará um formulário -->
<f:view>
<h:form id="formulario1">


<!-- aqui colocamos nosso primeiro componente, que é uma label -->


<b> Diga um número entre </b>


<h:outputText lang="en_US" value="#{BeanQueControlaOComponente.menorValor}" />


e


<h:outputBean lang="en_US" value="#BeanQueControlaOComponente.maiorValor}" />


<hr/>


<!-- aqui entra a caixinha para o usuário colocar um número -->


<h: inputText  id="numeroDoUsuario" label="Número do Usuário" value="#{BeanQueControlaOComponente.numeroUsuario}">


<!-- aqui colocamos um validador, para garantir que o número informado pelo usuário varia do mínimo escolhido pelo BeanQueControlaOComponente até o máximo -->


<f:validadeLongRange 
minumum="#{BeanQueControlaOComponente.menorValor}"  
maximum="#{BeanQueControlaOComponente.maiorValor}" 
/>


</h:inputText>


<!-- E agora colocamos o botão para enviar o formulário  -->


<h:commandButton id="enviar" action="success" value="Enviar" />




</h:form>
</f:view>



3. Definir a navegação das páginas no arquivo de configuração

Essa navegação é definida de modo a fazer com que a aplicação saiba para onde ir sempre que o usuário clicar em algum botão ou link.

Esse arquivo é baseado em regras de navegação, que são descritas em XML.

<navegation-rule>
<from-view-id>/pagina.jsp</from-view-id>
<navigation-case>
<from-outcome>
<to-view-id>/pagina_de_destino.jsp<to-view-id/>
</from-outcome>
</navigation-case>
</navegation-rule>

4. Desenvolver os backbeans

Os BackBeans são as classes java que vão controlar os componentes, como por exemplo, a classe que vai gerar os numeros maximo e minimo para o usuário tentar adivinhar, na aplicação acima.

5. Adicionar declarações de Managed Beans no arquivo de configuração

Uma vez criados esses Beans a aplicação têm que saber que eles existem, para criar novas instâncias para eles sempre que preciso.

Isso é feito em um arquivo de configuração: faces-config.xml


Outros Objetos da JSF

Conversores:  Os conversores servem para deixar a formatação dos dados informados nos componentes (amigáveis aos usuários) no formato redondinho para o tratamento nos BackBeans, como por exemplo um campo monerário, que o usuário informa algo como $RS 1.500,00  ;  devemos converter isso para um tipo do Java para a aplicação, os conversores podem fazer isso automagicamente:  1500.00. Os desenvolvedores podem criar seus próprios conversores, implementando a classe Convert.

Evento: é uma forma da aplicação saber se o usuário interagiu com aquele componente. Um botão, por exemplo, quando clicado, um evento deverá ser lançado.

Um botão ou link, por exemplo, lançam ActionEvents.

Já uma caixa de seleção lança um Value Change Event.


Os eventos podem ser tratados imediatamente ou durante o processo de validação, que é o caso dos componentes que lançam eventos de mudança de dados. (PENSE QUE BOTÕES E LINKS NÃO LANÇAM DADOS E NÃO PRECISAM TER TRATAMENTO DE EVENTOS EM TEMPO DE VALIDAÇÃO)

Ciclo de Vida dos JSF

Ciclo de Vida do JSF

Restore View: (Lembre-se, view é o nome que se dá a uma árvore de componentes de interface)

As requisições podem ser iniciais ou de postback.

Quando as requisições são iniciais então nem todas as fases precisam ser processadas já que não há dados para serem validados ou convertidos, então processa-se os eventos, como cliques em links e botões, e gera-se a view.

FacesContext é o local onde essa view é armazenada a cada requisição.

Se uma requisição inicial é realizada então ainda não há uma view armazenada no FacesConfig, porém se uma requisição postback então ele recupera o estado dessa view para gerar a resposta.

Note que a view não é gravada aqui, se é a primeira vez que o usuário requisita essa página então essa view é armazenada no Render Response.

Apply Requests:

Ao final dessa fase os componentes terão seus novos valores, enviados pelo usuário, e mensagens, como erros de conversões, foram colocados na FacesContext.

Note que no protocolo HTTP envia-se os dados por GET ou por POST de forma que uma requisição é apenas um emaranhado de código. O JSF extraí esse valor desse emaranhado de códigos e coloca esse valor na representação do componente contida na view.

Aqui os valores dos componentes serão extraídos dos parâmetros de requisição e convertidos.


"O JSF extrai todos os valores digitados pelo usuário e guarda esse valor nos seus respectivos componentes. Se o valor digitado não coincidir com o componente, um erro vai ser adicionado na classe FacesContext e será mostrado na fase Render Response Phase. " (FCC)

Process Events:

Se algum evento como FacesContext.responseComplete é lançado então o JSF vai direto para a fase de renderização.

Process Validations:

Essa fase é bem mnemônica. Ela valida a entrada do usuário, saber se o usuário colocou um número entre 0 e 100, por exemplo, ou se colocou o email válido. Caso essa validação falhe então é colocado uma mensagem no FacesContext para ser renderizada.

Note que uma vez que essa validação falhe o JSF vai executar imediatamente, após ser tratado o evento, a fase de renderização.

Validar as Entradas, se encontrar erro, manda para a renderização direto.

Process Events:

Chega se o evento de falha de validação foi lançado, caso não então continua, caso sim então vai direto para a renderização. Vamos pensar um pouco... Se o usuário colocou um dado inválido então não faz sentido continuar as outras fases visto que pode tornar o processamento desses dados inconsistente.

Update Model Values:

Nessa fase o JSF vai pegar os dados do componente, da entrada do usuário, e colocar no Bean. Lembre-se que o componente é uma representação visual de um Bean, que contém os dados que serão usados pela aplicação e também os dados necessários para recuperar o estado de um componente entre uma requisição e outra.

Se o dado do componente, mesmo após a conversão e a validação, não pode ser mapeado para um tipo de um Bean então a aplicação vai lançar um evento de erro, indo direto para a fase de renderização.

Note que ao final desse evento, nosso BeanQueControlaOComponente.numeroUsuario vai conter o valor informado pelo usuário.

Lembre-se, aqui vai gravar no BackBeans.

Process Events:

Se os dados não podem ser salvos no Bean então vai direto para a renderização.

Invoke Application:

Trata os eventos de nível de aplicação, tal como submeter um formulário ou então clicar em algum link.

Basicamente, trata eventos, calcula a navegação, invoca métodos.

Process Events:

Trata eventos como FacesConfig.responseComplete que podem ser lançados a qualquer fase.

Render Response:

Se é uma requisição inicial, então é nessa fase que é construída uma view dentro do FacesConfig.

Note que se erros são encontrados durante a fase de Apply Request,  Conversão, Validação ou Atualização do Modelo, então a página original (a view anterior) é renderizada, como as mensagens de erro se for o caso de exibi-las.