2. Introdução Desenvolvimento Web Aplicações web tornam-se mais e mais importantes Mais e mais complexas: Ajax, validação (server vs. client), efeitos... Exigência mais elevada do cliente durante os anos Interfaces ricas (fáceis de usar) Prazos cada vez mais curtos Desenvolvimento considerado difícil
3. Introdução Surgiram diversos frameworks MVC: Apache Struts WebWork (Struts2) Spring MVC Tapestry JbossSeam E muito outros.. continuam surgindo mais
4. Introdução Problemas Java não nos fornece o bastante para desenvolvermos aplicações web com produtividade Dificuldade para integrar vários frameworks (algumas vezes nem é possível) Falta de padrão para um framework web Ausência de uma API padrão para construir componentes web java
6. Introdução HTML Estático, simples Não tem conexão com Base De Dados Ótimo para criar Home Pages OlaMundo.html <html> <head> <title>Olá Mundo</title> </head> <body> Olá Mundo. </body> </html>
7. Introdução Servlets É uma extensão de servidores Disponibiliza uma interface para o servidor Recursos Dinâmicos para web Interage com os clientes Necessita de um Servlet Container (Ex: Tomcat)
8. Introdução Servlets import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class HelloWorldServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println("<html><body>Olá Mundo</body></html>"); out.close(); } }
9. Introdução Java Server Pages – JSP O JSP foi desenvolvido APENAS para mostrar resultados, o SERVLET deveria fazer a ponte com o banco de dados e fazer as regras de negócio Facilitar a criação de HTML Scriplets: colocar código Java no JSP ;-(
10. Introdução OlaMundo.jsp <html> <body> <% String mensagem = "Olá Mundo!"; out.println(mensagem); %> <br> Muito mais simples de editar o html e muito maiscomplicado de editar o codigo Java <br> </body> </html>
11. Introdução Frameworks Frameworks são projetados com a intenção de facilitar o desenvolvimento de software, habilitando designers e programadores a gastarem mais tempo determinando as exigências do software do que com detalhes de baixo nível do sistema Não reinventar a roda
12. Introdução Struts Framework: Action Based MVC para construções de aplicações WEB Cada solicitação HTTP tem que ser respondida com uma resposta HTTP O .do é mapeado no arquivo struts-config.xml O ActionServlet define o Action correspondente para a solicitação
13. Introdução Struts Framework: Action Based O ActionServlet coloca a entrada em um JavaBean , estes JavaBeans são definidos como FormBeans O Action pode acessar o FormBean efetuar qualquer operação e armazenar o resultado em um ResultBean O Action interage com a camada de negócio onde uma base de dados poderá ser atualizada
15. Introdução Framework: Component Based Rápido aprendizado Baseado em Componentes Deixa o programador despreocupado com a parte visual Programação Web como Desktop Simplicidade Agilidade
17. JSF - Introdução JavaServer Faces é... Uma especificação ? Um framework baseado em componentes ? Interface com o usuário ? Um framework dirigido a eventos ? Padrão de mercado ? RAD ? Um framework MVC ?
18. JSF - Introdução JavaServer Faces é... Uma especificação JSR 127 (JSF 1.0 e JSF 1.1) – 2004 JSF 1.0 – não alcançou o sucesso esperado JSF 1.1 – corrigiu os erros da versão anterior JSR 252 (JSF 1.2) - 2006 (Java EE 5.0) JSF 1.2 – melhor compatibilidade com JSP 2.1 e correção de bugs
19. JSF - Introdução JavaServer Faces é... • JSR 314 (JSF 2.0) • Arquitetura, produtividade, ferramentas RAD, AJAX, melhores componentes UI.. • Em desenvolvimento, porém estão planejando deixar bem integrado e intuitivo.
20. JSF - Introdução JavaServer Faces é... ... um framework baseado em componentes de interface com o usuário JSF é construído sob o conceito de componentes Os componentes são a base para a construção da interface com o usuário Existem componentes padrões equivalentes a quase todas as tags HTML e diversos componentes auxiliares
21. JSF - Introdução JavaServer Faces é... Existem diversas bibliotecas de componentes disponíveis comerciais e open source Os componentes são expressos através de tags em um JSP e posteriormente transformados em HTML
22. JSF - Introdução ... um framework dirigido a eventos Possui um modelo para manipulação de eventos Componentes geram determinados eventos Faz chamada à um método (ação no servidor) O estado da aplicação web muda devido ao evento disparado pelo usuário Um evento pode ser um click em um botão, focar sobre um input ou mesmo alterar o valor de uma combo-box
23. JSF - Introdução ... padrão de mercado É uma especificação (JCP) Java EE 5.0 Suporte de Big Players Sun, Apache, IBM, Oracle, BEA Systems, Borland, ... IDEs (NetBeans, Eclipse, MyEclipse, JDeveloper, ...) Implementações (Sun (R.I), Apache, IBM, ...) Conjuntos de componentes (ADF Faces, Apache MyFaces, WoodStock, IceFaces, JBoss RichFaces, ...)
24. JSF - Introdução .. RAD (Rapid Application Development) 4 camadas: Arquitetura de componentes básica Conjunto de componentes padrão Infra-estrutura da aplicação Ferramenta RAD
25. JSF - Introdução .. RAD (Rapid Application Development) JSF padroniza os primeiros três pontos e permite a criação de ferramentas RAD Utiliza-se IDEs drag-and-drop para construir aplicações Sun Studio Creator, NetBeans, Jdeveloper,Eclipse etc
26. JSF - Introdução ... um framework MVC para construir interfaces com o usuário para aplicações web. JSF inclui: Um conjunto de APIs para: representar os componentes UI e gerenciar o estado destes componentes manipular os eventos e validação de entrada do usuário definir e controlar a navegação entre as páginas dar suporte a internacionalização e acessibilidade
27. JSF - Introdução Resumo É mais do que um framework, é uma especificação baseada em MVC Suporte à internacionalização Facilita criação de telas Facilita a transferência dos dados entre telas e camadas de negócio através da EL Facilidade para criação de componentes
28. JSF - Introdução Resumo Produtividade para conversores recebidos do formulário para os tipos nas classes Flexibilidade para renderização Criar modelos simples de eventos entre interfaces gráficas e as classes no servidor Mecanismos produtivos para validação de campos na tela
29. JSF - Introdução Por que usar JSF? É um padrão de mercado Presente na especificação JEE5.0 e em breve JEE6.0 Suporte de Big Players Fácil de usar e produtivo Fornece separação de funções que envolvem a construção de aplicações Web
30. JSF Por que usar JSF? Alta abstração para desenvolvimento de aplicação web Modelo de programação dirigido a eventos (oposto ao modelo HTTP request/response) Baixa curva de aprendizagem da equipe Vários pontos de extensão (converters, validators, listeners etc) Componentes já prontos!
31. JSF Por que usar JSF? Reusabilidade e estrutura de componentes extensível Acessibilidade (browsers, celulares, pda’s, ...) Segurança OWASP (Open Web Application Security Project) cross-site scripting, session hijacking, execução de métodos, ... Natureza orientada a componentes, validação e pontos de extensão
32. JSF Por que usar JSF? Grande atividade da comunidade em fóruns, listas de discussão, blogs, portais, revistas, livros etc Integração com diversos frameworks: Spring, Spring-Annotation, Spring-Webflow, Hibernate, EJB3, JPA, JBoss Seam, Acegi, JAAS, Struts, Struts2, Shale, Tiles, Facelets, Sitemesh, DWR, EXT, Crank, Beehive-Webflow, GWT, Portlets e muitos outros
33. JSF Por que usar JSF? Testes unitários Shaletesting framework Templates Tiles e Sitemesh Facelets
34. JSF Por que usar JSF? IDEs e WYSIWYG (What you see is what you get) Eclipse (MyEclipse, Europa, Ganymed), IntelliJ IDEA, Jbuilder, NetBeans (Visual WebPack) , IBM Rational App/Web Sun Java Studio Creator , Oracle Jdeveloper, Red Hat Developer Studio (antigo Exadel Studio) e JSFToolbox (Dreamweaver)
35. JSF Por que usar JSF? Grande variedade de componentes comerciais e open- source disponíveis Myfaces Tomahawk Backbase Myfaces Sandbox Simplica (ECruiser Suite) Myfaces Tobago QuipuKit Myfaces Trinidad Blueprints
37. JSF Conceitos chaves do JSF Componentes Renderers Managed-beans Converters / Validators Navegação Eventos Ciclo de vida (Request Lifecycle)
38. JSF Componentes Separa a lógica de negócio da apresentação Cada view é composta por uma hierarquia de componentes Componentes podem ser adicionados na view programaticamente ou via template (JSP por default, ou Facelets para melhor desempenho e fácil desenvolvimento)
39. JSF Componentes são expressos em tags em uma página JSP e em sua maioria são de interface com o usuário Os componentes padrões são divididos em dois grupos: Faces Core <f:view>, <f:loadBundle>, <f:param> HTML wrappers <h:dataTable>, <h:selectOneMenu> Componente = class + [renderer] + tag handler (JSP)
40. JSF Renderers Responsável por exibir o componente no cliente São agrupados em render kits Render kit padrão é o HTML, mas podemos ter WML, SVG etc. Efetua o encode (gera HTML do componente) Efetua o decode (seta o componente com os dados da URL query string e do formulário)
44. JSF Managed beans Podem ser definidos nos escopos de: Application, Session, Request e None É uma classe que envia objetos de negócio para camada de apresentação São registrados no faces-config.xml
45. JSF Managed beans Objetos que sofrerão alterações em seus atributos durante uma requisição, assim como seus métodos podem ser chamados a partir de um command São como as Actions do Struts, porém os form beans são injetados por setters dentro do seu próprio bean Os ManagedBeans serão usados na EL das páginas
47. JSF Obtendo o Managed beans nos escopos: Request: User user = (User)FacesContext.getCurrentInstance().getExternalContext().getRequestMap().get("user"); Session User user = (User)FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"); Inserindo o Managed beans nos escopos: Request: FacesContext.getCurrentInstance().getExternalContext().getRequestMap().put("user", (User)users.getRowData()); Session FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("user", (User)users.getRowData());
48. JSF JSF Value Binding “Binda” valor do componente ao managed-bean O binding ocorre através de JSF Expression Language (EL) Semelhante a JSTL, porém usa-se ‘#{}’ no lugar de ‘${}’ Pode-se executar métodos no modelo através de expressões Não é processada imediatamente como na JSTL A partir da JSF 1.2 utiliza-se a Unified Expression Language (JSP 2.1) que resolve problemas de incompatibilidade entre a JSF-EL e JSP-EL <h:outputText value="#{pessoa.nome}"/>
51. JSF Converters Tem por finalidade converter e/ou formatar objetos do tipo Java para String e vice-versa Converters são bi-direcionais Managed-bean faz: getAsObject() JSP faz: getAsString()
52. JSF Converters JSF já fornece converters padrões para date / time, numbers etc Você pode implementar seu próprio converter: Basta implementar a interface javax.faces.convert.Converter Registrar o converter no faces-config.xml O converter pode atuar de forma explícita(id) ou implícita(class) de acordo com a sua configuração no faces-config.xml
53. JSF Converters javax.faces.convert.Converter Converter é registrado dentro faces-config.xml
54. JSF Converter para que toda propriedade do tipo org.com.model.CPF de qualquer bean use este converter <converter> <converter-for-class> org.com.model.CPF </converter-for-class> <converter-class> org.com.faces.CPFConverter </converter-class> </converter>
55. JSF Converter declarado explicitamente: <h:inputText id=“cpf“ value="#{UserRegistration.user.cpf}"> <f:converter converterId=“br.com.CPFConverter“ /> </h:inputText> Ou implicitamente (converter mapeado para objetos do tipo CPF) <h:inputText id=“cpf“ value="#{UserRegistration.user.cpf}"> NADA AQUI ;-) </h:inputText>
57. JSF Validatores Tem por responsabilidade garantir que o valor informado pelo usuário seja válido Validador trabalha com objetos, não somente com Strings JSF já fornece validadores padrões como required, length, range etc
58. JSF Você pode implementar seu próprio validador Basta implementar a interface javax.faces.validator.Validator Registrar o validador no faces-config.xml Você pode associar um ou mais validadores aum componente
59. JSF javax.faces.validator.Validator Validadores são registrados no faces-config.xml <validator> <validator-id>br.com.validaCPF</validator-id> <validator-class>faces.validaCPF </validator-class> </validator>
60. JSF Validação de obrigatoriedade e comprimento do campo: <h:inputText id=“firstName“ value="#{user.firstName}“ required=“true”> <f:validateLength minimum="2“ maximum="25“ /> </h:inputText>
61. JSF Navegação Navegação de uma página para outra Simples e poderoso sistema de navegação O framework seleciona a próxima view baseado: Na view anterior Resultado(outcome) de uma action EL de ação (ex.: #{mBean.user.save}) Qualquer combinação acima Permite wildcard (‘*’) para páginas de origem (from-view-id)
64. JSF Eventos Componentes geram determinados eventos que por sua vez disparam ações no servidor (método(s) no managed-bean ou listeners) Você também pode implementar listeners de ação associados a outros componentes do formulário Os listeners mais comuns do JSF são ActionListener ValueChangeListener
65. JSF Action event para navegação : <h:commandButton action=“listar” value=“Listar” /> Action event que executa método no managed-bean <h:commandLink action=“#{cadastroBean.cadastrar}” value=“Cadastrar” /> Método no managed-bean public String cadastrar() { // processa evento return “listar”; // retorna para view “listar” }
66. JSF Value-change event que executa método após alterar o valor do componente <h:selectOneMenu id=“UF” value=“#{cadastroBean.uf}” valueChangeListener=“#{cadastroBean.carregaCidades}” onchange=“submit();”> <f:selectItems value=“#{cadastroBean.ufList}” /> </h:selectOneMenu>
67. JSF Método no managed-bean public void carregaCidades(ValueChangeEvent event) { // processa evento String uf = event.getNewValue(); // obtém novo valor this.cidadesList = Servico.carregaCidades(uf); // processa evento }
69. JSF (Fases) São Atendidas pelo Reader Response e Restore Component Tree Restore Component Tree: O conjunto de componentes JSF é criado ou restaurado dependento da requisição (Primeira ou demais vezes executadas)
70. JSF (Fases) Apply request Values: Os componentes irão extrair seu novo valor dos parâmetros da Request, colocando-os em variáveis de estado no servidor
71. JSF (Fases) Process Validations: todos os validadores serão executados, em caso de erro de qualquer valor, a mensagem é alocada no FacesContext, caso contrário ele atualiza (Update Model Values) os valores dos inputs na camada de negócio através da EL
72. JSF (Fases) Invoke Application: Os métodos do ManagedBeans são executados e as regras de navegação (Gravar, Excluir, Alterar,...) são resolvidas. Se tudo ocorrer bem é renderizada pelo container do JSP, caso contrário as mensagens gravadas no FacesContext são apresentadas
73. JSF (Fases) Caso queira pular as fazer de validação e conversão, basta utilizar o parametro immediate=true <h:commandButton action=“proximo" value=“Proximo" immediate="true"/>
74. JSF JSF Extension Points Customizar componentes Phase listeners (antes, depois de qualquer fase) Customizar converters / validators Customizar renderers Customizar ActionListenerImpl para manipular eventos Decorar ou substituir view handler, navigation handler, state manager etc
75. JSF faces-config.xml Arquivo XML para configurar recursos da aplicação Contém regras de navegação, customização e extensão de converters, validators, componentes etc Geralmente está localizado dentro de /WEB-INF/faces-config.xml Pode ser dividido em diretórios e sub-diretórios ou dentro de arquivos jar Seta javax.faces.application.CONFIG_FILES no web.xml Ou então coloca-se META-INF/faces-config.xml dentro de um jar
95. Componentes JSF Atributos importantes: required, immediate, readonly, rendered ..... <h:inputText value="#{numberBean.userNumber}" required="true" validatorMessage="O número tem que ser entre 0 e 100" readonly=“false" rendered=“true” > <h:commandButton value="Desistir" action="desistir" immediate="true"/>
96. Exercício 1 Criar um cadastro de Pessoa. Criar um bean que represente o formulário (Nome, Endereço, Telefone ) Usar f:view e h:form para os formulários Especificar o Action Controller com o atributo de ação h:commandButton Criar uma Action para inserir os dados do formulário, chame a lógica de negócio, guarde os resultados em uma lista e imprima os valores no console Usar o faces-config para declarar o form bean e navegação Após inserir, imprimir no console quem foi inserido e enviar para uma página de sucesso com um botão voltar
97. Exercício 1 (Continuação) Validação: Utilizar o h:messages e h:message <h:messages style="color: red"/> Inserir algumas validações nos campos: <h:inputText value="#{user.name}" required="true" requiredMessage="Campo Obrigatorio" validatorMessage="Tamanho inválido"> <f:validateLength maximum="30" minimum="3"/> </h:inputText><br/> Enviar uma mensagem de sucesso após cadastrar o usuário FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Usuário já Cadastrado!"));
98.
99. Para inserir os objetos no DataModel: dataModel.setWrappedData(Lista)
118. Especificar onde os artefatos (Conversores, Renderizadores, etc.) devem ser colocados no WAR, permitindo ao container encontrá-los sem a necessidade de sua definição em arquivos de configuração