algaworks dwjsf desenvolvimento web com javaserver faces 2a edicao

DWJSF Desenvolvimento Web com JavaServer Faces

www.algaworks.com

Apostila do curso de JavaServer Faces

Conhea mais sobre nossos cursos Java e Scrum

www.algaworks.com softwares e treinamentos 2

ALGAWORKS SOFTWARES E TREINAMENTOS

DWJSF Desenvolvimento Web com JavaServer Faces

40 Horas/Aula

2a Edio

Setembro/2010

www.algaworks.com

+55 (34) 3255-9898

[email protected]

Av. Monsenhor Eduardo, 983, Sala 06 A, Bairro Bom Jesus Uberlndia-MG, CEP. 38400-748


Aprenda muito mais com nosso treinamento presencial


Sobre a empresa

A AlgaWorks uma empresa localizada em Uberlndia/MG, que trabalha para fornecer treinamentos em TI de qualidade e softwares que realmente funcionam.

Estamos no mercado desde 2004 trabalhando com treinamentos e consultorias sobre a plataforma Java.

Nossa misso

Capacitar pessoas em tecnologias e metodologias de desenvolvimento de software e fornecer aplicativos na internet de baixo custo que contribuem para a organizao da vida de milhares de usurios, micro e pequenas empresas de todo o mundo.

Nossa viso

Ser reconhecida como uma das principais empresas de treinamentos em TI do Brasil e como a principal exportadora de software web de baixo custo para indivduos e pequenas empresas do mundo.

Nossos valores

Honestidade

Transparncia

Respeito

Excelncia

Simplicidade

Origem de nosso nome "As algas produzem energia necessria ao seu prprio metabolismo atravs da

fotossntese ... As algas azuis foram os primeiros serem vivos a aparecerem na Terra, e acredita-se que tenham tido um papel fundamental na formao do oxignio da atfosmera."

A palavra em ingls Works, alm de trabalho, pode ser traduzido como algo que

funciona, que tem sucesso. AlgaWorks foi o nome dado para a nossa empresa, e quer dizer que:

Queremos ser uma empresa independente, que atravs de nosso prprio esforo conseguimos produzir uma energia suficiente para a nossa sobrevivncia;

No queremos depender de investidores externos que no agregam conhecimento ao negcio;

Desejamos criar alianas com empresas, autnomos, estudantes e profissionais e transmitir todo o nosso conhecimento em tecnologia;

Fornecemos softwares que funcionam e agregam valor ao negcio, sem complicaes;

Tudo isso deve funcionar com sucesso para ajudar nossos clientes, parceiros, fornecedores, colaboradores e acionistas serem mais felizes.




Nossos cursos Conhea nossos cursos abaixo ou acesse www.algaworks.com/treinamentos para mais informaes.

Java Bsico e Orientao a Objetos [24 horas]

Java Avanado [32 horas]

Migrando para o Java 5 [8 horas]

Desenvolvimento Web com HTML, CSS e JavaScript [12 horas]

Desenvolvimento Web com Servlets e JSP [36 horas]

Desenvolvimento da Camada de Persistncia com Hibernate [24 horas]

Desenvolvimento Web com JavaServer Faces [40 horas]

Desenvolvimento de Relatrios com JasperReports e iReport [24 horas]

Desenvolvimento Avanado com Java EE [32 horas]

Preparatrio para Certificao de Programador Java [32 horas]

Modelagem UML [28 horas]

Gerenciamento gil de Projetos com Scrum [16 horas]




Sobre esta apostila

Esta apostila faz parte do material didtico distribudo pela AlgaWorks para ministrar o curso Desenvolvimento Web com JavaServer Faces.

Apesar da distribuio desta apostila para fins no-comerciais ser permitida, recomendamos que voc sempre prefira compartilhar o link da pgina de download (http://www.algaworks.com/treinamentos/apostilas) ao invs do arquivo, pois atualizamos nosso material didtico constantemente para corrigir erros e incluir melhorias.

Para voc realmente aproveitar o contedo desta apostila e aprender a tecnologia

JavaServer Faces, necessrio que voc j tenha conhecimento prvio da plataforma Java, Orientao a Objetos, banco de dados e desenvolvimento web com JSP.

Se voc quiser se especializar ainda mais em JSF ou outras tecnologias, sugerimos

que faa os cursos presenciais na AlgaWorks, pois, alm de usarmos este material didtico ou outros com qualidade semelhante, voc ficar por dentro das ltimas novidades e ter a chance de aprender com a experincia de nossos instrutores.

Licena desta obra O contedo desta apostila est protegido nos termos da licena

Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported (http://creativecommons.org/licenses/by-nc-nd/3.0/deed.pt_BR) para a AlgaWorks Softwares, Treinamentos e Servios Ltda, CNPJ 10.687.566/0001-97. Isso significa que voc pode compartilhar (copiar, distribuir e transmitir) esta obra para uso no-comercial, desde que sempre atribua os crditos AlgaWorks. vedado a criao de materiais derivados, portanto, voc no pode alterar, transformar ou criar algo em cima dessa obra.

Para qualquer reutilizao ou distribuio, voc deve deixar claro a terceiros os termos da licena a que se encontra submetida esta obra.

Qualquer das condies acima pode ser renunciada se voc obtiver permisso da AlgaWorks. Para uso comercial, voc dever comprar os direitos de uso limitados a um nmero especfico de alunos. Neste caso, fale com nossa rea comercial.

Encontrou erros ou gostaria de sugerir melhorias? Se voc encontrar algum erro neste material ou tiver alguma sugesto, crtica ou

elogio, por favor, envie um e-mail para [email protected].




Sobre o autor

Thiago Faria de Andrade ([email protected]) fundador e diretor da AlgaWorks. Iniciou seu interesse por programao aos 14 anos, quando desenvolveu um software para entretenimento e se tornou um dos mais populares no Brasil e outros pases de lngua portuguesa.

Graduado em Sistemas de Informao e certificado como programador Java pela Sun/Oracle (SCJP), Thiago trabalhou em consultorias para grandes empresas de Uberlndia/MG, co-fundou a OpenK Tecnologia e trabalhou como diretor de tecnologia e treinamentos nesta empresa por quase 6 anos.

Fundou a AlgaWorks aps adquirir 100% das cotas da OpenK Treinamentos, e no ano de 2010, possua experincia profissional de mais de 10 anos, sendo 7 dedicados tecnologia Java.

Alm de programar, Thiago ministra cursos, palestras e presta consultorias sobre Java para rgos do governo, universidades, pequenas e grandes empresas e pessoas fsicas, tendo acumulado aproximadamente 2.500 horas em salas de aulas e auditrios, at o ano de 2010.




Contedo do DVD O DVD que acompanha o material de estudo do curso DWJSF contm arquivos teis para o aprendizado. Os seguintes arquivos e programas so disponibilizados atravs deste DVD: Bibliotecas do Hibernate, JFreeChart, MySQL JDBC, Mojarra (implementao JSF da Sun), JSTL, Facelets, Richfaces, Commons BeanUtils, Commons Digester, Commons Logging, Log4j e SL4J Log4j [DVD]:\Bibliotecas Documentao do Hibernate, JFreeChart, JSF, Facelets e Richfaces [DVD]:\Documentao Eclipse, NetBeans, JBoss Tools, EMS SQL Manager for MySQL, Toad for MySQL e MySQL GUI Tools [DVD]:\Ferramentas Servidor MySQL [DVD]:\MySQL Server Kit de desenvolvimento Java [DVD]:\JDK Apache Tomcat [DVD]:\Tomcat

* DVD distribudo apenas para clientes do curso.




ndice 1. Objetivo do curso .................................................................................................................. 12

2. Introduo ............................................................................................................................. 13

2.1. O que JavaServer Faces? ........................................................................................... 15

2.2. Principais componentes ................................................................................................. 15

2.3. Componentes adicionais ................................................................................................ 16

2.4. Renderizao de componentes ..................................................................................... 17

3. Ambiente de desenvolvimento .............................................................................................. 19

3.1. Escolhendo a ferramenta de desenvolvimento .............................................................. 19

3.2. Escolhendo um container web ....................................................................................... 21

3.3. Instalando e configurando o Eclipse .............................................................................. 22

3.4. Instalando e configurando o Apache Tomcat ................................................................. 24

3.5. Integrando o Eclipse com o Apache Tomcat ................................................................. 26

4. Primeiro projeto JSF ............................................................................................................. 30

4.1. Introduo....................................................................................................................... 30

4.2. Escolhendo uma implementao de JSF ....................................................................... 30

4.3. Criando um novo projeto ................................................................................................ 30

4.4. Codificando a primeira aplicao JSF ............................................................................ 34

4.5. Implantao e execuo da aplicao ........................................................................... 40

4.6. Gerando um WAR da aplicao ..................................................................................... 42

5. Desvendando o mistrio ....................................................................................................... 45

5.1. Introduo....................................................................................................................... 45

5.2. Managed bean UsuarioBean.......................................................................................... 45

5.3. Arquivo faces-config.xml ................................................................................................ 47

5.4. Pgina ola.jsp ................................................................................................................. 49

5.5. Arquivo web.xml ............................................................................................................. 51

5.6. Conhecendo mais sobre o diretrio WEB-INF ............................................................... 52

5.7. Como funciona nos bastidores ....................................................................................... 52

5.8. JSF apenas isso? ........................................................................................................ 54

6. Ciclo de vida ......................................................................................................................... 56

7. Managed beans .................................................................................................................... 58

7.1. Introduo....................................................................................................................... 58

7.2. Configurando beans ....................................................................................................... 58

7.3. Expresses de ligao de valor ..................................................................................... 58

7.4. Escopo dos beans .......................................................................................................... 59

7.5. Backing beans ................................................................................................................ 59

7.6. Definindo valores de propriedades ................................................................................ 60

7.7. Inicializando listas e mapas ............................................................................................ 60

7.8. Usando expresses compostas ..................................................................................... 61




7.9. Usando expresses de ligao de mtodo .................................................................... 62

7.10. Aplicao de exemplo .................................................................................................... 62

8. Navegao ............................................................................................................................ 66

8.1. Introduo....................................................................................................................... 66

8.2. Navegao simplificada ................................................................................................. 66

8.3. Filtro pela viso de origem ............................................................................................. 67

8.4. Navegao dinmica ...................................................................................................... 68

8.5. Filtro pela ao de origem .............................................................................................. 71

8.6. Usando redirecionamentos ............................................................................................ 71

8.7. Usando padres ............................................................................................................. 72

9. Componentes bsicos .......................................................................................................... 73

9.1. Introduo....................................................................................................................... 73

9.2. Formulrios..................................................................................................................... 73

9.3. Um pouco sobre os atributos comuns ............................................................................ 74

9.4. Entrada de textos ........................................................................................................... 77

9.5. Sada de textos .............................................................................................................. 79

9.6. Imagens .......................................................................................................................... 80

9.7. Menus, caixas de listagem e item de seleo ................................................................ 81

9.8. Campos de checagem e botes rdio ........................................................................... 85

9.9. Itens de seleo ............................................................................................................. 88

9.10. Botes e links ................................................................................................................. 90

9.11. Painis ............................................................................................................................ 92

9.12. Mensagens ..................................................................................................................... 95

10. Tabela de dados ................................................................................................................... 99

10.1. O componente h:dataTable ............................................................................................ 99

10.2. Cabealhos e rodaps ................................................................................................. 101

10.3. Componentes dentro de clulas................................................................................... 102

10.4. Aplicando estilos tabela ............................................................................................. 103

11. Internacionalizao ............................................................................................................. 105

11.1. Usando message bundles ............................................................................................ 105

11.2. Pacotes de mensagens para outras localidades ......................................................... 106

12. Converso e validao ....................................................................................................... 108

12.1. Introduo..................................................................................................................... 108

12.2. Conversores padro de nmeros e datas .................................................................... 109

12.3. Alternativas para definir conversores ........................................................................... 114

12.4. Customizando mensagens de erro de converso ....................................................... 115

12.5. Usando validadores ...................................................................................................... 119

12.6. Customizando mensagens de erros de validao ....................................................... 120

12.7. Ignorando validaes com o atributo immediate.......................................................... 121

12.8. Criando conversores personalizados ........................................................................... 122




12.9. Criando validadores personalizados ............................................................................ 125

13. Manipulando eventos .......................................................................................................... 128

13.1. Introduo..................................................................................................................... 128

13.2. Capturando eventos de ao ....................................................................................... 128

13.3. Capturando eventos de mudana de valor .................................................................. 129

14. Sistema financeiro com JSF e Hibernate ........................................................................... 133

14.1. Introduo..................................................................................................................... 133

14.2. O que persistncia de dados? .................................................................................. 133

14.3. Mapeamento objeto relacional (ORM) ......................................................................... 133

14.4. Hibernate e JPA ........................................................................................................... 134

14.5. Preparando o ambiente ................................................................................................ 135

14.6. Nosso modelo de domnio ............................................................................................ 135

14.7. Criando as classes de domnio .................................................................................... 136

14.8. Criando as tabelas no banco de dados ........................................................................ 139

14.9. Mapeando classes de domnio para tabelas do banco de dados ................................ 139

14.10. Configurando o Hibernate ......................................................................................... 141

14.11. Criando a classe HibernateUtil ................................................................................. 143

14.12. Implementando classes de negcio .......................................................................... 144

14.13. Criando uma folha de estilos e incluindo imagens ................................................... 146

14.14. Traduzindo as mensagens padro do JSF ............................................................... 148

14.15. Configurando managed beans e regras de navegao ............................................ 148

14.16. Conversor genrico para tipo Enum ......................................................................... 149

14.17. Conversor para entidade Pessoa ............................................................................. 150

14.18. Construindo uma tela de menu do sistema .............................................................. 151

14.19. Construindo a tela para cadastro de contas ............................................................. 151

14.20. Construindo a tela para consulta de contas ............................................................. 155

14.21. Um sistema financeiro funcionando! ......................................................................... 158

15. Data Access Object ............................................................................................................ 160

15.1. Introduo..................................................................................................................... 160

15.2. Criando um DAO genrico ........................................................................................... 160

15.3. Criando DAOs especficos ........................................................................................... 161

15.4. Criando uma fbrica de DAOs ..................................................................................... 163

15.5. Instanciando e usando os DAOs .................................................................................. 164

15.6. Valeu a pena usar DAO? ............................................................................................. 165

16. JBoss RichFaces e AJAX ................................................................................................... 166

16.1. Introduo..................................................................................................................... 166

16.2. Configurando e testando o ambiente ........................................................................... 166

16.3. Adicionando suporte AJAX em componentes no-AJAX ............................................ 170

16.4. Adicionando suporte AJAX no cadastro de contas ...................................................... 171

16.5. Componente de calendrio .......................................................................................... 171




16.6. Componente de caixa de sugesto .............................................................................. 172

16.7. Componente de painel com abas ................................................................................ 174

16.8. Componente de tabela de dados ................................................................................. 175

16.9. Componente de paginao de dados .......................................................................... 177

16.10. Clicar e arrastar com JBoss Tools ............................................................................ 178

17. Facelets .............................................................................................................................. 179

17.1. Introduo..................................................................................................................... 179

17.2. Instalando Facelets no projeto ..................................................................................... 179

17.3. Adequando nossas pginas para XHTML ................................................................... 180

17.4. Reutilizao com templating ........................................................................................ 181

17.5. Reutilizao com composition ...................................................................................... 183

18. Segurana com JAAS ......................................................................................................... 185

18.1. Introduo..................................................................................................................... 185

18.2. Criando tabelas de segurana no banco de dados ..................................................... 185

18.3. Configurando o domnio de segurana ........................................................................ 186

18.4. Integrando a aplicao ao domnio de segurana ....................................................... 187

18.5. Validando a segurana ................................................................................................. 189

18.6. Criando o formulrio de login e personalizando telas de erro ..................................... 189

18.7. Protegendo componentes contra aes dos usurios ................................................. 192

18.8. Exibindo o nome do usurio logado e criando um link para logout ............................. 193

19. Conhecendo o JFreeChart ................................................................................................. 194

19.1. Introduo..................................................................................................................... 194

19.2. Criando grficos em pginas JSF ................................................................................ 195

20. Concluso ........................................................................................................................... 201

21. Bibliografia .......................................................................................................................... 202

22. Fique atualizado! ................................................................................................................. 203

23. Livros recomendados.......................................................................................................... 204




1. Objetivo do curso As constantes evolues da tecnologia exigem das pessoas um freqente

aperfeioamento de seus conhecimentos profissionais. No dia-a-dia, muitas pessoas no conseguem acompanhar as mudanas e novidades nas tecnologias.

Para estes profissionais, a AlgaWorks oferece treinamentos personalizados, ministrados por pessoas com larga experincia no mercado de software. O contedo programtico de nossos cursos se adequam realidade, abordando os temas com aulas presenciais realizadas com muita prtica.

Tudo isso garante um investimento em TI que se traduz num diferencial competitivo para a empresa, pois sua equipe estar totalmente capacitada a extrair todo seu potencial.

Este curso tem o objetivo de apresentar a JavaServer Faces e alguns frameworks,

bibliotecas e especificaes, como Hibernate, Richfaces, Facelets, JAAS e JFreeChart, utilizados amplamente para desenvolvimento de sistemas em todo o mundo.

Aps a concluso deste curso, os alunos devero estar aptos a: Entender e criar managed beans; Entender o ciclo de vida do JSF; Utilizar navegao entre pginas; Entender e utilizar os principais componentes; Trabalhar com validao de campos; Criar pginas com internacionalizao; Utilizar componentes de projetos open-source, como Richfaces; Criar sistemas que utilizem AJAX; Utilizar Facelets para templating de pginas JSF; Efetuar download e configurao do Hibernate; Mapear classes com Hibernate; Entender e utilizar o padro de projeto DAO; Desenvolver classe de DAO genrico; Recuperar, gravar e consultar objetos com Hibernate; Criar grficos com dados dinmicos usando JFreeChart; Implementar sistemas que suportem autenticao e autorizao usando JAAS; Desenvolver um projeto completo usando boas prticas de programao, padres de

projetos e frameworks de mercado, com separao em camadas.




2. Introduo Com o avano da tecnologia sobre redes de computadores e com o crescimento da

internet, as pginas web esto se tornando cada vez mais atraentes e cheias de recursos que aumentam a interatividade com o usurio. So verdadeiras aplicaes rodando sobre a web.

Quando falamos em aplicaes web, estamos nos referindo a sistemas onde toda a programao fica hospedada em servidores na internet, e o usurio (cliente) normalmente no precisa ter nada instalado em sua mquina para utiliz-los, alm de um navegador (browser). O acesso s pginas (telas) desses sistemas feita utilizando um modelo chamado de request-response, ou seja, o cliente solicita que alguma ao seja realizada (request) e o servidor a realiza e responde para o cliente (response). Na plataforma Java, esse modelo foi implementado inicialmente atravs da API de Servlets e JSP (JavaServer Pages). Um Servlet estende a funcionalidade de um servidor web para servir pginas dinmicas aos navegadores, utilizando o protocolo HTTP. J o JSP, utilizando-se de uma sintaxe especial, permite que desenvolvedores web criem pginas que possuam programao Java, semelhante ao PHP e ASP, porm muito mais robusto e padronizado.

A interao entre o cliente e uma aplicao web ilustrada no diagrama abaixo.

Uma aplicao web em Java

O cliente envia uma requisio HTTP ao servidor web. No mundo Java os servidores

web so chamados de Servlet Container, pois implementam a especificao de Servlet e JSP. O servidor converte a requisio (request) em um objeto do tipo HttpServletRequest. Este objeto ento passado aos componentes web, que podem interagir com JavaBeans ou mesmo um banco de dados, para que possa ser gerado um contedo dinmico. Em seguida, o componente web gera um objeto HttpServletResponse, que representa a resposta (response) ao cliente. Este objeto utilizado para que o contedo dinmico gerado seja enviado ao navegador (usurio).

Desde o lanamento de Servlets e JSPs, outras tecnologias Java e frameworks foram surgindo com o objetivo de melhorar a produtividade e recursos no desenvolvimento de aplicaes web. Atualmente JavaServer Faces a tecnologia do momento, requisitada na maioria das oportunidades de emprego para desenvolvedores Java. Esta tecnologia foi baseada em outras j existentes, como pode ver na imagem abaixo.




Veja que Servlet a base de todas as aplicaes Java para web. As outras tecnologias criam um nvel de abstrao sobre Servlets, criando aplicaes mais fceis de manuteno, escalveis e robustas. Vrios outros frameworks baseados em Servlets foram desenvolvidos sobre propriedade de alguma empresa ou open-source, e muitos deles fizeram sucesso por muito tempo, mas JSF revolucionou o desenvolvimento web e agora est em grande expanso.

Voc aprender como instalar, configurar e desenvolver sistemas utilizando JavaServer Faces, a tecnologia que foi criada para que o desenvolvimento de aplicaes web fosse parecido com o de aplicaes clientes desktop em termos de produtividade e funcionalidades. O conceito bsico deste framework a existncia de classes que representam os componentes (formulrios, botes, campos de entrada, tabelas e etc) de sua pgina JSP. Veremos muitos mais detalhes sobre esta tecnologia adiante.

Em aplicaes corporativas, extremamente importante gravar os dados de cadastros,

transaes e etc. Os bancos de dados vieram para facilitar a vida dos programadores. Hoje existem diversos sistemas gerenciadores de banco de dados (SGBD) no mercado, uns trazendo facilidades de administrao, outros com suporte a grandes quantidades de dados, alguns totalmente gratuitos e outros muito caros! Enfim, o importante saber que, como programador, voc certamente ter que utilizar algum banco de dados.

Como veremos nesta apostila, existem frameworks que facilitam a vida de um programador orientado a objetos (sim, para voc estar lendo esta apostila, voc deve ser um programador orientado a objetos) para trabalhar com banco de dados.

O Hibernate um excelente framework que trabalha entre o banco de dados e sua aplicao Java. A figura abaixo ilustra como isso ocorre.

Com o Hibernate, ganhamos muito em agilidade e tornamos nossos produtos muito mais flexveis, pois como veremos, fica muito fcil trocar o banco de dados inteiro com quase nenhum esforo.

O objetivo desta apostila lhe ensinar JavaServer Faces, porm ensinaremos tambm como criar uma aplicao usando JSF e Hibernate. Voc j deve conhecer pelo menos o bsico de Hibernate. Abordaremos tambm outros padres e conceitos importantes no desenvolvimento de software, como por exemplo, o DAO (Data Access Object), utilizado na camada de persistncia, o famoso MVC (Model, View e Controller) e outros.

O que ns desejamos que voc tenha um timo aprendizado e que entre mais preparado neste mercado de trabalho, que necessita rapidamente de profissionais cada vez mais qualificados.




Sinta-se a vontade em voltar a esta apostila sempre que tiver dvidas. Nos primeiros dias voc poder achar alguns cdigos estranhos, mas ao longo do tempo vai ver que tudo se encaixa perfeitamente!

2.1. O que JavaServer Faces? JavaServer Faces, tambm conhecido como JSF, uma tecnologia para

desenvolvimento web que utiliza um modelo de interfaces grficas baseado em eventos. Esta tecnologia foi definida pelo JCP (Java Community Process), o que a torna um padro de desenvolvimento e facilita o trabalho dos fornecedores de ferramentas ao criarem produtos que valorizem a produtividade no desenvolvimento de interfaces visuais, inclusive com recursos de drag-and-drop.

JSF baseado no padro de projeto MVC (Model-View-Controller), o que torna o desenvolvimento de sistemas menos complicado, pois a separao entre a visualizao e regras de negcio muito clara.

O padro MVC separa o sistema em trs responsabilidades (modelo, visualizao e controle), onde o modelo responsvel por representar os objetos de negcio, manter o estado da aplicao e fornecer ao controlador o acesso aos dados. A visualizao responsvel pela interface do usurio. Ela que define a forma como os dados so apresentados e encaminha as aes do usurio para o controlador. O controlador responsvel por ligar o modelo e a visualizao, interpretando as solicitaes do usurio, traduzindo para uma operao no modelo (onde so realizadas efetivamente as mudanas no sistema) e retornando a visualizao adequada solicitao.

Em JSF, o controle feito atravs de um servlet chamado Faces Servlet, por arquivos XML de configurao e por vrios manipuladores de aes e observadores de eventos. O Faces Servlet recebe as requisies dos usurios na web, redireciona para o modelo e envia uma resposta. Os arquivos de configurao possuem informaes sobre mapeamentos de aes e regras de navegao. Os manipuladores de eventos so responsveis por receber os dados da camada de visualizao, acessar o modelo e devolver o resultado para o usurio atravs do Faces Servlet.

O modelo representado por objetos de negcio, que executa uma lgica de negcio ao receber dados oriundos da camada de visualizao.

A visualizao composta por uma hierarquia de componentes (component tree), o que torna possvel unir componentes para construir interfaces mais ricas e complexas.

Arquitetura do JavaServer Faces baseada no MVC

2.2. Principais componentes

O verdadeiro poder de JavaServer Faces est em seu modelo de componentes de interface do usurio, onde aplicaes so desenvolvidas com um conjunto de componentes que podem ser renderizados em diversas formas para vrios tipos de clientes, como por exemplo para um browser da web, celular, etc.




JSF similar tecnologia proprietria ASP.NET, pois o modelo de componentes oferece alta produtividade aos desenvolvedores, permitindo a construo de interfaces para web usando um conjunto de componentes pr-construdos, ao invs de criar interfaces inteiramente do zero. Existem vrios componentes de visualizao JSF, desde os mais simples, como um outputLabel, que apresenta simplesmente um texto, ou um dataTable, que representa dados tabulares de uma coleo que pode vir do banco de dados.

A especificao do JSF fornece um conjunto de componentes visuais bsicos em sua implementao de referncia. Ela inclui duas bibliotecas de componentes, como a HTML, que possui componentes que representam diversos elementos HTML e a biblioteca Core, que responsvel por tarefas comuns no desenvolvimento de sistemas, como internacionalizao, validao e converso de dados de entrada. Alm de fornecer uma biblioteca base de componentes, a API da JSF suporta a extenso e criao de novos componentes, que podem fornecer funcionalidades adicionais.

Os principais componentes que a implementao de referncia do JSF fornece so: Formurio Campos de entrada de texto Campo de entrada de senha Rtulos com textos Textos de uma nica linha Links Botes Mensagens Painis Tabela HTML Tabela de dados (grid) Coluna de tabela de dados Etc

2.3. Componentes adicionais

Atualmente existem diversas empresas que trabalham na criao de componentes personalizados. Como exemplo, podemos citar a Oracle, com o ADF Faces Rich Client, IceSoft, com o IceFaces, JBoss (Redhat), com o Richfaces, e etc. Muitos desses componentes incluem mltiplos renderizadores para diversos tipos de clientes, tabelas avanadas, componentes para captura de datas e cores, menus suspensos, botes, barras de progresso, telas suspensas para seleo de valores e etc.

Veja alguns exemplos de sistemas usando diversas bibliotecas de componentes:

Aplicao de exemplo usando ADF Faces Rich Client




Aplicao de exemplo usando IceFaces

Software de gesto de projetos usando Richfaces

2.4. Renderizao de componentes

A tecnologia JSF possui capacidade de utilizar renderizadores de componentes plugveis. Isso se traduz na capacidade dos componentes se apresentarem diferentes dependendo do tipo do cliente que est sendo utilizado. Por exemplo, um browser como o




Firefox ou Internet Explorer, deve receber cdigo HTML para que possa ser exibido ao usurio, enquanto um dispositivo mvel como um celular poder ser capaz de exibir apenas contedos WML.

Um mesmo componente JSF pode se adequar aos dois tipos de contedos, dependendo do que for adequado no momento. Isso possvel graas ao desacomplamento dos componentes visuais do cdigo de renderizao, tornando possvel criar mltiplos renderizadores para um mesmo componente. Diferentes renderizadores podem ento ser associados ao componente e em tempo de execuo decidido qual renderizador ser utilizado, baseado no tipo do cliente que enviou a requisio.

Um componente de tabela de dados sendo renderizado para clientes WML e HTML




3. Ambiente de desenvolvimento

3.1. Escolhendo a ferramenta de desenvolvimento

Atualmente existem vrias ferramentas que suportam o desenvolvimento com JSF. Algumas delas possuem um ambiente visual que exibe uma representao grfica da tela em desenvolvimento e permite arrastar e soltar componentes a partir de uma paleta. Outras ferramentas apiam mais na edio do arquivo de configurao e na escrita de cdigos e templates.

Eclipse

Eclipse com plugins do JBoss Tools




MyEclipse IDE

NetBeans




JDeveloper Vrias ferramentas so baseadas no Eclipse, como o JBoss Developer Studio (que

basicamente o Eclipse + JBoss Tools) e o MyEclipse IDE, pois o Eclipse considerado uma plataforma muito flexvel e atualmente a mais usada em todo o mundo.

Disponibilizamos os arquivos de instalao das IDEs grtis mais importantes na comunidade no DVD que acompanha esta apostila, porm utilizaremos o Eclipse para desenvolver os exemplos e exerccios da apostila.

O Eclipse distribudo para desenvolvedores Java EE no possui recursos visuais interessantes para criar pginas JSF, porm apia visualmente na configurao da aplicao nesta tecnologia. Nossa escolha pelo Eclipse pelo fato de ser uma ferramenta rpida e com excelente suporte a edio de cdigo Java e JSP (isso inclui JSF).

Antes de terminar nosso estudo, instalaremos o plugin JBoss Tools para trabalharmos com a biblioteca Richfaces, e a tiraremos proveito da funcionalidade arrastar-e-soltar.

O Eclipse pode ser baixado em http://www.eclipse.org, mas felizmente j possumos o arquivo de instalao no DVD. A instalao dessa ferramenta ser apresentada em um prximo tpico.

3.2. Escolhendo um container web

Para executar aplicaes desenvolvidas em JSF, voc precisar de um servidor com um container web instalado. Um container web um programa que recebe requisies HTTP, executa componentes Java (Servlets) e devolve para o usurio (browser) cdigo HTML, alm de todos os outros recursos necessrios (como imagens, vdeos, folhas de estilo e etc). Na verdade, trata-se de um servidor web (como o Apache HTTPD), porm com outras funcionalidades para executar cdigo Java de acordo com a especificao Java EE.

A JavaServer Faces foi construda baseada na tecnologia de Servlets e JSP, mas voc no obrigado a saber sobre elas para desenvolver em JSF, apesar de ser recomendado.

Existem diversos containers web (e outros containers completos, que tambm no deixam de ser web) disponveis para download, e o melhor, sem custo algum para implantar em produo. Apesar de tantas ofertas gratuitas de excelentes produtos, algumas empresas ainda vendem licenas de seus prprios servidores, pois oferecem suporte diferenciado ao cliente e normalmente implementam funcionalidades que os servidores gratuitos talvez no possuam.




Dentre os vrios servidores que so containeres web, podemos destacar os mais conhecidos:

Apache Tomcat Jetty JBoss AS Glassfish JOnAS Apache Geronimo IBM WebSphere Application Server Oracle WebLogic Server (antigo BEA WebLogic Server) Oracle Application Server Para desenvolver nossos cdigos, usaremos o Apache Tomcat, pois mais leve, grtis

e possui tudo que precisamos para executar nossos exemplos. Como estes servidores so baseados nas especificaes da tecnologia Java EE, voc

pode implantar os softwares que desenvolveremos neste curso em qualquer servidor mais atual compatvel com a Java EE.

O download do Apache Tomcat pode ser feito em http://tomcat.apache.org. O DVD que acompanha a apostila j possui o arquivo de instalao desse servidor, e aprenderemos a instal-lo ainda neste captulo.

3.3. Instalando e configurando o Eclipse

A instalao do Eclipse simples, basta descompactar o arquivo de instalao (com extenso .zip) no local desejado.

Para iniciar o Eclipse, voc j deve ter a Java SDK 5 ou superior instalada em seu

computador. Execute o arquivo eclipse.exe na pasta eclipse que foi descompactada e a ferramenta ser iniciada.




Aparecer uma tela solicitando um diretrio onde o Eclipse gravar seus projetos, que

chamado de workspace. Pressione o boto OK para usar o diretrio sugerido ou selecione outro local.

Aguarde o carregamento e a tela Welcome aparecer, indicando que a instalao ocorreu com sucesso.




3.4. Instalando e configurando o Apache Tomcat

O processo de instalao do Apache Tomcat simples, basta descompactar o arquivo com extenso .zip no local desejado.

Uma vez finalizado, tem-se um servidor de aplicaes pronto para produo. De

qualquer forma, o site disponibiliza toda a documentao necessria para resolver problemas encontrados e esclarecer dvidas com relao ao processo de instalao e configurao do servidor.

Para entender um pouco sobre o funcionamento do Tomcat, examine os diretrios criados durante o processo de instalao. Os principais so:

bin Executveis, incluindo os aplicativos para iniciar e para encerrar a execuo do

servidor.

conf Arquivos de configurao do Tomcat. O arquivo server.xml, em particular, define uma srie de parmetros para a execuo do servidor, como por exemplo, a porta onde o servidor ir receber requisies (essa porta , por default, 8080), devendo ser examinado com cuidado e modificado conforme as necessidades.

logs Arquivos de log do servidor. Alm de gerar arquivos de log contendo entradas para cada requisio recebida, como qualquer servidor web, o Tomcat tambm pode gerar arquivos de log com tudo o que as aplicaes desenvolvidas enviam para a sada padro do sistema.

work Diretrio temporrio do Tomcat. Esse diretrio utilizado, por exemplo, para realizar a recompilao automtica de pginas JSP.

webapps Nesse diretrio so instaladas as diversas aplicaes web desenvolvidas.

Para verificar se a instalao foi bem sucedida, acesse o diretrio bin e execute o arquivo startup.bat (ou startup.sh para Linux) para iniciar o servidor. Voc j deve ter a Java SDK 5 ou superior instalada em seu computador para efetuar este passo.




Uma console ser exibida e os passos da inicializao do servidor sero impressos nela.

Abra um browser (pode ser o Firefox, que melhor que o Internet Explorer) e acesse o endereo http://localhost:8080. Se a tela abaixo aparecer para voc, parabns, o Tomcat est instalado e funcionando em seu computador.




Agora interrompa a execuo do Tomcat executando o arquivo shutdown.bat (shuwdown.sh no Linux), ou na console do servidor, pressione em conjunto as teclas Ctrl + C.

3.5. Integrando o Eclipse com o Apache Tomcat

Para tornar nosso estudo mais prtico, iremos integrar o Apache Tomcat ao Eclipse. Desta forma, voc poder iniciar e parar o Tomcat e implantar as aplicaes a partir do ambiente de desenvolvimento.

Acesse o menu Window, Preferences. Na tela que se abre, clique em Server e depois em Runtime Environments.




Clique sobre o boto Add.... A tela New Server Runtime Environment ser aberta para seleo do servidor.

Localize e selecione a verso que mais se aproxima da que usaremos, neste caso,

Apache Tomcat v6.0. Pressione Next >.




Clique sobre o boto Browse... e localize o diretrio raiz onde o Apache Tomcat foi instalado, em seguida pressione Finish e depois OK.

Para testar a integrao do Eclipse com o Tomcat, localize e clique sobre aba Servers.

Se no encontrar esta aba ou ela estiver desaparecido, acesse o menu Window,

Show view e Others. Localize a opo Servers e clique em OK.

Pronto. Agora clique com o boto direito na rea branca, selecione New e clique em

Server.




Selecione a opo Tomcat 6.0 Server e clique em Finish.

O Tomcat aparecer na lista de servidores integrados ao Eclipse. Clique com o boto

direito sobre este servidor e selecione a opo Start.

Neste momento, o Apache Tomcat est funcionando integrado ao Eclipse. Voc pode

parar, configurar ou publicar aplicaes no servidor a partir do ambiente de desenvolvimento.




4. Primeiro projeto JSF

4.1. Introduo

Nossa primeira aplicao em JSF ser bem simples. O objetivo que voc consiga preparar o ambiente de um novo projeto e deixe-o funcionando no servidor.

Voc poder ficar com vrias dvidas do tipo como funciona isso?, porque tive que escrever aquilo?. No se preocupe! Nos prximos captulos aprofundaremos em cada detalhe da tecnologia.

4.2. Escolhendo uma implementao de JSF A JSF foi criada atravs do Java Community Process (JCP), que uma entidade

formada pelas mais importantes empresas de tecnologia do mundo e especialistas em diversos assuntos.

O JCP composto por vrios grupos de trabalho, que so chamados de JSR (Java Specification Request). Uma JSR um projeto de desenho de uma nova tecnologia. O artefato produzido atravs das JSRs so documentaes, interfaces e algumas classes que especificam como deve funcionar um novo produto.

A JSF foi criada e controlada pelo JCP atravs de JSRs (uma para cada verso). Quando uma JSR finalizada, empresas fornecedoras de tecnologia tm a chance de entender a especificao e implementar um produto final compatvel com o proposto pela especificao.

No caso da JSF, as implementaes mais conhecidas atualmente so a da prpria Sun, conhecida como Mojarra, e a da Apache, chamada de MyFaces Core.

Todas as implementaes devem fazer a mesma coisa, mas o que diferencia uma da outra a qualidade que foi desenvolvido o produto, documentao disponvel, suporte oferecido pela empresa e principalmente pela comunidade, etc.

Usaremos neste curso a implementao da Sun, a Mojarra verso 1.2.x. O DVD que acompanha esta apostila possui o arquivo distribudo pela Sun, mas caso voc tenha interesse em conhecer o site e at mesmo baixar a ltima verso disponvel, acesse https://javaserverfaces.dev.java.net/.

4.3. Criando um novo projeto Para comear, crie uma nova aplicao web no Eclipse, selecionando a opo File,

New e Dynamic Web Project no menu da ferramenta. Digite o nome do projeto (por exemplo PrimeiroProjeto) e na seo Configuration

selecione JavaServer Faces v1.2 Project. Pressione o boto Next.




A nova tela que aparece apresenta algumas informaes sobre o nome do contexto da

aplicao e nomes dos diretrios de contedos web e fontes Java. Apenas pressione Next.




A prxima tela solicita as configuraes da JSF para o seu projeto. Em JSF Libraries,

selecione a segunda alternativa, selecione a opo Deploy e clique no boto New.... Iremos referenciar os pacotes (JARs) da implementao JSF.

Informe um nome para a biblioteca, como por exemplo, Mojarra JSF 1.2, selecione

v1_2 em Version Supported, clique sobre o boto Add... e selecione os arquivos jsf-api.jar e jsf-impl.jar, que se encontram dentro do diretrio lib distribudo no arquivo de instalao da Mojarra. Clique novamente em Add... e inclua o arquivo jstl.jar, que tambm est disponvel no DVD. Clique no boto Finish.




Nosso projeto agora utilizar a biblioteca cadastrada. Clique sobre o boto Finish.




Quando o projeto for criado, voc o ver em Project Explorer.

4.4. Codificando a primeira aplicao JSF

Nossa primeira aplicao ser uma tela com um campo de entrada de texto e um boto. O usurio deve informar o nome no campo e pressionar o boto. Uma mensagem de boas vindas ser dada ao usurio, transformando o nome digitado em letras maisculas.

Clique com o boto direito sobre a pasta WebContent, selecione New e JSP.

Em File name, digite o nome de nossa primeira pgina JSF, como por exemplo, ola.jsp, e clique no boto Next.

A extenso do arquivo deve ser .jsp, pois a tecnologia JSF foi construda baseada na JSP.




O Eclipse nos fornece alguns templates (modelos de cdigos prontos) para facilitar nosso trabalho. Selecione um template JSF com tags HTML, como o New JavaServer Faces (JSF) Page (html). Clique no boto Finish.

O Eclipse ir gerar um cdigo JSF com um contedo que comum em praticamente todas as telas que desenvolvemos. Isso facilita para no precisarmos digitar tudo.

Altere o ttulo da tela na tag HTML .




Dentro da tag , digite o cdigo a seguir:

Encontre o arquivo faces-config.xml no diretrio WebContent/WEB-INF e clique duas vezes sobre ele. Um editor visual deste arquivo ser apresentado.

No editor do arquivo faces-config.xml, clique sobre a aba ManagedBean. Selecione a opo request na lista esquerda e clique sobre o boto Add.




Nesta nova tela, selecione a opo Create a new Java class e clique em Next >.

Voc criar uma nova classe responsvel por controlar os componentes da tela. Digite com.algaworks.dwjsf.view para o nome do pacote e UsuarioBean para o nome da classe. Clique no boto Next >.




O Eclipse far o mapeamento necessrio para que a classe que estamos criando consiga realmente se conectar com a tela JSP. No se preocupe, aprenderemos a fazer isso sem ajuda do Eclipse. Nosso objetivo agora apenas deixar funcionando a primeira tela. Clique sobre o boto Finish.




Salve o arquivo faces-config.xml pressionando as teclas Ctrl + S. Se tiver curiosidade, clique sobre a aba Source para ver o cdigo que o Eclipse gerou a partir desta ferramenta de configurao.

A classe UsuarioBean foi criada pelo Eclipse, mas ainda no tem mtodos e atributos. Crie um atributo privado do tipo String chamado nome. Depois gere os mtodos getters e setters para este atributo. O Eclipse possui um gerador de mtodos getters e setters atravs da opo Source, Generate Getters and Setters.

Crie um mtodo pblico, sem retorno e com o nome enviar. Este mtodo deve receber um parmetro chamado event do tipo ActionEvent. A importao deste tipo deve

ser feita atravs do pacote javax.faces.event.




O mtodo enviar ser chamado quando o usurio clicar no boto Enviar. Precisamos passar o nome digitado para maisculo, por isso, voc pode deixar este mtodo da seguinte forma:

public void enviar(ActionEvent event) {

this.setNome(this.getNome().toUpperCase());

}

Nossa tela est pronta!

4.5. Implantao e execuo da aplicao

Para testar a tela que criamos, precisamos adicionar o projeto ao Tomcat que j est integrado ao Eclipse. Na aba Servers, clique com o boto direito sobre o servidor e selecione Add and Remove Projects....

Selecione o projeto PrimeiroProjeto e transfira-o para a lista de projetos configurados. Clique no boto Finish.




Inicie o Tomcat. O Eclipse implantar automaticamente a aplicao PrimeiroProjeto.

Abra um browser e acesse a primeira tela que desenvolvemos atravs do endereo: http://localhost:8080/PrimeiroProjeto/faces/ola.jsp.

Digite seu nome no campo e clique sobre o boto Enviar.




Veja que o nome digitado foi transformado para maisculo, e a mensagem de boas vindas foi apresentada.

4.6. Gerando um WAR da aplicao

A integrao que o Eclipse faz com o Tomcat facilita bastante o desenvolvimento de sistemas, mas voc no ter o Eclipse no servidor de produo que executar as aplicaes.

Para voc distribuir suas aplicaes de forma elegante e de fcil instalao, voc deve gerar um pacote nico que contm tudo necessrio para o funcionamento, sem complicaes. Esse pacote chamado de WAR (Web Application Archive).

Um arquivo WAR nada mais que um arquivo .jar nomeado com a extenso .war. O Eclipse possui uma ferramenta para gerar arquivos WAR. Clique sobre o boto

direito do mouse no projeto e selecione a opo Export. Clique sobre WAR File.

A tela Export deve ser exibida. Informe o caminho completo (incluindo o nome do

arquivo) que deseja gerar o WAR e clique no boto Finish.




Com um arquivo .war, podemos instalar nossa aplicao web em qualquer servidor de

aplicaes. No caso do Tomcat, basta copiar esse arquivo para a pasta webapps do servidor. Para testarmos, inicie o Tomcat por fora do Eclipse. No copie ainda o arquivo WAR

gerado para a pasta webapps. Depois que o Tomcat for iniciado, copie o arquivo PrimeiroProjeto.war para dentro da

pasta webapps.

Veja que o Tomcat far o deploy automtico do pacote.




Agora voc pode acessar o sistema atravs do browser para confirmar se deu tudo

certo.




5. Desvendando o mistrio

5.1. Introduo

Para entender o que acabamos de desenvolver, precisamos conhecer o que o Eclipse gerou de cdigo para ns e tambm as programaes que fizemos.

Estudaremos basicamente o managed bean UsuarioBean, os arquivos faces-config.xml, ola.jsp e web.xml, alm dos demais contedos do diretrio WEB-INF.

5.2. Managed bean UsuarioBean

Antigamente (h no muito tempo atrs), alguns programadores desenvolviam todo o comportamento de uma tela no prprio arquivo de layout, na verdade ainda existem programadores que fazem isso. Em JSF, no fazemos isso! O arquivo JSP deve possuir tags HTML e JSF que definem o layout da pgina. O comportamento da tela deve ser implementado em cdigo Java, em uma classe caracterizada como um managed bean.

Os managed beans nada mais que Java Beans, que servem como canais entre a interface grfica (a tela) e o back-end da aplicao (regras de negcio, acesso ao banco de dados, etc).

Um Java Bean uma classe Java implementada de acordo com algumas convenes que determinam como devem ser escritas propriedades e os mtodos pblicos que as acessam. A especificao completa pode ser encontrada em http://www.oracle.com/technetwork/java/javase/documentation/spec-136004.html.

Os managed beans no JSF podem ser criados e configurados sem programao (atravs de arquivos XML de configurao, que veremos adiante). Em JSF, usa-se beans para conectar classes Java com pginas web ou arquivos de configurao.

Os beans so muito importantes para os desenvolvedores JSF, portanto,

fundamental entender a especificao JavaBean. Nesta seo veremos as partes relevantes para o desenvolvimento com JSF.

As caractersticas mais importantes de um bean so suas propriedades. Uma

propriedade tem: Um nome; Um tipo; Mtodos para obter (getter) e/ou definir (setter) o valor da propriedade. Veja que os JavaBeans so classes Java, portanto, propriedades so os atributos

desta classe.

Uma propriedade no deve ser acessada diretamente, mas atravs dos mtodos de

acesso (getters e setters). Algumas linguagens de programao permitem isso (inclusive o Java), porm, na especificao JavaBean isso no correto.

Uma propriedade de um JavaBean pode ser: Leitura/escrita, somente-leitura ou somente-escrita; Simples, ou seja, contm apenas um valor, ou indexado, quando representa uma

lista de valores. Para obter o resultado de uma propriedade, o bean precisa ter um mtodo da seguinte

forma: public ClasseDaPropriedade getPropriedade() { ... }

E para alterar uma propriedade: public setPropriedade(ClasseDaPropriedade propriedade) { ... }




A especificao ainda exige que a classe bean tenha pelo menos um construtor

padro, ou seja, sem parmetros.

O exemplo abaixo ilustra um bean Pessoa com as propriedades nome, idade e

profissoes.

package com.algaworks.dwjsf.dominio.Pessoa;

import java.util.List;

public class Pessoa {

private String nome;

private Long idade;

private List profissoes;

public Pessoa() {

}

public Pessoa(String nome, Long idade, List profissoes) {

this.nome = nome;

this.idade = idade;

this.profissoes = profissoes;

}

public String getNome() {

return this.nome;

}

public void setNome(String nome) {

this.nome = nome;

}

public Long getIdade() {

return this.idade;

}

public void setIdade(Long idade) {

this.idade = idade;

}

public List getProfissoes() {

return this.profissoes;

}

public void setProfissoes(List profissoes) {

this.profissoes = profissoes;

}

}

Uma propriedade possui apenas o mtodo getter para somente-leitura, somente o

mtodo setter para somente-escrita ou ambos os mtodos para leitura e escrita. Os nomes e as assinaturas dos mtodos devem coincidir precisamente com o padro,

ou seja, comear com get ou set, como apresentado no exemplo acima. Um mtodo get

deve ter um valor de retorno e nenhum parmetro. Um mtodo set deve ter um parmetro e

nenhum valor de retorno.




A regra para a criao do nome do mtodo colocar set ou get na frente do nome da

propriedade com sua primeira letra maiscula, ou seja, uma propriedade nome teria os

mtodos com nomes getNome e setNome. Uma exceo a est regra ocorre quando o nome

da propriedade est em maiscula, por exemplo, uma propriedade URL teria os mtodos com

nomes getURL e setURL. Repare que a propriedade referenciada no uRL.

Uma propriedade do tipo boolean tem uma varincia no seu mtodo getter. Por

exemplo, uma propriedade de nome ativo do tipo boleano, poderia ser tanto:

boolean isAtivo()

Quanto: boolean getAtivo()

Nosso bean UsuarioBean possui apenas a propriedade nome.

public class UsuarioBean {

private String nome;

...

public String getNome() {

return nome;

}

public void setNome(String nome) {

this.nome = nome;

}

}

Uma vantagem de se utilizar os mtodos de acesso s propriedades a possibilidade

de manipular seus valores atravs estes mtodos, ou seja, podem-se converter dados, acessar um banco de dados, fazer validaes e vrias outras coisas.

Voltando tela que desenvolvemos, o bean UsuarioBean possui apenas o atributo

nome porque o nico campo que inclumos na tela.

O mtodo enviar(...) recebe como parmetro um objeto do tipo ActionEvent,

que aprenderemos em outro captulo. Neste momento voc s precisa saber que este mtodo ser invocado quando o boto Enviar for pressionado pelo usurio. Esse mtodo ento um manipulador de eventos, que no nosso exemplo, altera o nome digitado para maisculo.

public void enviar(ActionEvent event) {

this.setNome(this.getNome().toUpperCase());

}

5.3. Arquivo faces-config.xml

Para instanciar um managed bean e determinar seu escopo, utiliza-se um arquivo de configurao XML.

Este arquivo processado quando a aplicao iniciada. Quando uma pgina referencia um bean, a implementao do JSF o inicializa de acordo com as configuraes contidas neste arquivo.

O arquivo de configurao mais utilizado o WEB-INF/faces-config.xml, porm possvel mudar este nome e at utilizar vrios arquivos em conjunto.




Para configurar um bean necessrio no mnimo o nome, a classe e o escopo do bean (que ser visto mais adiante).

No ltimo exemplo, configuramos o bean atravs de uma ferramenta visual do Eclipse, mas poderamos ter feito manualmente. Para ver o cdigo gerado pelo Eclipse, acesse a aba Source da ferramenta de edio do faces-config.xml.

O XML de configurao dos beans deve-se parecer com este:

usuarioBean

com.algaworks.dwjsf.view.UsuarioBean

request

O XML acima declara que teremos um managed bean chamado usuarioBean, que referente a classe com.algaworks.dwjsf.view.UsuarioBean, ou seja, sempre que

usarmos o nome usuarioBean em uma pgina JSF, estamos falando de uma instncia da classe UsuarioBean.

A propriedade managed-bean-scope define o escopo do bean. Neste caso, o escopo request, o que significa que o estado do bean ser mantido a cada requisio do cliente. Veremos outros escopos em outro captulo.




5.4. Pgina ola.jsp

Toda tela de usurio deve possuir um arquivo JSP com cdigos HTML e tags JSF. Normalmente, os arquivos das pginas possuem extenso .jsp. No exemplo que desenvolvemos, o nome desse arquivo foi ola.jsp. Veja o cdigo da tela do ltimo exemplo:

Minha primeira aplicao

Observe que grande parte deste arquivo possui tags HTML. Isso prova que voc pode

misturar cdigos HTML com tags JSF na maioria dos casos. Agora veremos o que cada trecho de cdigo significa para a construo da tela. Comeamos pelas declaraes das bibliotecas de tags (taglibs) do JSF:

As declaraes acima dizem para o framework do JSF que queremos usar as

bibliotecas de tags html e core. A biblioteca html contm todas as tags (componentes) para trabalhar com itens especficos da HTML, como formulrios, campos de entrada de dados, botes e etc. A biblioteca core contm lgicas para validaes, converses e outras coisas especficas da JSF.

Todas as pginas JSF devem possuir uma tag . Essa tag diz ao JSF que

voc quer gerenciar os componentes que estiverem em seu corpo, em outras palavras, todos

os componentes filhos de podem ser gerenciados.

...

Se voc no colocar a tag , o JSF no poder construir a rvore de

componentes gerenciveis da pgina, e isso impossibilitaria uma futura localizao dos

componentes criados na tela, ou seja, voc deve sempre incluir a tag englobando

todos os seus componentes JSF para que tudo funcione da maneira desejada.




A tag diz que voc quer um formulrio da HTML neste local.

...

Os componentes de entrada de dados e tambm os que permitem comandos (aes)

dos usurios (como os botes e links) sempre devem estar dentro da tag , pois

assim os valores digitados pelos usurios nos campos e os estmulos aos comandos podem ser enviados para o servidor fazer o processamento.

Usamos o componente para apresentar um campo de entrada de

texto e um componente para um boto.

Os delimitadores #{...} sero explicados no prximo captulo com mais detalhes.

Esses delimitadores podem ser chamados de expresses de ligao ou JSF EL (JavaServer Faces Expression Language). O texto usuarioBean est referenciando o managed bean que configuramos anteriormente, e nome faz referncia propriedade com mesmo nome no bean. Esta propriedade acessada usando o mtodo getNome e alterada usando o mtodo

setNome, por isso to importante o padro Java Beans.

Quando a pgina exibida, o mtodo getNome chamado para obter o valor atual da

propriedade. Quando a pgina submetida atravs do boto Enviar, o mtodo setNome chamado para alterar o valor que foi digitado pelo usurio atravs do campo de entrada.

A tag possui o atributo actionListener, que liga a ao

sobre este boto ao mtodo enviar da classe UsuarioBean, ou seja, quando o usurio clicar

sobre o boto Enviar, o servidor identificar este comando e executar automaticamente o mtodo enviar do bean. Este mtodo por sua vez tem a chance de fazer qualquer

processamento do lado do servidor. No caso de nosso exemplo, apenas mudamos o nome digitado no campo de entrada para letras maisculas.

A tag apenas apresenta um texto (rtulo) digitado no atributo

value. Nada de extraordinrio.

Voc deve ter percebido que a mensagem de boas vindas s foi apresentada depois

que o nome foi informado no campo de entrada e o boto Enviar foi pressionado. Isso ocorreu porque inclumos um componente chamado que s apresentado

(renderizado) quando o nome no for nulo.

A tag apresenta textos contidos no atributo value. Esse atributo

pode conter textos estticos (fixos), como a mensagem de boas vindas, e tambm textos dinmicos, como o nome digitado pelo usario.

O atributo rendered do componente utilizado incluindo uma

expresso boleana (que retorna true ou false). O componente s renderizado se essa expresso for verdadeira. Nossa expresso s ser verdadeira se o nome for diferente de nulo, ou seja, apenas se o usurio digitar o seu nome no campo de entrada.




5.5. Arquivo web.xml

As aplicaes JSF precisam de um arquivo chamado web.xml com algumas configuraes para funcionarem. Normalmente este arquivo o mesmo na maioria das aplicaes. No exemplo que desenvolvemos, o Eclipse criou e configurou este arquivo de acordo com as informaes que passamos para ele.

Para entender um pouco mais, abra o cdigo-fonte do arquivo web.xml (dentro da pasta WEB-INF). Ele deve se parecer com o seguinte:

PrimeiroProjeto

index.jsp

Faces Servlet

javax.faces.webapp.FacesServlet

1

Faces Servlet

/faces/*

Todas as pginas JSF so processadas por um servlet do prprio framework. Este

servlet implantado no web.xml atravs da tag .

Faces Servlet

javax.faces.webapp.FacesServlet

1

Este servlet chamado toda vez que o caminho da URL iniciar por /faces/*. Esta

regra foi definida atravs da tag e, portanto, pode ser alterada para

outro padro que voc gostar mais.

Faces Servlet

/faces/*

Voc no pode simplesmente chamar o endereo sem incluir /faces, como: http://localhost:8080/PrimeiroProjeto/ola.jsp




Veja o resultado se isso acontecer:

Quando voc chama o arquivo JSP diretamente, o Faces Servlet no executado, e

por isso o JSF no inicializa seu contexto e o view root (os componentes dentro da tag

) antes de exibir a pgina.

Experimente mudar o mapeamento do Faces Servlet para o padro *.jsf.

Faces Servlet

*.jsf

Agora podemos chamar nossa pgina usando a URL: http://localhost:8080/PrimeiroProjeto/ola.jsf

5.6. Conhecendo mais sobre o diretrio WEB-INF

O diretrio WEB-INF contm arquivos de configurao e outros necessrios para o funcionamento da aplicao web. Todas as classes (arquivos .class) e bibliotecas (arquivos .jar) devem ficar dentro desse diretrio. Este diretrio vital para sua aplicao, e ela no funcionar sem isso.

Alm dos arquivos web.xml e faces-config.xml, o diretrio WEB-INF pode possuir os sub-diretrios classes e lib. O diretrio classes contm as classes criadas, tais como os managed beans, Java beans, regras de negcio, acesso a banco de dados e etc, e o diretrio lib possui as bibliotecas de terceiros necessrias para o funcionamento de seu software, como para gerao de grficos e relatrios, driver JDBC, bibliotecas para leitura e escrita de arquivos PDF ou XLS, etc.

5.7. Como funciona nos bastidores

Voc j conhece alguns dos principais conceitos do JSF e sabe como preparar o ambiente para desenvolvimento, inclusive j criou uma tela simples neste framework. Agora vamos estudar o que acontece nos bastidores da execuo da nossa aplicao de exemplo.




Quando voc digita o endereo da aplicao no browser e acessa a tela do sistema pela primeira vez, o servlet da JSF (Faces Servlet) intercepta a requisio, l o arquivo JSP e efetua o processamento. No nosso caso, o arquivo JSP o ola.jsp. Esse arquivo contm tags de componentes, como o formulrio, o campo de entrada de texto, o boto e etc.

Cada tag possui uma classe que a representa, chamada de tag handler, executada assim que a pgina processada. Essas classes trabalham em conjunto e constroem uma hierarquia de componentes na memria do servidor, seguindo o que foi programado no arquivo JSP.

A hierarquia de componentes representa os elementos da interface visual presentes na pgina. Esses componentes so responsveis por gerenciar seus estados e comportamentos. Veja como ficou a hierarquia dos componentes do ltimo exemplo:

O componente UIViewRoot representa a raiz dos componentes gerenciados pelo

JSF, especificado atravs da tag , o UIForm representa o formulrio (),

UIOutput significa o label de escrita de textos definido como , os

componentes UIInputText so os campos de entrada de texto () e

UICommand o boto, especificado pela tag .

Ainda durante o processamento do arquivo JSP, uma pgina HTML renderizada e

enviada para o seu browser. Os componentes JSF so convertidos para cdigo HTML. Cada componente JSF possui um renderizador, que responsvel por gerar cdigo

HTML refletindo o estado de seu componente. Por exemplo, o componente

poderia ser representado no HTML pelo seguinte cdigo, de acordo com seu renderizador, aps o usurio digitar o seu nome e submeter ao servidor:

O nome do componente HTML (atributo name) foi definido com vrios caracteres e

nmeros estranhos. Esse nome gerado automaticamente pelo framework JSF, e chamado de identificador nico, ou unique ID. Voc pode especificar o unique ID que deseja utilizar, mas se no fizer isso, o JSF ir gerar um para voc, como no ltimo exemplo. Veja abaixo como ficaria o cdigo HTML gerado pelos renderizadores dos componentes da pgina ola.jsp:




Entre a requisio do usurio e a resposta dada pelo servidor, existem vrias outras coisas executadas que no abordamos neste tpico. Voc aprender tudo sobre a sequncia de processamento no captulo sobre Ciclo de Vida.

5.8. JSF apenas isso? JavaServer Faces muito mais do que apenas isso! Este framework oferece diversos outros servios para o desenvolvimento da camada visual de sua aplicao, como:

Converso de dados: facilita a converso de textos digitados pelos usurios para tipos especficos, como por exemplo, quando o usurio digita sua data de nascimento, o servidor recebe um texto, que deve ser convertido para um objeto do

tipo Date representando o que o usurio informou.

Validao: diversas validaes de dados bsicas podem ser feitas antes de suas

regras de negcio ser executadas, como, por exemplo, sobre obrigatoriedade de campos, aceitao de apenas nmeros ou validao de documentos, como CPF e CNPJ. O JSF nos ajuda nesta tarefa, e aprenderemos como utilizar este recurso mais a frente.

Componentes customizados: voc pode criar ou baixar da internet componentes

customizados para enriquecer o desenvolvimento de suas aplicaes. Os componentes podem ser reutilizados em todas as aplicaes de sua empresa, e o designer das pginas no precisa conhecer como ele foi feito para utiliz-lo. Por exemplo, voc poderia criar um componente para exibir um teclado virtual para digitao de senhas. Veja um exemplo de como o designer de pginas poderia utiliz-lo:

Renderizadores: o JSF gera cdigo HTML por padro, porm o framework suporta

a incluso de outros renderizadores plugveis que podem produzir cdigos em outras linguagens para visualizadores de diferentes tipos, como celulares (WML), Telnet, Flash, etc.




Internacionalizao: com JSF, muito fcil voc desenvolver aplicaes multi-idiomas com o recurso de i18n (abreviao para internacionalization).




6. Ciclo de vida

Voc pode desenvolver uma aplicao completa em JSF sem conhecer todos os detalhes deste framework, porm quanto mais voc souber sobre ele, melhor e mais produtivo voc se tornar. Por isso, estudaremos agora um assunto que nem todos os desenvolvedores JSF conhecem: o ciclo de vida.

Ao executar uma pgina construda usando componentes JSF, ela passar por um ciclo de vida de processamento bem definido, constitudo por 6 fases, como seguem:

1. Restaurar viso 2. Aplicar valores de requisio 3. Processar validaes 4. Atualizar os valores do modelo 5. Invocar a aplicao 6. Renderizar a resposta

Veja abaixo uma ilustrao deste ciclo:

Agora vamos estudar o que cada fase do ciclo de vida processa. 1. Restaurar viso A fase de restaurao da viso recupera a hierarquia de componentes para a pgina

solicitada, se ela foi exibida anteriormente, ou constri uma nova hierarquia de componentes, se for a primeira exibio.

Se a pgina j tiver sido exibida, todos os componentes so recuperados em seu estado anterior. Isso d condies dos dados de um formulrio submetido ao servidor serem recuperados, caso ocorra algum problema de validao ou restrio de regra de negcio. Por exemplo, se um formulrio solicita campos obrigatrios que no so totalmente preenchidos, porm enviados pelo usurio, o mesmo formulrio deve aparecer novamente com os campos que no estavam vazios j preenchidos, porm com mensagens de erro indicando os campos requeridos.

2. Aplicar valores de requisio Nesta fase, cada componente tem a chance de atualizar seu prprio estado com

informaes que vieram da requisio




3. Processar validaes Nesta fase, os valores submetidos so convertidos em tipos especficos e anexados

aos componentes. Quando voc programa uma pgina em JSF, voc pode incluir validadores para criticarem os valores recebidos pelos usurios. Neste momento, os validadores entram em ao e, se ocorrerem erros de converso ou de validao, a fase de renderizao de resposta invocada imediatamente, pulando todas as outras fases, e exibindo a pgina atual novamente, para que o usurio possa corrigir os erros e submeter os dados mais uma vez.

4. Atualizar os valores do modelo Durante esta fase, os valores anexados (chamados de valores locais) aos

componentes so atualizados nos objetos do modelo de dados e os valores locais so limpos. 5. Invocar a aplicao Na quinta fase, os eventos que originaram o envio do formulrio ao servidor so

executados. Por exemplo, ao clicar em um boto para submeter um cadastro, a programao do evento deste boto deve ser executada. Em alguns casos, a execuo do evento pode retornar um identificador dizendo qual a prxima pgina a ser exibida, ou simplesmente no retornar nada para re-exibir a mesma pgina.

6. Renderizar a resposta Por ltimo, a fase de renderizao da resposta gera a sada com todos os

componentes nos seus estados atuais e envia para o cliente. O ciclo recomea sempre que o usurio interage com a aplicao e uma requisio enviada ao servidor.




7. Managed beans

7.1. Introduo

O entendimento de beans no desenvolvimento de aplicaes Java de modo geral e principalmente em conjunto com o JSF essencial para um bom programador. No contexto das pginas JSF, os beans fazem a separao entre a apresentao e a lgica de negcios, ou seja, todo o cdigo de implementao fica no bean e as pginas apenas os referenciam.

Voc j aprendeu o que um Java Bean e tambm um managed bean em um captulo anterior. Agora, aprender como configurar os managed beans atravs do arquivo XML.

7.2. Configurando beans Os beans usados para vincular s pginas JSF so chamados de managed beans.

Geralmente, utiliza-se um arquivo XML para configurao desses beans e seus escopos. Este arquivo processado quando a aplicao iniciada. Quando uma pgina

referencia um bean, a implementao do JSF o inicializa de acordo com as configuraes obtidas.

O arquivo de configurao mais utilizado o WEB-INF/faces-config.xml, porm para uma maior organizao do cdigo, comum fazer uma separao em vrios arquivos, agrupando-os por funcionalidades como navegao, converses e beans. Para isto, basta acrescentar ao arquivo WEB-INF/web.xml um parmetro de inicializao javax.faces.CONFIG_FILES como mostrado abaixo:

javax.faces.CONFIG_FILES

WEB-INF/navigation.xml, WEB-INF/beans.xml

...

O assunto de navegao e converses ser abordado mais tarde. Para configurar um bean necessrio no mnimo o nome, a classe e o escopo do bean

(que ser estudado mais adiante). O cdigo abaixo ilustra um exemplo de configurao:

meuBean

com.algaworks.MeuBean

session

As instrues de configurao acima esto dizendo para o framework JSF construir um

objeto da classe com.algaworks.MeuBean, dar um nome a ele de meuBean e manter este

objeto no escopo de sesso do usurio, ou seja, durante toda a navegao do usurio no sistema.

7.3. Expresses de ligao de valor Depois que o managed bean definido no arquivo XML, ele pode ser acessado pelos

componentes das pginas do sistema.




A maioria dos componentes JSF possui propriedades que nos permitem especificar um valor ou uma ligao a um valor que est associado a um bean.

Por exemplo, pode-se especificar um valor definitivo (esttico) no componente

:

Ou tambm uma ligao de valor (dinmico):

Quando o componente for renderizado, o mtodo getter da propriedade nome ser

invocado. J o mtodo setter da propriedade ser invocado quando o usurio digitar algo no componente de entrada de texto e submeter a pgina ao servidor.

7.4. Escopo dos beans Conforme mostrado no arquivo de configurao WEB-INF/faces-config.xml, a tag

define o escopo no qual o bean armaz

algaworks dwjsf desenvolvimento web com javaserver faces 2a edicao

Documents