jsf 2 slideshare

JSF 2Indra Software Labs Brasil

09/2016

Título del documento | 2

Observações

• Esse curso foi elaborado para apresentação de conceitos d o J S F. É p r é - r e q u i s i t o c o n h e c e r J a v a e desenvolvimento web básico.

• O código-fonte com os exemplos de código podem ser obtidos em https://github.com/antoniolazaro/jsflabs.


Agenda

• Curso dividido em 5 dias (código-fonte do projeto reflete essa programação) • Dia 1:

• Conceitos gerais JSF • Arvore de componentes • Escopos • Converters

• Dia 2: • Validators • Navigation

• Dia 3: • Events • Ajax

• Dia 4: • Templates (facelets) • Primefaces

• Dia 5: • Revisão/Dúvidas


Índice

01 Desenvolvimento Web 02 Histórico JSF 03 JSF 2 04 Ciclo de vida 05 Árvore de componentes 06 Escopos 07 Converters 08 Validators 09 Navegação 10 Events 11 Ajax 12 Templates (facelets) 13 Primefaces 14 Outras implementações 15 Dicas desenvolvimento 16 JSF 2.2 17 JSF 2.3 18 Futuro JSF 19 Referências


DESENVOLVIMENTO WEB

▪ Antes de aprender JSF, é importante (não é pré-requisito) alguma base de conhecimento: ▪ Protocolo Http (métodos, request, response, session, status,

headers). ▪ https://nandovieira.com.br/entendendo-um-pouco-mais-

sobre-o-protocolo-http ▪ http://cin.ufpe.br/~erp/DesenvWeb/aulas/http_servlet/

http.pdf ▪ HTML, CSS e Javascript

▪ https://www.caelum.com.br/apostila-html-css-javascript/ ▪ Java para Web:

▪ JSP, Servlets, Filters, Listeners, Taglibs ▪ http://docs.oracle.com/javaee/6/tutorial/doc/bnafd.html

JSF 2

https://nandovieira.com.br/entendendo-um-pouco-mais-sobre-o-protocolo-http

https://nandovieira.com.br/entendendo-um-pouco-mais-sobre-o-protocolo-http

http://cin.ufpe.br/~erp/DesenvWeb/aulas/http_servlet/http.pdf

http://cin.ufpe.br/~erp/DesenvWeb/aulas/http_servlet/http.pdf

https://www.caelum.com.br/apostila-html-css-javascript/

http://docs.oracle.com/javaee/6/tutorial/doc/bnafd.html


DESENVOLVIMENTO WEB

▪ Frameworks Web ▪ O que é um framework?

▪ "Um framework provê uma solução para uma família de problemas semelhantes, usando um conjunto de classes e interfaces que mostra como decompor a família de problemas e como objetos dessas classes colaboram para cumprir suas responsabilidades, o conjunto de classes deve ser flexível e extensível para permitir a construção de várias aplicações com pouco esforço, especificando apenas as particularidades de cada aplicação”.

▪ Framework MVC: Model-View-Controller ▪ Tipos

▪ Action based x Component based

JSF 2


DESENVOLVIMENTO WEBJSF 2


DESENVOLVIMENTO WEB - FRAMEWORKS ACTION BASED X COMPONENT BASED

▪ Action based (MVC Push): ▪ O Controller tem a responsabilidade de colocar os dados na

view. ▪ Fluxo linear. ▪ Orientado a “Actions” ▪ Exemplos: Struts, Spring MVC, Vraptor, Grails, Rails, DJango,

asp.net

JSF 2

http://asp.net



▪ Component based (MVC Pull): O Controller invoca a view que chama o Managed Bean que é quem tem relação com o modelo. ▪ No caso do JSF o Controller é o Faces Servlet ▪ Fluxo não orientado a actions/requests e responses. ▪ Orientado a componentes. Componente “invoca modelo” ▪ Exemplo: JSF, Wicket, Tapestry, Gwt (Google Web

Toolkit),Vaadin

JSF 2



▪ Diferenças ▪ São incompatíveis, devido ao seu ciclo de vida. ▪ MVC Push:

▪ Desacoplamento entre a visão e o controller ▪ Componentes são feitos com HTML, CSS e javascript.

▪ MVC Pull: ▪ Maior acoplamento entre a visão e o framework. ▪ Permite criação de componentes de tela através de

código Java (Wicket funciona assim, “Swing like”).

JSF 2


JSF

▪ JSF = Java Server Faces. ▪ Framework MVC Web. ▪ Component Based

▪ Mais sobre design patterns:

JSF 2


Índice

01 Desenvolvimento Web 02 Histórico JSF 03 JSF 2 04 Ciclo de vida 05 Árvore de componentes 06 Escopos 07 Converters 08 Validators 09 Navegação 10 Events 11 Ajax 12 Templates (facelets) 13 Primefaces 14 Outras implementações 15 Dicas desenvolvimento 16 JSF 2.2 17 JSF 2.3 18 Futuro JSF 19 Referências


HISTÓRICO JSF

▪ JSF = Java Server Faces. ▪ Framework MVC Web. ▪ Component Based

JSF 2


HISTÓRICO JSF

▪ Histórico de versões: ▪ JSF 2.3 (2017) - JSR 372 (https://jcp.org/en/jsr/detail?id=372) ▪ JSF 2.2 (16/04/2013) - JSR 344 (https://jcp.org/en/jsr/detail?id=344) ▪ JSF 2.1 (22/10/2010) - JSR 314 (https://jcp.org/en/jsr/detail?id=314) ▪ JSF 2.0 (28/06/2009) - JSR 314 (https://jcp.org/en/jsr/detail?id=314) ▪ JSF 1.2 (11/05/2006) - JSR 252 (https://jcp.org/en/jsr/detail?id=252) ▪ JSF 1.1 (27/05/2004) - JSR 127 (https://jcp.org/en/jsr/detail?id=127) ▪ JSF 1.0 (11/03/2004) - JSR 127 (https://jcp.org/en/jsr/detail?id=127) ▪ JEE 5 iniciou adoção do JSF e ele entrou oficialmente no JEE 6

como parte da especificação. ▪ * JSR = Java Specification Request. Definição de especificação avaliada pelo JCP (Java Community

Process) do que será implementado em cada versão do JSE, JEE, etc. ▪ Especificações x Implementações:

▪ M o j a r r a ( i m p l e m e n t a ç ã o r e f e r ê n c i a ) : h t t p s : / /javaserverfaces.java.net/

▪ Myfaces (implementação Apache): https://myfaces.apache.org/

JSF 2

https://jcp.org/en/jsr/detail?id=372







https://javaserverfaces.java.net/

https://javaserverfaces.java.net/


Índice

01 Desenvolvimento Web 02 Histórico JSF 03 JSF 04 Ciclo de vida 05 Árvore de componentes 06 Escopos 07 Converters 08 Validators 09 Navegação 10 Events 11 Ajax 12 Templates (facelets) 13 Primefaces 14 Outras implementações 15 Dicas desenvolvimento 16 JSF 2.2 17 JSF 2.3 18 Futuro JSF 19 Referências


JSF

▪ Java Server Faces (JSF): ▪ Tecnologia de view oficial da camada web da especificação JEE. ▪ Possui um conjunto de componentes pré-definidos. ▪ Possui um modelo de programação orientada a eventos ▪ Trabalha com HTML e CSS associado a classes java chamadas

Managed Beans ▪ Os Managed Beans tem responsabilidade de manter a lógica de

apresentação de dados e conectar o usuário com a camada de negócio no backend.

JSF 2


JSF

▪ Hello World ▪ Configurando aplicação JSF 2. ▪ web.xml ▪ Declarando tags na página xhtml ▪ Criando primeiro Managed Bean

▪ http://localhost:8080/jsflab ▪ http://localhost:8080/jsflab/dia1/primeiroManagedBean.xhtml

JSF 2

http://localhost:8080/jsflab/dia1/primeiroManagedBean.xhtml


JSF

▪ B o a p r á t i c a : N o m e a r M a n a g e d B e a n @ManagedBean(name=“requestScopeManagedBean”).

▪ Quando isso não acontece o default é o nome da classe anotada como @ManagedBean

▪ O atributo eager da anotação ManagedBean informa se o bean será criado por demanda (quando requisitado) ou no startup da aplicação. Default é false.

JSF 2


Índice



CICLO DE VIDAJSF 2


CICLO DE VIDA

▪ RestoreView: Na primeira requisição de um usuário, uma nova árvore de componentes que representa a tela desse usuário é gerada. Nas demais requisições (postback) desse mesmo usuário, a árvore de componentes que representa a tela anteriormente enviada a ele é reconstruída.

▪ ApplyRequestValues: Nesta etapa, a árvore construída na etapa anterior é percorrida e cada um dos seus componentes é “decodificado”. No processo de decodificação, cada componente extrai da requisição atual os dados associados a essa componente e se atualiza com essas informações. Ainda nessa etapa, os eventos de ação (como um clique em um link ou em um botão, por exemplo) são identificados. Por padrão, esses eventos são adicionados às filas correspondentes para serem tratados posteriormente (na fase Invoke Application).

▪ Process Validations: Nesta fase, os componentes que possuem valores submetidos pelo usuário através de formulários são convertidos e validados (caso haja algum validador registrado para esse componente). Se ocorrer algum erro de conversão ou validação, mensagens de erro são adicionadas no contexto da requisição atual e o fluxo é redirecionado para a fase Render Response. Caso contrário, processo continua na fase Update Model Values. Ainda nesta fase, os eventos de mudança de valor são identificados e tratados ao final da mesma.

JSF 2


CICLO DE VIDA

▪ UpdateModelValues: Os valores contidos em cada componente da árvore, já convertidos e validados na fase anterior, são armazenados em propriedades de objetos definidos pela aplicação (managed beans)

▪ Invoke Application: Uma vez que os dados dos componentes já foram convertidos, validados e armazenados nos objetos do modelo, as tarefas correspondentes ao evento que disparou a requisição (normalmente um clique em um botão ou link) serão executadas. Também nesta fase, a próxima tela a ser apresentada ao usuário é determinada pelo resultado do método que implementa a lógica de negócio executado nesta fase.

▪ Render Response: Nesta etapa, a próxima tela é gerada e enviada ao navegador do usuário. Uma representação desta tela também é armazenada a fim de ser usada na fase Restore View da próxima requisição.

JSF 2


Índice



ÁRVORE DE COMPONENTESJSF 2

ÁRVORE DE COMPONENTES

▪ Componentes guardam estado na árvore de componentes (também conhecida como view ou UIViewRoot)

▪ Hash único da view: <input id=“javax.faces.ViewState" value="-5331242430046946924:4161480279607048884"

▪ Todas as página vão ter uma ou mais árvores de componentes na sessão (mesmo para uma aplicação com poucas páginas, o usuário poderia usar várias abas da mesma página).

▪ Como resolver? Guardar árvore serializada no cliente. <context-param>

<param-name>javax.faces.STATE_SAVING_METHOD</param-name>

<param-value>client</param-value> 

</context-param>

JSF 2


ÁRVORE DE COMPONENTES

▪ Boa prática: Usar id em todos componentes.

JSF 2


Índice



ESCOPOS

▪ Os Managed Beans são instanciados pelo JSF. O ciclo de vida que esses Managed Bean vão existir na aplicação é chamado de escopo,

▪ Principais escopos no JSF 2: ▪ Request - Valores são criados quando o request é disparado e e

é destruído quando o response é fornecido. Escopo default. Caso não seja definido nenhuma anotação, será considerado esse.

▪ View - Valores são criados quando o request é criado e é persistido enquanto não há mudança de tela (navegação)

▪ Session - Valores são persistido na sessão do usuário e são destruídos apenas quando a sessão do usuário é encerrada.

▪ Application - Valores são persistido no contexto de aplicação e são destruídos apenas quando a aplicação for finalizada

JSF 2


ESCOPOS

▪ Os managed Bean devem sempre implementar serializable, principalmente quando o estado da view é do tipo client. O view de escopo trabalha com serialização de dados para manter o estado dos valores.

▪ Precedência dos escopos: ▪ Request < View < Session < Application

JSF 2


ESCOPOS

▪ Existem outros escopos: ▪ @NoneScoped - Não é salvo em lugar algum. Os dados estão

disponíveis até a EL ser executada. ▪ @CustomScoped - Dev é responsável por implementar o ciclo de

vida. ▪ Acessando request/sessão

▪ ManagedBeanUtil ou abstração

JSF 2


ESCOPOS - CONTEXTOS

▪ FacesContext e ExternalContext ▪ http://docs.oracle.com/javaee/6/api/ javax/faces/context/

FacesContext.html ▪ http://docs.oracle.com/javaee/6/api/ javax/faces/context/

ExternalContext.html

JSF 2

http://docs.oracle.com/javaee/6/api/javax/faces/context/ExternalContext.html

http://docs.oracle.com/javaee/6/api/javax/faces/context/ExternalContext.html


ESCOPOS - OBJETOS IMPLICATIVO EL JSF

▪ Implicitos objetos EL ▪ #{component}: Atual UIComponent ▪ #{facesContext}: Atual FacesContext ▪ #{view}: Atual UIViewRoot ▪ #{request}: Atual HttpServletRequest ▪ #{session}: Atual HttpSession ▪ #{application}: O ServletContext ▪ #{flash}: Atual Flash ▪ #{cc}: Atual composite component ▪ #{requestScope}: Atual request attribute map ▪ #{viewScope}: Atual view attribute map ▪ #{sessionScope}: Atual session attribute map ▪ #{applicationScope}: the application attribute map ▪ #{initParam}: Atual context parameter map ▪ #{param}: Atual request parameter map ▪ #{paramValues}: Atual request parameter values map ▪ #{header}: Atual request header map ▪ #{headerValues}: Atual request header values map ▪ #{cookie}: Atual request cookie map

JSF 2


Índice



CONVERTERS

▪ Mecanismo automático que converte valor do campo no HTML para o Managed Bean

▪ Aplicado automaticamente para os tipos abaixo: ▪ BigDecimal ▪ BigInteger ▪ Boolean e boolean ▪ Byte e byte ▪ Character e char ▪ Double e double ▪ Float e float ▪ Integer e int ▪ Long e long ▪ Short e short ▪ String

JSF 2


CONVERTERS

▪ Conversores especiais

▪ <f:convertNumber> ▪ Mais informações: https://www.tutorialspoint.com/jsf/

jsf_convertnumber_tag.htm

▪ <f:convertDateTime> ▪ Mais informações: https://www.tutorialspoint.com/jsf/

jsf_convertdatetime_tag.htm

JSF 2

https://www.tutorialspoint.com/jsf/jsf_convertdatetime_tag.htm




CONVERTERS

▪ Custom Validators: ▪ Demo

JSF 2


Índice



DEMONSTRAÇÃO COMPONENTES JSF

▪ http://www.mkyong.com/tutorials/jsf-2-0-tutorials/

JSF 2


VALIDATORS

▪ Após a conversão, o JSF pode aplicar uma etapa de validação (fase Process Validation)

▪ Validações padrão: ▪ Campo obrigatório (required)

▪ <h:inputText value="#{testeBean.nome}" id="campo-nome" required="true"/> 2 <h:message for="campo-nome"/>

▪ <h:inputText value="#{testeBean.nome}" id="campo-nome"> <f:validateRequired/></h:inputText>

▪ Outros validadores:

▪ <f:validateLongRange> ▪ <f:validateDoubleRange> ▪ <f:validateLength> ▪ <f:validateRegex>

JSF 2


VALIDATORS

▪ Exibindo mensagens de erro:

▪ <h:message>

▪ <h:inputText value="#{testeBean.numero}" id="campo-numero"/> <h:message for="campo-numero"/>

▪ Cada mensagem de erro possui duas versões: uma detalhada e outra resumida. Por padrão, apenas a mensagem detalhada é exibida quando a tag <h:message> é aplicada. Para modificar esse comportamento, podemos alterar os valores dos atributos showSummary e showDetail. O primeiro atributo indica se a mensagem resumida deve ser apresentada, enquanto o segundo indica se a mensagem detalhada deve ser exibida. Esses atributos devem assumir valores true ou false. Veja o exemplo abaixo.

▪ <h:inputText value="#{testeBean.numero}" id="campo-numero"/>

▪ <h:message for="campo-numero" showSummary="true" showDetail="false"/>

JSF 2


VALIDATORS

▪ Boa prát ica: Cr iar um arquivo de mensagens ( fac i l i ta internacionalização)

▪ Conjunto de chaves/valores.

▪ Exemplo: javax.faces.converter.BooleanConverter.BOOLEAN={1}: ’’{0}’’ must be ’true’ or ’false’←

▪ Exemplo de declaração do arquivo (faces-config.xml) ▪ <application> <message-bundle>resources.Messages</

message-bundle> </application>

▪ Outra forma de customizar mensagem: ▪ <h:inputText value="#{testeBean.numero}" id="campo-numero"

converterMessage="Por favor, digite um número"/> <h:message for="campo-numero"/>

JSF 2


VALIDATORS

▪ Bean validation (JSR 303: https://jcp.org/en/jsr/detail?id=303)

▪ Adicionar validações na classe do modelo.

▪ Strings por padrão são tratadas como “” ao invés de null. Para mudar esse comportamento, é necessário definir o atributo abaixo no web.xml

▪ <context -param> <param-name> javax.faces.INTERPRET_EMPTY_STRING_SUBMITTED_VALUES_AS_NULL </param-name> <param-value>true</param-value> </context -param>

▪ Para desabilitar bean validations em um componente particular de um formulário, podemos usar a tag <f:validateBean>. Isso pode ser feito atribuindo o valor “true” ao atributo disabled dessa tag.

JSF 2



VALIDATORS

▪ Validações (Beans validation): ▪ @AssertFalse: Verifica se uma propriedade booleana possui valor false. ▪ @AssertTrue: Verifica se uma propriedade booleana possui valor true. ▪ @DecimalMax: Define o valor real máximo que uma propriedade pode

armazenar. ▪ @DecimalMin: Define o valor real mínimo que uma propriedade pode assumir. ▪ @Digits: Define a quantidade máxima de dígitos da parte inteira (através do

atributo integer) ou da parte fracionária (através do atributo fraction) de um número.

▪ @Future: Verifica se uma data é posterior ao instante atual. ▪ @Max :Define o valor inteiro máximo que uma propriedade pode assumir. ▪ @Min: Define o valor inteiro mínimo que uma propriedade pode armazenar. ▪ @NotNull: Verifica se o valor de uma propriedade não é null. ▪ @Null: Verifica se o valor de uma propriedade é null. ▪ @Past: Verifica se uma data é anterior ao instante atual. ▪ @Pattern: Verifica se o valor de uma propriedade respeita uma expressão

regular. ▪ @Size: Define os tamanhos mínimo (através do atributo min) e máximo (através

do atributo max) para uma Collection, array ou String.

JSF 2


VALIDATORS

▪ (JSR 380 Bean Validation 2.0): http://beanvalidation.org/news/2016/07/15/bean-validation-2-0-is-coming/

JSF 2


VALIDATORS

▪ Personalizando mensagem usando Beans Validation: ▪ @NotNull(message="O nome não pode ser nulo") private String nome; ▪ Arquivo de configuração: ▪ br.com.teste.Funcionario.nome=O nome do funcionário não pode ser nulo ▪ @NotNull(message="br.com.teste.Funcionario.nome") private String nome; ▪ javax.validation.constraints.NotNull.message=O nome do funcionário não pode ser

nulo ▪ Outras demais:

▪ @AssertFalse: “{javax.validation.constraints.AssertFalse.message}" ▪ @AssertTrue: “{javax.validation.constraints.AssertTrue.message}" ▪ @DecimalMax: “{javax.validation.constraints.DecimalMax.message}" ▪ @DecimalMin: "{javax.validation.constraints.DecimalMin.message}" ▪ @Digits: “{javax.validation.constraints.Digits.message}" ▪ @Future: “{javax.validation.constraints.Future.message}" ▪ @Max: “{javax.validation.constraints.Max.message}" ▪ @Min: "{javax.validation.constraints.Min.message}" ▪ @Null: “{javax.validation.constraints.Null.message}" ▪ @Past: “{javax.validation.constraints.Past.message}" ▪ @Pattern: “{javax.validation.constraints.Pattern.message}" ▪ @Size: "{javax.validation.constraints.Size.message}"

JSF 2


VALIDATORS▪ Criando seu próprio validator

@FacesValidator("com.mkyong.EmailValidator")

public class EmailValidator implements Validator{

private static final String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\." +

"[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*" +

"(\\.[A-Za-z]{2,})$";

private Pattern pattern;

private Matcher matcher;

public EmailValidator(){

pattern = Pattern.compile(EMAIL_PATTERN);

}

@Override

public void validate(FacesContext context, UIComponent component,

Object value) throws ValidatorException {

matcher = pattern.matcher(value.toString());

if(!matcher.matches()){

FacesMessage msg =

new FacesMessage("E-mail validation failed.",

"Invalid E-mail format.");

msg.setSeverity(FacesMessage.SEVERITY_ERROR);

throw new ValidatorException(msg);

}

}

}

JSF 2


VALIDATORS

▪ Criando seu próprio validator (passando parâmetro para validator)

▪ <h:inputText value="#{testeBean.data}" id="campo-data"> ▪ <f:attribute name="inicio" value="01/05/2014" /> ▪ <f:attribute name="fim" value="30/08/2014"/> </h:inputText>

@Override public void validate(FacesContext context , UIComponent component , Object value) {

String inicio = (String) component.getAttributes().get("inicio");

String fim = (String) component.getAttributes().get("fim"); ...

}

JSF 2


VALIDATORS

▪ Criando seu próprio validator import java.lang.annotation.Retention; import java.lang.annotation.Target;

import javax.validation.Constraint;

import javax.validation.Payload;

@Target ({ METHOD , FIELD , ANNOTATION_TYPE }) @Retention(RUNTIME)

@Constraint(validatedBy = ValidadorDePrimo.class) public @interface Primo {

String message() default "{br.com.k19.Primo.message}"; Class<?>[] groups() default {};

Class <? extends Payload >[] payload () default {}; }

JSF 2


Índice



NAVEGAÇÃO

▪ Navegar entre páginas é algo natural em uma aplicação web.

▪ Normalmente são utilizados botões ou links para navegação entre telas.

▪ Navegação no JSF acontece orientado a sinais (conhecidos como: outcome). Esse sinal nada mais é que uma string que direciona a próxima página destino.

JSF 2


NAVEGAÇÃO

▪ Tipos de navegação: ▪ Navegação implícita: outcome tem o nome do arquivo destino sem o sufixo ▪ Exemplo:

▪ <h:commandButton value="Página 2" action="pagina2"/> ▪ <h:link outcome="pagina1"> <h:outputText value="Página 1"/> </

h:link> ▪ <h:commandButton value="Página 2" action="/diretorio1/diretorio2/

pagina2"/> ▪ <h:commandButton value="Página 2" action="diretorio2/pagina2"/>

▪ Navegação explicita: outcome tem nome diferente do arquivo destino. O destino deve ter o nome completo do arquivo. Deve ser declarada no faces-config.xml.

▪ <navigation-rule> <from-view-id>/pagina1.xhtml</from-view-id> <navigation-case> <from-outcome>proxima</from-outcome> <to-view-id>/pagina2.xhtml</to-view-id> </navigation-case> </navigation-rule>

▪ <h:commandButton value="Próxima tela" action="proxima"/>

JSF 2


NAVEGAÇÃO

▪ O JSF utiliza a seguinte lógica para determinar a página de resposta.

▪ Primeiro, ele verifica se o outcome é compatível com alguma regra de navegação registrada no arquivo faces-config.xml. ▪ Caso seja, o JSF realizará uma navegação explícita

processando essa regra. ▪ Caso contrário, o JSF tentará realizar uma navegação

implícita, procurando um arquivo compatível com o outcome. ▪ Se esse arquivo não existir, a tela atual será reapresentada.

<navigation-rule>

<from-view-id>/teste/*</from-view-id> <navigation -case>

<from-outcome>home</from-outcome> <to-view-id>/home.xhtml</to-view-id>

</navigation -case> </navigation -rule>

JSF 2


NAVEGAÇÃO

▪ Navegação dinâmica

<h:commandButton value="Lançar Moeda" action="#{caraOuCoroaBean.lanca}" />

@ManagedBean

public class CaraOuCoroa{

public String lanca(){

if(Math.random() < 0.5){

return “cara”;

}else{

return “coroa”;

}

}

}

JSF 2


Índice



EVENTS

▪ Ações são baseadas em eventos (clique do botão, mudança de estado de combo).

▪ Três categorias: ▪ FacesEvent ▪ PhaseEvent ▪ SystemEvent

JSF 2


EVENTS

▪ FacesEvent

▪ ActionEvent: Botão ou link é pressionado. Métodos do ManagedBean podem ser invocados.

▪ action x actionListener: ▪ action: Retorno void ou String. No caso de retorno de String será

usada como regra de navegação. Conceitualmente deve ser usado para métodos de regras de negocio da aplicação.

▪ actionListener: Retorna void e tem como parâmetro ActionEvent. Conceitualmente deve ser usado por métodos que implementem lógica de interface. Sempre será invocado antes da action. (bloquear ou esconder componentes)

JSF 2


EVENTS

▪ FacesEvent ▪ ValueChangeEvent: Disparado quando o valor de um

componente é modificado.

<h:inputText valueChangeListener="#{produtoBean.mudaPreco}" id="preco" />

@ManagedBeanpublic class ProdutoBean {

public void mudaPreco(ValueChangeEvent e) { System.out.println("Preço antigo: " + e.getOldValue());

System.out.println("Preço novo: " + e.getNewValue()); }

}

▪ Outra forma: <h:inputText id="preco"> <f:valueChangeListener type="teste.RegistraAlteracao" /> </h:inputText

JSF 2


EVENTS

▪ PhaseListener: Eventos disparados pelo JSF antes e depois de cada uma das fases do processamento de uma requisição. Esses eventos são úteis para monitorar a execução das fases. ▪ Para tratar um PhaseEvent, podemos criar uma classe que implemente a interface

javax.faces.event.PhaseListener. ▪ Além disso, precisamos registrar essa classe no arquivo faces-config.xml. A interface

PhaseListener obriga a implementação de três métodos: afterPhase(), beforePhase() e getPhaseId().

▪ O método getPhaseId() deve devolver a referência de um objeto do tipo javax.faces.event.PhaseId, que indica em quais fases do processamento de uma requisição estamos interessados. Se estivermos interessados nos eventos da fase Apply Request Values, por exemplo, podemos fazer esse método devolver PhaseId.APPLY_REQUEST_VALUES.

▪ Os valores que podem ser utilizados são: ▪ PhaseId.RESTORE_VIEW ▪ PhaseId.APPLY_REQUEST_VALUES ▪ PhaseId.INVOKE_APPLICATION ▪ PhaseId.PROCESS_VALIDATIONS ▪ PhaseId.UPDATE_MODEL_VALUES ▪ PhaseId.RENDER_RESPONSE ▪ PhaseId.ANY_PHASE

▪ <lifecycle> <phase-listener>br.teste.MonitorPhaseListener</phase-listener> </lifecycle>

JSF 2


EVENTS

▪ SystemEvent: Similares aos PhaseEvents no sentido de que ambos estão relacionados a pontos específicos de execução de uma aplicação JSF. Contudo, os eventos de sistema são gerados em diversos pontos não cobertos pelos eventos de fase. Todas as classes que definem eventos de sistema são subclasses de javax.faces.event.SystemEvent. ▪ PostConstructApplicationEvent: É gerado imediatamente após o início

da aplicação, depois que todas as configurações são processadas. ▪ PreDestroyApplicationEvent: Esse tipo de evento é gerado

imediatamente antes da aplicação ser finalizada. ▪ ExceptionQueuedEvent: Esse evento é gerado assim que uma exceção

não esperada é lançada durante o processamento de uma requisição. Alguns exemplos de exceções esperadas durante o processamento de uma requisição são aquelas relacionadas à conversão e validação dos dados.

▪ PreValidateEvent e PostValidateEvent: Esses eventos são gerados imediatamente antes e logo após um componente ser validado, respectivamente.

JSF 2


EVENTS

▪ SystemEvent ▪ <f:event type="postValidate" listener="#{extratoBean.validaDatas}" />

▪ preRenderComponent:javax.faces.event.PreRenderComponentEvent ▪ preRenderView: javax.faces.event.PreRenderViewEvent ▪ postAddToView: javax.faces.event.PostAddToViewEvent ▪ preValidate: javax.faces.event.PreValidateEvent ▪ postValidate: javax.faces.event.PostValidateEvent

▪ Exemplo: preRenderView

JSF 2


EVENTS

▪ Immediate ▪ Por padrão, a conversão e a validação dos dados de um

componente de entrada são realizadas na fase Process Validation.

▪ A l é m d i s s o , o s e v e n t o s d e m u d a n ç a d e v a l o r (ValueChangeEvent) também ocorrem nessa fase.

JSF 2


EVENTS

▪ Immediate ▪ Também por padrão, os eventos de ação (ActionEvent)

a s s o c i a d o s a o s c o m p o n e n t e s <h:commandButton>ou<h:commandLink>são disparados no final da fase Invoke Application do processamento de uma requisição.

▪ Esse comportamento pode ser alterado através do atributo immediate desses componentes. ▪ Para Input: Tornar o componente alta prioridade para

validação. Se qualquer validação falhar, então nenhum outro componente no mesmo form é validado.

▪ Para submit: Permite pular a fase de validação

JSF 2


Índice



AJAX

▪ AJAX (Asynchronous Javascript And XML):AJAX é carregar e renderizar uma página, utilizando recursos de scripts rodando pelo lado cliente, buscando e carregando dados em background sem a necessidade de reload da página.

▪ AJAX é acrônimo para: Asynchronous JavaScript And XML e foi gerado por Jesse James Garret, em um artigo no site

▪ Enquanto em uma aplicação Web clássica o navegador tem que ir buscar as informações no servidor e retornar para o cliente, no Ajax ocorre de forma diferente. No carregamento da página, toda a lógica de processamento de dados é passado ao cliente. Quando o usuário faz uma requisição, quem busca e trás essas informações é o JavaScript, de forma assíncrona, não causando assim o chamado “reload” na tela.

▪ O tratamento dos dados, seu formato e exibição fica toda por conta do script que foi carregado inicialmente quando se acessou a página. O processo inicial de carregamento é mais lento que de uma aplicação comum, pois muitas informações são pré-carregadas. Mas depois, somente os dados são carregados, tornando assim o site mais rápido.

JSF 2


AJAX

▪ Duas características: ▪ A primeira é a possibilidade de atualizar trechos de uma página

ao invés da página inteira. ▪ A segunda é poder realizar requisições sem interromper a

navegação dos usuários.

▪ JSF 2 tem suporte nativo a ajax. Nas versões anteriores dependia do uso de bibliotecas de terceiros (a4j !!!)

▪ <h:inputText> <f:ajax/></h:inputText>

▪ Evento padrão (onchange). ▪ BOA PRÁTICA. Informar explicitamente qual evento você

programou.

JSF 2


AJAX

▪ Agrupando chamadas:

▪ <f:ajax event="mouseout"> <h:inputText/> <h:inputSecret/> <h:commandButton value="OK"/> </f:ajax> \

▪ Através do atributo execute da tag ajax é possível definir quais componentes devem ser avaliados no servidor. Podem ser declarado através de uma lista separada por “,”. ▪ <h:commandButton value=“Enviar"><f:ajax event="cl ick"

execute=“component-id1,component-id2”/> </h:commandButton>

▪ Render ▪ <h:commandButton value="Gera Número"> <f:ajax event="click"

render="numero"/></h:commandButton> ▪ < h : o u t p u t T e x t i d = " n u m e r o "

value="#{geradorDeNumeroBean.numero}"/>

JSF 2


AJAX

▪ Ações: ▪ <h:commandButton value="Salva"> <f:ajax event=“click"

e x e c u t e = " f o r m u l a r i o " r e n d e r = " f o r m u l a r i o " listener=“#{produtoBean.salva}”/></h:commandButton>

▪ Além dos ids podem ser usados com render e execute os seguintes valores: ▪ @all refere-se a todos os componentes da tela. ▪ @none refere-se a nenhum componente. ▪ @this refere-se ao componente que disparou a requisição AJAX. ▪ @form refere-se aos componentes do formulário que contém o

componente que disparou a requisição AJAX.

JSF 2


Índice



TEMPLATES (FACELETS)

▪ Em geral, os templates não definem uma tela concreta da aplicação. Eles funcionam como uma base para a criação de telas concretas. Dessa forma, não seria interessante que os navegadores acessassem diretamente a tela correspondente a um template, pois, provavelmente, essa tela estaria incompleta. ▪ Para evitar esse comportamento indesejado, devemos colocar

todos os templates dentro do diretório /WEB-INF.

▪ Esqueleto. Gera Reuso, redução de tempo, consequentemente custo.

▪ Facelets é nativo do JSF 2 e é engine padrão para gerenciamento de telas.

JSF 2



▪ Outras template engine (caso tenham gostado do tema e queiram usar em outros projetos) ▪ Thymeleaf ▪ Apache Velocity ▪ FreeMarker

▪ Criando template (clássico: cabeçalho, rodapé, menu e conteúdo) ▪ <ui:insert> ▪ <ui:composition> ▪ <ui:define> ▪ <ui:include>

JSF 2


TEMPLATES (FACELETS)▪ Ciclo de vida:

1) Quando um cliente, como um navegador, faz uma nova solicitação para uma página que é criado usando Facelets, uma nova árvore de componente ou javax.faces.component.UIViewRoot é criado e colocado no FacesContext.

2) O UIViewRoot é aplicada aos Facelets, e a view é preenchida com componentes para processamento.

3) A view recém-construída é processado de volta como uma resposta para o cliente.

4) No processamento, o estado desta view é armazenado para o próximo request. O estado de componentes de entrada e dados do formulário é armazenado.

5) O cliente pode interagir com a vista e solicitar uma outra view ou alteração do JavaServer Faces. Neste momento a exibição salva é restaurada a partir do estado armazenado.

6) A visão restaurada mais uma vez passou pelo ciclo de vida do JSF, que eventualmente será ou gerará uma nova visão ou re-tornar a visão atual se não houvesse problemas de validação e nenhuma ação foi acionado.

7) Se o mesmo ponto de vista é solicitada, a vista armazenado é processado novamente.

8) Se uma nova view é requerida, então o processo descrito no Passo 2 é continuado.

9) A nova view é então renderizado de volta como uma resposta para o cliente.

JSF 2



▪ Passagem de parâmetros e facelets.

▪ Exemplo prático.

JSF 2


TEMPLATES (FACELETS) - TÓPICO AVANÇADO

▪ Composite Components: Tipo especial de template que permite criação de componentes de tela através de criação de novas tags. É uma coleção de tags e outros componentes existentes.

▪ O componente é essencialmente um pedaço de código reusável que tem comportamento particular.

JSF 2


TEMPLATES (FACELETS) - TÓPICO AVANÇADOJSF 2

Tag Funçãocomposite:interface Declara o contrato de utilização de um componente composto.

composite:implementation Define a implementação do componente compósito. Se um elemento de interface aparece, deve haver um correspondente na implementação.

composite:attribute Declara um atributo que pode ser dado a uma instância do componente composto em que essa marca é declarada.

composite:insertChildren É usada para inserir um componente dentro de um componente pai. Estes componentes filhos são realocadas na página usando o ponto onde eles são colocados. Serve para marcar, a implementação que deve fazer é quem implementa o componente. Não há atributos definidos para esta tag.

composite:valueHolder Especi f ica os componentes in ternos, que implemente javax.faces.component.ValueHolder. Esta tag é usada para fixar o valor do objeto na página. O valor atribuído ao ValueHolder não pode ser alterado pelo usuário.

composite:editableValueHolder Especi f ica os componentes in ternos, que implemente javax.faces.component.EditableValueHolder. Esta tag é usada para fixar o valor do objeto na página. O valor atribuído ao EditableValueHolder pode ser alterado pelo usuário.

composite:actionSource Esta marcação é utilizado para acoplar o valor de objecto na página usando o componente que é utilizado no componente compósito. Esta marca é declarada dentro da tag <composite interface> com algum valor do atributo 'nome' e / ou 'alvos'. Dentro do <composite: implementação> tag se o valor objeto de qualquer componente é anexado ao ActionSource em seguida, seus nomes devem ser combinados.



▪ Exemplo.

▪ Atenção para resources/demo. Padrão da pasta.

JSF 2


Índice



PRIMEFACES

▪ Principal biblioteca de componentes JSF 2 do mercado. (http://www.primefaces.org/) ▪ http://www.primefaces.org/showcase/index.xhtml

▪ A instalação basicamente consiste em adicionar o jar no projeto e adicionar a entrada abaixo nas páginas: ▪ xmlns:p="http://primefaces.org/ui">

▪ Características (versão atual 6.x): ▪ Ajax nativo. ▪ Suporte Html 5 ▪ Suporte a Themas ▪ Construído usando Jquery

▪ Documentação: ▪ http://www.primefaces.org/documentation

JSF 2

http://www.primefaces.org/

http://www.primefaces.org/

http://www.primefaces.org/showcase/index.xhtml

http://www.primefaces.org/documentation


PRIMEFACES

▪ Versões: ▪ Community - Gratuito. Mantido pela comunidade, sem suporte

do time do Primefaces. Tem acesso apenas a major release (Exemplo: 6.0. Não tem acesso a 6.0.1) ▪ Elite - Pagamento anuidade (US$ 99,00 por desenvolvedor

anual). Tem acesso a releases intermediárias. ▪ Pro - Eles pedem para entrar em contato e negociar. Tem

direito a suporte pelo time do Primefaces. ▪ Mais informações:

▪ http://www.primefaces.org/support ▪ Código fonte:

▪ https://github.com/primefaces/primefaces

JSF 2

http://www.primefaces.org/support

https://github.com/primefaces/primefaces


PRIMEFACES

▪ Showcase ▪ http://www.primefaces.org/showcase/

JSF 2


PRIMEFACES

▪ Primefaces Theme

▪ Primefaces mobile

▪ Primefaces Push

JSF 2


PRIMEFACES - INDO ALÉM DO JSF

▪ Primefaces Ui - Suíte de componentes do Primefaces usando Jquery para páginas Html, css e javascript ▪ http://www.primefaces.org/primeui/

▪ Primefaces Ng - Suíte de componentes do Primefaces escrito para uso com Angular 2 (https://angular.io/) ▪ http://www.primefaces.org/primeng

JSF 2

http://www.primefaces.org/primeui/

https://angular.io/

http://www.primefaces.org/primeng


PRIMEFACES EXTENSIONS

▪ Definição do site: ▪ Primefaces extensions é uma biblioteca de componentes

open source para JSF 2. O projeto é construído em cima das Pr imeFaces. Pr imefaces extensions consis te em componentes estendidos ausentes em outras bibliotecas ou com componentes melhorados que já existem em algum lugar, mas não trabalham lá sem problemas. Além disso ele fornece ClientBehaviors úteis, conversores, taghandlers e muito mais. Eles estão apresentados no lado esquerdo. Correspondentes casos de uso são mostrados na parte superior sobre a documentação direita e tag along com eventos comportamento do cliente na parte inferior à direita.

▪ http://www.primefaces.org/showcase-ext/views/home.jsf ▪ http://primefaces-extensions.github.io/ ▪ https://github.com/primefaces-extensions

JSF 2

http://www.primefaces.org/showcase-ext/views/home.jsf

http://primefaces-extensions.github.io/

https://github.com/primefaces-extensions


Índice



OUTRAS IMPLEMENTAÇÕES JSF 2

▪ Rich Faces - http://richfaces.jboss.org/ - Descontinuado em junho/2016 (https://developer.jboss.org/wiki/RichFacesEnd-Of-LifeQuestionsAnswers) ▪ http://showcase.richfaces.org/

▪ Omini faces - http://showcase.omnifaces.org/ - Biblioteca utilitária para JSF

▪ Ice Faces - http://www.icesoft.org/java/projects/ICEfaces/overview.jsf ▪ http://icefaces-showcase.icesoft.org/showcase.jsf

▪ Boots Faces: http://www.bootsfaces.net/index.jsf ▪ http://showcase.bootsfaces.net/ ▪ http://showcase.bootsfaces.net/Examples/

▪ ButterFaces: ▪ http://www.butterfaces.org/ ▪ https://github.com/ButterFaces/ButterFaces

▪ Angular Faces: https://www.angularfaces.net/ ▪ https://www.angularfaces.net/tetris/index.jsf

JSF 2

http://richfaces.jboss.org/

https://developer.jboss.org/wiki/RichFacesEnd-Of-LifeQuestionsAnswers

https://developer.jboss.org/wiki/RichFacesEnd-Of-LifeQuestionsAnswers

http://showcase.omnifaces.org/

http://www.icesoft.org/java/projects/ICEfaces/overview.jsf

http://icefaces-showcase.icesoft.org/showcase.jsf

http://www.bootsfaces.net/index.jsf

http://showcase.bootsfaces.net/

http://showcase.bootsfaces.net/Examples/

http://www.butterfaces.org/

https://www.angularfaces.net/

https://www.angularfaces.net/tetris/index.jsf


Índice



DICAS

▪ Livro JSF eficaz (https://www.casadocodigo.com.br/products/livro-jsf-eficaz) ▪ Coloque lógica de rendered no MB

▪ Cuidado com que tipo de lógica coloca aqui. ▪ @PostConstruct para inicializar atributos

▪ Inicializar objetos evita Target Unreachable ▪ Use sempre xhtml (é mais rápido que JSP). ▪ Evite misturar as implementações/Bibliotecas de Componentes

(Primefaces com Richfaces ou outras combinações) ▪ Quando usar ajax, sempre indique o que está acontecendo

(p:ajaxStatus) ▪ Sempre indique mensagem de feedback para o usuário final ▪ Evite o usuário dedo nervoso. Ele pode derrubar seu sistema

(bloqueio de botão)

JSF 2

https://www.casadocodigo.com.br/products/livro-jsf-eficaz

https://www.casadocodigo.com.br/products/livro-jsf-eficaz


DICAS▪ Onde aprender mais

▪ Documentação oficial: ▪ http://docs.oracle.com/javaee/6/tutorial/doc/bnadp.html

▪ BalusC ▪ http://balusc.omnifaces.org/ ▪ http://stackoverflow.com/users/157882/balusc

▪ Rafael Ponte ▪ http://www.rponte.com.br/ ▪ http://blog.triadworks.com.br/ ▪ Artigo clássico: http://www.rponte.com.br/2008/11/24/os-10-maus-habitos-dos-

desenvolvedores-jsf/ ▪ http://blog.triadworks.com.br/jsf-nao-coloque-processamento-caro-em-metodos-getters

▪ Blog da caelum: ▪ http://blog.caelum.com.br/10-razoes-para-migrar-sua-aplicacao-para-jsf-2/

▪ K19 ▪ http://www.k19.com.br/downloads/apostilas/java/k19-k12-desenvolvimento-web-com-

jsf2-e-jpa2 ▪ Alura (https://www.alura.com.br/) ▪ Casa do código (https://www.casadocodigo.com.br/) ▪ http://www.tutorialspoint.com/jsf/ ▪ http://www.mkyong.com/tutorials/jsf-2-0-tutorials/ ▪ http://www.coreservlets.com/JSF-Tutorial/

JSF 2

http://balusc.omnifaces.org/

http://stackoverflow.com/users/157882/balusc

http://www.rponte.com.br/

http://blog.triadworks.com.br/

http://www.rponte.com.br/2008/11/24/os-10-maus-habitos-dos-desenvolvedores-jsf/



http://blog.triadworks.com.br/jsf-nao-coloque-processamento-caro-em-metodos-getters

http://blog.caelum.com.br/10-razoes-para-migrar-sua-aplicacao-para-jsf-2/

http://www.k19.com.br/downloads/apostilas/java/k19-k12-desenvolvimento-web-com-jsf2-e-jpa2


https://www.alura.com.br/

https://www.casadocodigo.com.br/

http://www.tutorialspoint.com/jsf/

http://www.mkyong.com/tutorials/jsf-2-0-tutorials/


Índice



JSF 2.2

▪ Suporte HTML 5

▪ Faces Flows (novo escopo: FlowScoped)

▪ Cross Site Request Forgery (CSRF) Protection

▪ Componente de upload

▪ Carga de facelets via resource handler

▪ Multi-templating

JSF 2


Índice



JSF 2.3

▪ Previsto para dezembro/2017

▪ Melhorias na injeção CDI

▪ Melhorias no suporte a collections

▪ Melhor suporte a Java 8

JSF 2


Índice



FUTURO JSF

▪ Pontos de vista contra: ▪ https://www.thoughtworks.com/radar/languages-and-frameworks/jsf ▪ https://gist.github.com/nekman/8774761

▪ Pontos de vista a favor: ▪ http://blog.primefaces.org/?p=3035

JSF 2

https://www.thoughtworks.com/radar/languages-and-frameworks/jsf

https://gist.github.com/nekman/8774761

http://blog.primefaces.org/?p=3035


Índice



REFERÊNCIAS1. http://docs.oracle.com/javaee/6/tutorial/doc/bnafd.html 2. https://www.caelum.com.br/apostila-java-testes-jsf-web-services-design-patterns/ 3. http://www.rponte.com.br/2008/11/24/os-10-maus-habitos-dos-desenvolvedores-jsf/ 4. http://blog.caelum.com.br/10-razoes-para-migrar-sua-aplicacao-para-jsf-2/ 5. https://pt.wikipedia.org/wiki/JavaServer_Faces 6. https://en.wikipedia.org/wiki/JavaServer_Faces 7. http://richfaces.jboss.org/ 8. http://showcase.omnifaces.org/ 9. http://www.icesoft.org/java/projects/ICEfaces/overview.jsf 10.http://jdevelopment.nl/jsf-22/ 11.http://blog.caelum.com.br/entenda-os-mvcs-e-os-frameworks-action-e-component-based/ 12.http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/oque.htm 13.http://www.softwareengineeringsolutions.com/thoughts/frameworks/JSF-lifecycle.htm 14.http://blog.caelum.com.br/jsf-lidando-com-o-estado-da-view/ 15.http://download.oracle.com/otn_hosted_doc/jdeveloper/j2ee101302/jsf_apps/eventvalidate/sf_avc_converters.html 16.http://www.k19.com.br/downloads/apostilas/java/k19-k12-desenvolvimento-web-com-jsf2-e-jpa2 17.http://blog.triadworks.com.br/quando-usar-action-ou-actionlistener-com-jsf 18.http://stackoverflow.com/questions/3909267/differences-between-action-and-actionlistener 19.http://stackoverflow.com/questions/8177288/list-of-jsf-2-events 20.http://www.slideshare.net/drspockbr/novidades-do-jsf-22 21.http://www.devmedia.com.br/java-server-faces-technology-conceitos-avancados/25877 22.http://codigofonte.uol.com.br/artigos/o-que-e-o-ajax-e-como-ele-funciona 23.https://docs.oracle.com/javaee/7/tutorial/jsf-intro006.htm 24.http://balusc.omnifaces.org/2006/09/debug-jsf-lifecycle.html 25.http://balusc.omnifaces.org/2011/09/communication-in-jsf-20.html 26.http://www.beyondjava.net/blog/jsf-viewstate-and-csrf-hacker-attacks/ 27.https://www.mkyong.com/jsf2/jsf-2-convertnumber-example/ 28.http://www.mkyong.com/jsf2/jsf-2-convertdatetime-example/ 29. http://pt.slideshare.net/fredmaia/java-web-facil-com-v-raptor 30.http://stackoverflow.com/questions/1247627/java-component-based-vs-request-based-frameworks 31.https://www.mkyong.com/jsf2/composite-components-in-jsf-2-0/ 32.https://www.tutorialspoint.com/jsf/jsf_composite_components.htm 33.http://docs.oracle.com/javaee/6/tutorial/doc/giqzr.html 34.https://emmanuelnerisouza.wordpress.com/2014/11/19/passando-parametros-na-tag-jsf-uiinclude/ 35.https://www.mkyong.com/jsf2/composite-components-in-jsf-2-0/ 36.http://docs.oracle.com/javaee/6/tutorial/doc/giqzr.html 37.https://www.tutorialspoint.com/jsf/jsf_composite_components.htm 38.http://www.devmanuals.com/tutorials/java/jsf/jsf2TagLibrary/composite/insertChildren.html 39.http://www.primefaces.org/docs/guide/primefaces_user_guide_6_0.pdf 40.http://www.coreservlets.com/JSF-Tutorial/ 41.http://www.mkyong.com/tutorials/jsf-2-0-tutorials/

JSF 2

http://docs.oracle.com/javaee/6/tutorial/doc/bnafd.html

https://www.caelum.com.br/apostila-java-testes-jsf-web-services-design-patterns/


http://blog.caelum.com.br/10-razoes-para-migrar-sua-aplicacao-para-jsf-2/

https://pt.wikipedia.org/wiki/JavaServer_Faces

http://richfaces.jboss.org/

http://showcase.omnifaces.org/

http://www.icesoft.org/java/projects/ICEfaces/overview.jsf

http://jdevelopment.nl/jsf-22/

http://blog.caelum.com.br/entenda-os-mvcs-e-os-frameworks-action-e-component-based/

http://www.softwareengineeringsolutions.com/thoughts/frameworks/JSF-lifecycle.htm

http://blog.caelum.com.br/jsf-lidando-com-o-estado-da-view/

http://download.oracle.com/otn_hosted_doc/jdeveloper/j2ee101302/jsf_apps/eventvalidate/sf_avc_converters.html


http://blog.triadworks.com.br/quando-usar-action-ou-actionlistener-com-jsf

http://stackoverflow.com/questions/3909267/differences-between-action-and-actionlistener

http://stackoverflow.com/questions/8177288/list-of-jsf-2-events

http://www.slideshare.net/drspockbr/novidades-do-jsf-22

http://www.devmedia.com.br/java-server-faces-technology-conceitos-avancados/25877

http://codigofonte.uol.com.br/artigos/o-que-e-o-ajax-e-como-ele-funciona

https://docs.oracle.com/javaee/7/tutorial/jsf-intro006.htm

http://balusc.omnifaces.org/2006/09/debug-jsf-lifecycle.html

http://balusc.omnifaces.org/2011/09/communication-in-jsf-20.html

http://www.beyondjava.net/blog/jsf-viewstate-and-csrf-hacker-attacks/

https://www.mkyong.com/jsf2/jsf-2-convertnumber-example/

http://www.mkyong.com/jsf2/jsf-2-convertdatetime-example/

http://stackoverflow.com/questions/1247627/java-component-based-vs-request-based-frameworks

https://www.mkyong.com/jsf2/composite-components-in-jsf-2-0/

https://www.tutorialspoint.com/jsf/jsf_composite_components.htm

http://docs.oracle.com/javaee/6/tutorial/doc/giqzr.html

https://emmanuelnerisouza.wordpress.com/2014/11/19/passando-parametros-na-tag-jsf-uiinclude/

https://www.mkyong.com/jsf2/composite-components-in-jsf-2-0/

http://docs.oracle.com/javaee/6/tutorial/doc/giqzr.html

https://www.tutorialspoint.com/jsf/jsf_composite_components.htm

http://www.devmanuals.com/tutorials/java/jsf/jsf2TagLibrary/composite/insertChildren.html

http://www.primefaces.org/docs/guide/primefaces_user_guide_6_0.pdf

http://www.coreservlets.com/JSF-Tutorial/

http://www.mkyong.com/tutorials/jsf-2-0-tutorials/

Antonio Lazaro Carvalho Borges Serviços Globais de Produção / Mercado Telecom [email protected] ISL Salvador Av Tancredo Neves, Liz empresarial Segundo Andar Iguatemi Salvador – BA T +55 11 3025 1133www.indracompany.com

http://www.indracompany.com

jsf 2 slideshare

Technology