PROJETO FINANCEIROWEB GRADUAÇÃO TECNOLÓGICA EM GESTÃO DA TECNOLOGIA DA INFORMAÇÃO

Transcrição

1 FACULDADE DE TECNOLOGIA SENAC GOIÁS PROJETO FINANCEIROWEB GRADUAÇÃO TECNOLÓGICA EM GESTÃO DA TECNOLOGIA DA INFORMAÇÃO - MÓDULO V - GOIÂNIA - ABRIL 2015

2 ELABORAÇÃO Coordenador do Projeto: Douglas de Souza Braga Hugo Bastos de Souza Kaysmier Walessa Alves de Castro Rafael Vitor Couto do Amaral

3 SUMÁRIO 1. APRESENTAÇÃO INFORMAÇÕES GERAIS SOBRE AS TECNOLOGIAS JAVASERVER FACES HIBERNATE PRIMEFACES HIBERNATE MAVEN APACHE TOMCAT DESCRIÇÃO DO PROCESSO DE DESENVOLVIMENTO INTRODUÇÃO VISÃO GERAL DA APLICAÇÃO DESENVOLVIMENTO DO APLICATIVO FINANCEIROWEB Configuração do Projeto Implantação da Camada de Acesso ao Banco de Dados Criação do Pacote Usuario, Suas Classes e Conexão ao Banco de Dados Administração de Usuários com DataTable Segurança do Sistema com Spring Security Cadastro de Contas com Ajax Identidade Visual com CSS e Facelets Cadastro de Categorias Usando PrimeFaces CONCLUSÃO SOBRE O DESENVOLVIMENTO DO APLICATIVO FINANCEIROWEB CONCLUSÃO HUGO BASTOS CONCLUSÃO KAYSMIER CASTRO CONCLUSÃO DOUGLAS BRAGA CONCLUSÃO RAFAEL VITOR REFERÊNCIAS BIBLIOGRÁFICAS...93

4 1. APRESENTAÇÃO Este trabalho possui o objetivo de demonstrar o processo de desenvolvimento da aplicação FinanceiroWeb, desenvolvida no livro Programação Java para Web 01, onde os autores explicam a integração entre as tecnologias JavaServer Faces, Hibernate, Primefaces, Spring Security entre outras. 2. INFORMAÇÕES GERAIS SOBRE AS TECNOLOGIAS As informações a seguir servem de orientação as pessoas que desejam saber um pouco mais sobre as tecnologias utilizadas JavaServer Faces JavaServer Faces (JSF) é uma especificação Java para criar interfaces de usuário baseadas em componentes para aplicações WEB. JSF foi formalizado como padrão por meio da Java Community Process e é parte da Plataforma Java, Enterprise Edition. Facelets é um sistema de templates web de código aberto pertencente à licença Apache e a tecnologia de controle da visualização padrão para JSF, sendo que a versão 2.x utiliza-o como sistema de templates padrão. A primeira versão do JSF data de 2001, quando a Java Specification Request (JSR) para a tecnologia que, no fim, se tornaria a tecnologia Java Server Faces, porpôs desenvolver um pacote com o nome javax.servlet.ui. Em junho desse mesmo ano, JavaWorld, um site de tecnologia focado em tecnologias Java desde 1996, noticiou que um time de pesquisadores desenvolvia a API JavaServer Faces (chamada na época de Moonwalk ) uma biblioteca de aplicação para criar interfaces de usuário baseadas em tecnologia web. Baseado em um modelo de interface de usuário voltado a componentes, JavaServerFaces usa arquivos XML chamados templates de visualização ou visualizações em faceletes. O FacesServlet processa requisições, carrega o template de visualização apropriado, constrói uma árvore de componentes, processa eventos e renderiza a resposta (tipicamente na linguagem HTML) para o cliente. E, uma vez que JSF suporta múltiplos formatos de saída, componentes habilitados para Ajax podem ser facilmente incorporados para enriquecer as interfaces de usuário Hibernate Hibernate ORM (ou só Hibernate) é uma biblioteca de mapeamento de objetos relacional (Object-Relational Mapping) para a linguagem Java, fornecendo uma biblioteca para mapear um modelo de domínio orientado a objeto para um banco de dados relacional. O Hibernate resolve os problemas de conflito de impedância de objetos relacionais, substituindo acessos diretos ao banco de dados persistentes com funções de manuseio de objetos de alto nível. O a principal característica do Hibernate é mapear classes Java para tabelas de bancos de dados (e de tipos de dados Java para tipos de dados SQL). O Hibernate também fornece instruções de dados e retorno de informações, realizando chamadas SQL e liberando o desenvolvedor da conversão manual de objetos e manipulação manual dos resultados de busca. 1/2015 1

5 O projeto Hibernate começou em 2001 com Gavin King e colegas da Cirrus Technologies como alternativa ao uso do estilo de entidade beans EJB2, com o objetivo original de oferecer melhores capacidades de persistência que aquelas oferecidas pelo EJB2 simplificando as características complexas e suprindo aquelas ausentes. Após anos de desenvolvimento, em 2011, a versão Core Final foi liberada, incluindo novas características. Em 2012, o desenvolvimento da versão 5 começou, mas ainda não se concluiu. Algumas novas funções são melhor abertura de Sessão de dentro da SessionFactory, melhor integração via org.hibernate.spi.integrator, e auto-descoberta, internacionalização, entre outros PrimeFaces PrimeFaces é uma biblioteca componente para aplicações baseadas em JavaServer Faces, uma suíte de código aberto para interface de usuários, desenvolvido pela empresa PrimeTek, da Turquia. Como características, a biblioteca possui mais de 100 componentes específicos de interface de usuário, bem como integração com bibliotecas Ajax. Possui mais de 100 componentes, permitindo criar interfaces ricas para aplicações web de forma simplificada e eficiente. Ele é considerado muito melhor do que muitas outras bibliotecas de componentes JSF, tendo em vista que: Possui um rico conjunto de componentes de interface (DataTable, AutoComplete, HTMLEditor, gráficos etc). Nenhum xml de configuração extra é necessária e não há dependências. Componentes construídos com Ajax no padrão JSF 2.0 Ajax APIs. Mais de 25 temas templates. Boa documentação com exemplos de código Hibernate Spring Security é uma biblioteca Java e Java Enterprise Edition que fornece funções de segurança, como autenticação e autorização, para aplicações organizacionais. O projeto se iniciou no fim de 2003 como Acegi Security por Bem Alex, com sua publicação sob a Licença Apache em março de Posteriormente, Acegi foi incorporada no portfolio Spring como Spring Security, um subprojeto oficial Spring. Sua primeira publicação com o novo nome se deu em abril de 2008, na versão Dentre suas características principais, podemos citar o uso do LDAP (protocolo de aplicação para acesso e manutenção de informação distribuída em diretórios por meio do protocolo de internet) para centralização e autenticação de informação; suporte do tipo SU-Unix para troca da identidade principal entre uma conexão HTTP e HTTPS; autenticação anônima, o que significa que mesmo usuários principais não autenticados tem alocados uma identidade de segurança; suporte ao lembre-se de mim por meio de cookies HTTP; suporte total a personalização e espaço para implementação de autenticação personalizada, entre outros Maven Maven (ou Apache Maven) é uma ferramenta de construção automática usada primariamente para projetos Java (Maven significa acumulador de conhecimento ). Ele se encarrega de dois aspectos de construção de software: primeiro, ele descreve como o software é construído, e depois descreve suas dependências. Um arquivo XML chamado POM 1/2015 2

6 (Project Object Model) descreve o projeto de software a ser construído, suas dependências em outros módulos externos e componentes, a ordem de construção, diretórios, e plug-ins necessários. O Maven foi criado por Jason van Zyl, da Takari, sendo iniciado como um subprojeto do Apache Turbine em Em 2003, foi aceito como projeto top-level da Apache Software Foundation. Em julho de 2004m a publicação do Maven 1.0 foi a primeira etapa crítica para sua consolidação. Atualmente, a versão 3.0 expandiu a possibilidade de add-nos para inclusão de linguagens Ruby, YAML e Groovy. Uma característica central no Maven é seu gerenciamento de dependências. O mecanismo de manipulação de dependências é organizado com base em um sistema de coordenadas identificando artefatos individuais como bibliotecas ou módulos. Um projeto só precisa ter suas coordenadas declaradas no arquivo POM, para que o Maven se encarregue de fazer automaticamente o download das dependências necessárias àquela biblioteca e arquiva-las no repositório local Apache Tomcat Apache Tomcat é um servidor web de código aberto desenvolvido pela Apache Software Foundation (ASF). Ele implementa várias especificações Java EE, incluindo Java Servlet, JavaServer Pages (JSP), Java EL e WebSocket, e fornece um ambiente de servidor web HTTP Java puro para fazer rodas códigos Java. Sua versão mais recente, 8.0, oferece suporte a Servlet 3.1, JSP 2.3, EL 2.3 e especificações WebSocket. Tomcat começou como um servlet de implementação de referência criado por James Duncan Davidson, um arquiteto de software da Sun Microsystems, tendo papel crucial em tornar o projeto open-source e convencer a Sun a doa-lo para a Apache Software Foundation. A criação do software de construção automática Apache Ant foi uma criação tida como efeito colateral do desenvolvimento do Tomcat. A versão EE do Apache Tomcat (chamada Apache TomEE pronuncia-se Tommy ) combina vários projetos organizacionais Java incluindo Apache OpenEJB, Apache OpenWebBeans, Apache OpenJPA, ApacheMyFaces e outros. Em outubro de 2011, obteve o certificação da Oracle Corporation como uma implementação compatível com o perfil Web Java EE 6 1/2015 3

7 3. Descrição do processo de desenvolvimento Introdução Neste sessão iremos descrever o processo de desenvolvimento do FinanceiroWeb, usando o Ambiente de Desenvolvimento Integrado Eclipse em um projeto do tipo Maven Visão geral da aplicação O aplicativo FinanceiroWeb funciona como gerenciador financeiro de despesas e receitas, englobando cadastro de usuários, fornecimento de permissões para alterações no sistema aos mesmos, bem como cadastro de contas bancárias, e seu gerenciamento, podendo torna-las favoritas do usuário ou não, um método de gerenciar quais contas deverão ser utilizadas primeiro em caso de operações financeiras. Além disso, o sistema disponibiliza possibilidade de cadastro de tipos de movimentação financeira (despesas e receitas, por exemplo), bem como seus subitens, como salários, despesas automobilísticas, escola, entre outros Desenvolvimento do aplicativo FinanceiroWeb DICAS IMPORTANTES: Salve periodicamente o projeto inteiro com o comando Ctrl+Shift+S. Isso evita perda de trabalho por algum imprevisto; Mantenha o código sempre organizado, com a identação correta, com o comando Ctrl+Shift+F; Durante a implementação do código, não se preocupe imediatamente com os imports. Ao terminar a implementação, use o comando Ctrl+Shift+O para que o sistema organize automaticamente os imports necessários, tomando cuidado apenas em verificar se são os imports corretos. Para que o projeto FinanceiroWeb possa ser desenvolvido, serão utilizados dois programas básicos: IDE (Integrated Development Environment Ambiente Integrado de Desenvolvimento) Eclipse LUNA, que pode ser baixado do endereço Eclipse IDE for Java EE Developesr, com a versão do processador respectiva; Banco de dados PostgreSQL, que pode ser baixado do endereço com a observação de baixar a versão mais atual compatível com a máquina. Baixe e instale estes dois programas. A instalação é bastante simplificada para o Postgres. Já o Eclipse não precisa ser instalado. Basta descompactar e executar o arquivo eclipse.exe. Será necessário, agora, configurar o servidor Apache Tomcat 8.0 na máquina onde será desenvolvido o projeto. Para tanto, os seguintes passos deverão ser seguidos: 1/2015 4

8 Realizar o download do servidor Apache 8.0 no endereço eletrônico 80.cgi, no campo Binary Distributions, conforme a versão do computador (para que não haja problemas de compatibilidade, será utilizada a versão padrão) [1]; É interessante que seja criada uma pasta específica para os servidores. Para tanto, será criada uma pasta dentro do disco C:\, com o nome Servidores, e o servidor Apache Tomcat deverá ser recortado para lá, e descompactado [2]. Figura [1]: Download do servidor Apache Tomcat Figura [2]: Pasta Servidores em C:\, com o servidor descompactado Agora que o servidor foi instalado no computador, o sistema FinanceiroWeb será desenvolvido. 1/2015 5

9 3.3.1 Configuração do Projeto Para iniciar o desenvolvimento do aplicativo, primeiro necessitamos criar um novo projeto do tipo Maven, e cadastrar um novo servidor, que será o Apache Tomcat v Para tanto, siga os seguintes procedimentos: Abra a IDE Eclipse Luna; Clique em File, New, e então em Maven Project [3]; Na tela de criação, marque a seleção Create a simple Project (skip archetype selection) e clique em Next [4]; Na próxima tela, o projeto deverá ser identificado. Usaremos os seguintes nomes para ele [5]: o Group ID - com.financeiro.org o Artifcat ID FinanceiroWeb o Packaging war Após, devemos clicar no botão Finish, e o projeto estará criado. Abaixo seguem exemplos por meio de imagens para facilitar a compreensão Figura [3]: Criação de novo projeto Maven Figura [4]: Criação do Projeto Figura [5]: Configuração do Projeto 1/2015 6

10 Uma vez criado o projeto, e ainda conforme explanação em sala de aula, antes de mais nada, é interessante que seja adicionada a opção JavaServer Faces o que permitirá que o projeto seja desenvolvido com funcionalidades JSF, antes de adicionar as dependências no arquivo pom.xml. Isso evita inserção de códigos manualmente de forma desnecessária. Clique em cima do projeto FinanceiroWeb com o botão direito, e em seguida clique em Properties [6]; Clique em Project Faces e marque a opção JavaServer Faces. Ao fazer isso, o aviso Further configuration required aparecerá na parte inferior da tela. Será necessário entrar nessa configuração [7]; Ao acessar a próxima tela, no campo JSF Implementation Library, a opção Type deverá ser alterada para Disable Library Configuration, e no campo URL Mapping Patterns, deverá ser excluída a opção /faces/* por meio do botão Remove e incluída, por meio do botão Add, a opção *.xhtml [8]. Feito isso, basta clicar no botão Ok, e Ok novamente na tela de Project Faces para adicionar as funcionalidades JSF. Figura [6]: Acesso às propriedades do projeto Figura [7]: Habilitação da Funcionalidade JavaServer Faces Figura [8]: Configuração adicional do JavaServer Faces 1/2015 7

11 Uma vez que trabalharemos com a especificação JavaServer Faces, é necessário informarmos ao projeto qual será a primeira página que ele deverá carregar. Para tanto, iremos abrir o arquivo web.xml, que se encontra no caminho src/main/webapp/web-inf/. Observe que o código para o servlet Faces Servlet já consta no arquivo, o que não aconteceria se o JavaServer Face não tivesse sido configurado primeiro. O seguinte código deverá ser inserido: 7. <display-name>financeiroweb</display-name> <welcome-file-list> 10. <welcome-file>index.xhtml</welcome-file> 11. </welcome-file-list> 12. <servlet> Uma vez inserido este código, as dependências serão listadas no arquivo pom.xml, que se encontra na pasta raiz do projeto. Para tanto, inicialmente, decidiremos qual tipo de charset será o padrão do projeto. Ao invés de termos que declarar em cada página.xhtml qual é o tipo padrão de caracteres que iremos usar, o seguinte código deverá ser digitado no arquivo pom.xml: 1. <properties> 2. <project.build.sourceencoding> 3. UTF-8 4. </project.build.sourceencoding> 5. </properties> Com isso, todo texto a ser mostrado na tela será codificado para o padrão UTF-8, que é o padrão usado nas páginas web para mostrar caracteres especiais utilizados pela língua portuguesa. Para configurar a versão do plugin do Maven a ser utilizada, que será a versão 3.0, o seguinte código deverá ser inserido, abaixo das propriedades de codificação. 1. <build> 2. <plugins> 3. <plugin> 4. <artifactid>maven-compiler-plugin</artifactid> 5. <version>3.0</version> 6. <configuration> 7. <source>1.8</source> 8. <target>1.8</target> 9. </configuration> 10. </plugin> 11. </plugins> 12. </build> Em source e target especificamos qual versão do Java estamos utilizando no projeto. Feito isso, é hora de adicionar todas as dependências que usaremos no projeto. Escolhemos adicionar todas as bibliotecas a serem usadas neste passo, visando agilidade no desenvolvimento, uma vez que as mesmas já foram todas 1/2015 8

12 testadas. Ao finalizar, todas as bibliotecas necessárias para o bom funcionamento do projeto serão importadas para o mesmo. Todas as dependências deverão ser colocadas dentro de um bloco dependencies, conforme o código abaixo. 1. <dependencies> 2. <!-- Adicionar todas as dependências aqui --> 3. </dependencies> Inicialmente, serão adicionadas as dependências JSF. O seguinte código deverá ser incluído no arquivo pom.xml, dentro do bloco dependencies. 1. <dependencies> 2. <dependency> 3. <groupid>com.sun.faces</groupid> 4. <artifactid>jsf-api</artifactid> 5. <version>2.2.10</version> 6. </dependency> 7. <dependency> 8. <groupid>com.sun.faces</groupid> 9. <artifactid>jsf-impl</artifactid> 10. <version>2.2.10</version> 11. <dependency> Agora, serão adicionadas as dependências Hibernate core e Entity Manager, para o gerenciamento de entidades dentro do sistema. 1. <dependency> 2. <groupid>org.hibernate</groupid> 3. <artifactid>hibernate-core</artifactid> 4. <version>4.3.8.final</version> 5. </dependency> 6. <dependency> 7. <groupid>org.hibernate</groupid> 8. <artifactid>hibernate-entitymanager</artifactid> 9. <version>4.3.8.final</version> 10. </dependency> A próxima biblioteca a ser adicionada é a referente ao banco de dados. Utilizaremos o PostGres versão 9.4 no projeto. 1. <dependency> 2. <groupid>org.postgresql</groupid> 3. <artifactid>postgresql</artifactid> 4. <version> jdbc41</version> 5. </dependency> A biblioteca a ser adicionada agora é a Javax Servlet API, que contém um número de classes e interfaces que descrevem e definem os contratos entre uma classe servlet e o ambiente de trabalho, fornecida a uma instância de tal classe por um container servlet em conformidade. 1. <dependency> 2. <groupid>javax.servlet</groupid> 3. <artifactid>servlet-api</artifactid> 4. <version>2.5</version> 5. </dependency> 1/2015 9

13 As dependências Spring Security são responsáveis pela configuração da autenticação e autorização de usuários, bem como fornecimento de permissão para acesso e execução de comandos. 1. <dependency> 2. <groupid>org.springframework.security</groupid> 3. <artifactid>spring-security-web</artifactid> 4. <version>3.1.7.release</version> 5. </dependency> 6. <dependency> 7. <groupid>org.springframework.security</groupid> 8. <artifactid>spring-security-config</artifactid> 9. <version>3.1.7.release</version> 10. </dependency> 11. <dependency> 12. <groupid>org.springframework.security</groupid> 13. <artifactid>spring-security-taglibs</artifactid> 14. <version>3.1.7.release</version> 15. </dependency> Devem ser, também, adicionadas as bibliotecas Java Expression Language (EL), que formam um importante mecanismo para habilitar a camada de apresentação (páginas web) para comunicar com a lógica da aplicação (beans gerenciável). O código segue abaixo. 1. <dependency> 2. <groupid>javax.el</groupid> 3. <artifactid>el-api</artifactid> 4. <version>2.2</version> 5. </dependency> 6. <dependency> 7. <groupid>org.glassfish.web</groupid> 8. <artifactid>el-impl</artifactid> 9. <version>2.2</version> 10. </dependency> Outra biblioteca necessária é a Commons Logging, que fornece uma ligação entre as diferentes implementações de logging, podendo ser usada com qualquer implementação de logging no ambiente de execução. 1. <dependency> 2. <groupid>commons-logging</groupid> 3. <artifactid>commons-logging</artifactid> 4. <version>1.1.1</version> 5. </dependency> E, por fim, será incluída a biblioteca PrimeFaces que, como explicado acima, é uma biblioteca JSF para implementação da interface de usuário. 1. <dependency> 2. <groupid>commons-logging</groupid> 3. <artifactid>commons-logging</artifactid> 4. <version>1.1.1</version> 5. </dependency> 6. </dependencies> 1/

14 NOTA IMPORTANTE: Muito embora todas as dependências tenham sido adicionadas neste momento, sua implementação no sistema se dará de forma gradual, afim de que as suas funcionalidades sejam melhor explicadas. Uma vez que todo código tenha sido implementado no arquivo, salve todo documento com o atalho Ctrl+Shift+S. É importante que, cada vez que o código seja salvo a cada modificação, afim de evitar erros futuros. Aguarde, então, a importação de todas as bibliotecas. Desnecessário mencionar, mas deverá haver conexão ativa com a internet para tal. Ao terminar a importação, é visível que existe um ícone de erro próximo ao projeto. Para resolver este problema, o projeto deverá ser atualizado. Para tanto, basta clicar com o botão direito do mouse em cima do projeto, e selecionar Maven, e então Update Project [9]. Na tela de atualização, é interessante marcar a opção Force Use of Snapshots/Release. Ao final, clique em Ok [10]. Nesse momento, o projeto está configurado, e o desenvolvedor poderá começar a implementar as classes. Figura [9]: Atualização do Projeto Figura [10]: Configuração da Atualização 1/

15 3.3.2 Implantação da Camada de Acesso ao Banco de Dados Nesta parte do trabalho será implementada a classe de acesso aos dados. É importante ressaltar que, uma vez que o trabalho gira em torno do desenvolvimento de um sistema financeiro, deverá haver, também, a persistência dos dados, para análise, modificação e posterior uso, como geração de relatórios, entre outros. Para que a persistência dos dados ocorra, todas as informações pertinentes deverão ser gravadas no banco de dados PostgreSQL. Para tanto, inicialmente, será preparada a camada de acesso aos dados. Para que possamos iniciar a construção do sistema, deveremos entender a questão da separação de tarefas dentro do código. Cada parte do código ficará responsável por executar uma tarefa específica. Isso não apenas facilita a reusabilidade e configuração do sistema, como também facilita a correção de erros e aplicação de modificações necessárias. Dito isso, todas as classes específicas estarão separadas em seus respectivos pacotes, para que uma classe não interfira nas atividades da outra. Para tanto, criaremos primeiro a classe ConnectionFactory, que será a responsável por instanciar a SessionFactory, responsável pela conexão ao banco de dados. Uma vez que será utilizado a API Hibernate, precisaremos criar o arquivo hibernate.cfg.xml, que será o responsável por conter todas as configurações de conexão. O arquivo deverá ser criado na pasta raiz do sistema, fora de qualquer pacote. Para tanto: Clique com o botão direito em FinanceiroWeb, e selecione New, e Other (a última opção) [11]; Vá até o final com a barra de rolagem, abra a opção XML, e selecione XML File [12]; Nesta tela, selecione a pasta FinanceiroWeb/src/main/java, ou digite o endereço no campo Enter or select the parente folder, e em File name digite o nome do arquivo hibernate.cfg.xml [13]; Na próxima tela, marque a opção Create XML file from an XML template e clique no botão Finish [14]. Figura [11]: Criação do arquivo XML Figura [12]: Criação do Arquivo XML Seleção do template do arquivo 1/

16 Figura [13] Criação do Arquivo XML Configuração do Arquivo Figura[14]: Criação do Arquivo XML Seleção do Template Feito isso, abra o arquivo criado e digite o seguinte código, a partir da linha 01: 1. <?xml version='1.0' encoding='utf-8'?> 2. <!DOCTYPE hibernate-configuration PUBLIC 3. "-//Hibernate/Hibernate Configuration DTD//EN" 4. " 5. <hibernate-configuration> 6. <session-factory> 7. <property name="dialect"> 8. org.hibernate.dialect.postgresql9dialect 9. </property> 10. <property name="connection.driver_class"> 11. org.postgresql.driver 12. </property> 13. <property name="connection.url"> 14. jdbc:postgresql://localhost:5432/bd_financeiro 15. </property> 16. <property name="connection.username">postgres</property> 17. <property name="connection.password">abcd1234</property> 18. <property name="current_session_context_class">thread</property> 19. <property name="hibernate.hbm2ddl.auto">update</property> 20. </session-factory> 21. </hibernate-configuration> Sobre este código, os seguintes comentários merecem ser feitos: O código em questão se trata da configuração da conexão do sistema com o banco de dados; A propriedade dialect, que sempre retornará uma classe Dialect como valor, é necessária para que o sistema possa conversar com o banco de dados em sua linguagem; As outras configurações se referem ao Driver de conexão com o banco (driver_class), ao endereço que é usado na comunicação com o banco de dados (connection.url), o nome do usuário, que por padrão é postgres (connection.username), a senha do banco de dados, que é definida pelo usuário (pode ser modificada conforme desejo do desenvolvedor neste caso, será usada a senha abcd connection.password), o contexto da sessão, que será invocado toda vez que o método ConnectionFactory.getOpenSession() for invocado, trazendo a conexão que está ligada ao contexto (current_session_context_class), e a opção de, automaticamente, validar 1/

17 ou exportar a estrutura do banco de dados contendo as instruções DDL do banco, com base nas estruturas mapeadas, quando a SessionFactory é criada (hibernate.hbm2ddl.auto). Uma vez escrito o código, salve o projeto. Agora, para continuar o desenvolvimento, será necessário criar a classe que gerenciará a conexão com o banco, a atualização da estrutura do banco de dados, suas modificações, entre outros. Conforme comentado anteriormente, cada tarefa do sistema será separada por pacotes, para que suas atividades sejam restritas e não interfiram nas atividades de outras classes. Para isso, encapsularemos as classes em pacotes. Na criação de pacotes, será adotado o padrão financeiro.pacote, onde pacote é a definição do pacote que conterá as classes. No caso da classe ConnectionFactory, deverá ser criado o pacote financeiro.util. Clique com o botão direito em FinanceiroWeb, e em seguida New, e Class [15]; Digite o nome financeiro.util no campo Name e clique em Finish [16]. Figura [15]: Criação de Novo Pacote financeiro.util Figura [16]: Criação de Novo Pacote financeiro.util Uma vez criado o pacote financeiro.util, ele aparecerá dentro de Java Resources, src/main/java, com um ícone em branco. Isto porque o pacote ainda não teve nenhuma classe adicionada a ele. Iremos, então, criar a classe ConnectionFactory. Clique com o botão direito no pacote financeiro.util, em seguida New e Class [17]; Na próxima tela, no campo Name digite ConnectionFactory [18]. 1/

18 Figura [17]: Criação da Classe ConnectionFactory Figura [18]: Criação da Classe ConnectionFactory Uma vez que a classe foi criada, perceba que o ícone do pacote financeiro.util se tornou amarelo, uma vez que já existe uma classe dentro dele. Abra a classe ConnectionFactory e implemente o seguinte código: 1. package financeiro.util; 2. import org.hibernate.sessionfactory; 3. import org.hibernate.cfg.configuration; 4. public class ConnectionFactory { 5. private static final SessionFactory sessionfactory = buildsessionfactory(); 7. private static SessionFactory buildsessionfactory() { 8. // TODO Auto-generated method stub 9. try { 10. Configuration cfg = new Configuration(); 11. cfg.configure("hibernate.cfg.xml"); 12. return cfg.buildsessionfactory(); 13. }catch (Throwable e){ 14. System.out.println("Criação inicial do objeto SessionFactory falhou."); 15. System.out.println("Erro: " + e); 16. throw new ExceptionInInitializerError(e); 17. } 18. } 19. public static SessionFactory getsessionfactory(){ 20. return sessionfactory; 21. } 22. } Sobre este código, há algumas considerações a serem feitas 1/

19 O método buildsessionfactory() é o responsável por criar uma nova SessionFactory com base no arquivo XML construído. Esse mesmo método é responsável por retornar uma SessionFactory quando uma chamada for realizada ao método getsessionfactory(). Ao executar o comando new Configuration(), o Hibernate procura pelo arquivo hibernate.properties no pacote raiz src/java/main. Contudo, perceba que junto a este comando, o método configure() é invocado, fazendo com que o Hibernate procure pelo arquivo declarado no método, que no caso é o que criamos, hibernate.cfg.xml. Caso ele não exista, será gerada uma exceção. Uma vez criada a classe ConnectionFactory, as demais classes do sistema deverão ser criadas, começando pela classe Usuário, responsável por gerenciar o cadastro de novos usuários. A medida que o desenvolvimento do sistema avançar, as classes já geradas, bem como os arquivos criados, sofrerão modificações. 1/

20 3.3.3 Criação do Pacote Usuario, Suas Classes e Conexão ao Banco de Dados Para a criação do pacote Usuário, que irá englobar todas as responsabilidades acerca do usuário do sistema, basta executar os procedimentos para a criação do pacote Util, conforme descrito acima. Modifique o nome para financeiro.usuario. Para criar a classe Usuário, o desenvolvedor deverá usar os mesmos procedimentos usados para criar a classe ConnectionFactory: Clique com o botão direito do mouse em financeiro.usuário, então em New e depois Class; No campo Name, digite Usuário, e clique em Finish. DICA IMPORTANTE: Toda vez que fizer qualquer alteração no código, é interessante salvar o projeto com o atalho Ctrl+Shift+S. Isso evita perda de dados por algum problema (queda de energia, erro no programa, etc). CLASSE USUÁRIO Uma vez criada a classe, é hora de identificar as propriedades que o usuário do sistema deve possuir, que serão preenchidas no ato do cadastro. O código da classe Usuário, inicialmente, deverá ser o seguinte: 1. package financeiro.usuario; 2. import java.io.serializable; 3. import java.util.date; 4. public class Usuário implements Serializable{ 5. private static final long serialversionuid = 1L; 6. private Integer codigo; 7. private String nome; 8. private String ; 9. private String login; 10. private String senha; 11. private Date nascimento; 12. private String celular; 13. private String idioma; 14. private Boolean ativo; 15. // gerar Getters e Setters 16. // gerar HashCode e Equals 17. } Visando facilitar a criação do código, para gerar os métodos Gets e Sets, referidos no código Usuário como Getters (para retornar os valores armazenados) e Setters (para atribuir ou modificar valores) das variáveis, coloque o cursor onde deseja que os códigos se iniciem, clique com o botão direito do mouse, e vá em Source e Generate Getters and Setters [19]. Selecione então todas as variáveis (por meio do botão à direita Select All, menos a variável referente à implementação da Superclasse Serializable. Clique em Ok para finalizar. [20]. Os métodos HashCode e Equals são utilizados para que todo conteúdo das classes persistíveis do projeto sejam comparados. Isso é necessário porque, em uma comparação simples, é considerado apenas o endereço de memória do 1/

21 objeto. Para tanto, clique em Source e então em Generate hashcode() and equals(). Siga, então, o mesmo procedimento da geração de Getters e Setters. Figura [19]: Geração dos Métodos Get e Set das Variáveis Figura [20]: Seleção das Variáveis para Geração dos Métodos Dessa forma, a classe Usuário foi criada com sucesso. Devemos compreender, contudo, que para que haja persistência dos dados desta classe, os mesmos deverão ser armazenados em um banco de dados específico. Deveremos, então, criar o banco de dados financeiro_bd. Para tanto, abra o programa pgadmin III, acesse o servidor do PostGres, e então clique com o botão direito do mouse em Databases e selecione New Database... [21]. No campo Name digite financeiro_bd, com o cuidado de verificar a grafia, e clique em Ok [22]. O banco de dados financeiro_bd foi criado com sucesso. Figura [21]: Criação de novo Banco de Dados Figura [22]: Criação de novo Banco de Dados (nome) 1/

22 Uma vez criado o Banco de dados, é necessário que seja criada a tabela Usuário dentro desse banco de dados. Para tal, selecione o banco de dados financeiro_bd e clique na lupa SQL na barra de ferramentas [23]. Depois, será aberta a tela de inserção de códigos SQL. Execute o código abaixo. Figura [23]: Acesso à Edição SQL 1. CREATE TABLE usuario ( 2. codigo INT NOT NULL PRIMARY KEY, 3. nome VARCHAR (50) NOT NULL, 4. login VARCHAR (15) NOT NULL UNIQUE, 5. VARCHAR (100) NOT NULL, 6. senha VARCHAR (10) NOT NULL, 7. nascimento DATE NOT NULL, 8. celular VARCHAR, 9. idioma VARCHAR NOT NULL, 10. ativo BOOLEAN NOT NULL 11. ); Para saber se a tabela foi criada corretamente, execute o seguinte comando SQL: SELECT * FROM usuário; Deverá aparecer a tabela no campo Output pane conforme abaixo: Figura [24]: Tabela Usuário Caso o PostGres retorne algum erro, verifique a maneira como as variáveis foram informadas, bem como as palavras reservadas ao programa. Uma vez criada a tabela dentro do banco de dados, é necessário mapear a classe Usuário, para que o sistema FinanceiroWeb saiba que esta classe deverá se comunicar com aquela tabela. Para tanto, modificaremos a classe Usuário da seguinte forma (destacadas em vermelho): 1. package financeiro.usuario; 2. import java.io.serializable; 3. import java.util.date; 4. public class Usuário implements Serializable{ 6. private static final long serialversionuid = 1L; 1/

23 9. private Integer codigo; 10. private String nome; 11. private String ; 13. private String login; 14. private String senha; 15. private Date nascimento; 16. private String celular; 17. private String idioma; 18. private Boolean ativo; 19. // Getters e Setters 20. // HashCode e Equals 21. } As modificações acima são necessárias para que o Hibernate entenda que esta se trata de uma classe que deverá ter seus dados persistidos no banco de dados declarado dentro do arquivo hibernate.cfg.xml. Isso é possível por meio da declarando que se trata de uma entidade do banco de dados. As referenciam a chave primária na tabela usuário do banco de dados, indicando que aquela variável deverá ser a chave primária autonumerada. A da variável login indica que esta é a chave natural (ou uma segunda chave primária) do elemento Usuário, e que dois usuários não poderão ter o mesmo valor de login no sistema. INTERFACE USUARIODAO Para seguir as diretrizes do Design Pattern DAO (Data Access Object), e consequentemente seguir as regras de separação de responsabilidades dentro do sistema, será criada a interface UsuarioDAO, que conterá a assinatura de todos os métodos das operações a serem feitas no banco de dados. Para criar uma nova interface, clique com o botão direito em cima do pacote financeiro.usuario, então em New e em Interface [25]. Na próxima tela, digite no campo Name o nome da interface UsuarioDAO e depois em Finish [26]. 1/

24 Figura [24]: Criação da Interface UsuarioDAO Figura [25]: Criação da Interface UsuarioDAO (Nome da Interface) Uma vez criada a interface, o código a ser implementado na mesma segue abaixo. 1. package financeiro.usuario; import java.util.list; public interface UsuarioDAO { public void salvar(usuario usuario); public void atualizar(usuario usuario); public void excluir(usuario usuario); public Usuario carregar(integer codigo); public Usuario buscarporlogin(string login); public List<Usuario> listar(); } CLASSE USUARIODAOHIBERNATE Agora, deverá ser criada a classe UsuarioDAOHibernate, que irá implementar a interface UsuarioDAO. Para cria-la, siga os procedimentos para criar a classe Usuario: clique com o botão direito no pacote financeiro.usuario, e então New e Class. Digite o nome UsuarioDAOHibernate e posteriormente em Finish. Para implementar a interface, modifique a linha de abertura do corpo da classe, adicionando implements UsuarioDAO na frente da palavra UsuarioDAOHibernate [26]. Feito isso, o sistema apresentará um erro, visto que uma interface foi implementada, mas os seus métodos não foram adicionados na classe. Para resolver este problema, basta posicionar o cursor sobre a palavra (agora destacada com uma 1/

25 linha de erro) UsuarioDAOHibernate e, quando a tela de Quickfix aparecer, selecione a opção Add uninplemented methods [27]. Os métodos declarados na interface serão automaticamente importados para a classe. Figura [26]: Implementação da Interface UsuarioDAOHibernate Figura [27]: Importação dos Métodos da Interface DICA: Caso prefira, você pode implementar a interface no momento da criação da classe. Na configuração da classe, teremos procedimentos novos para a implementação da interface. No campo Name, digite UsuarioDAOHibernate, e em Interfaces, clique em Add [28]. No campo de buscas, digite financeiro.. Para que a interface apareça no campo de seleção. Clique nela e clique em Ok [29]. O nome da interface deverá aparecer dentro do campo Interfaces. Certifiquese que a opção Inherit abstract methods esteja marcada e clique em Finish. Figura [28]: Criação da Classe UsuarioDAOHibernate Figura [29]: Seleção da Interface UsuarioDAO Uma vez que a interface foi implementada, o código da classe UsuarioDAOHibernate deverá ser modificado, conforme descrito: 1. package financeiro.usuario; import java.util.list; import org.hibernate.query; 6. import org.hibernate.session; public class UsuarioDAOHibernate implements UsuarioDAO { 9. 1/

26 10. private Session session; public void setsession(session session) { 13. this.session = session; 14. } public void salvar(usuario usuario) { 18. // TODO Auto-generated method stub 19. this.session.save(usuario); 20. } public void atualizar(usuario usuario) { 24. // TODO Auto-generated method stub 25. this.session.update(usuario); 26. } public void excluir(usuario usuario) { 30. // TODO Auto-generated method stub 31. this.session.delete(usuario); 32. } public Usuario carregar(integer codigo) { 36. // TODO Auto-generated method stub 37. return (Usuario) this.session.get(usuario.class, codigo); 38. } public Usuario buscarporlogin(string login) { 42. // TODO Auto-generated method stub 43. String hql = "select u from Usuario u where u.login = :login"; 44. Query consulta = this.session.createquery(hql); 45. consulta.setstring("login", login); 46. return (Usuario) consulta.uniqueresult(); 47. } public List<Usuario> listar() { 52. // TODO Auto-generated method stub 53. return this.session.createcriteria(usuario.class).list(); 54. } 55. } Alguns comentários são pertinentes a este código Toda classe DAOHibernate do sistema deverá implementar um código Session (declaração de variáveis e construtor). É por meio desse padrão que será injetada a Session do Hibernate no código, e as operações do Hibernate serão executadas no banco de dados. O resto do código é auto-explicativo. A operação session.save irá cadastrar um novo usuário no banco de dados (comandos SQL INSERT); a operação session.update é utilizada para modificar as informações de um usuário já cadastrados (comandos SQL UPDATE); session.delete é a operação utilizada para excluir um usuário do banco de 1/

27 dados (comandos SQL DELETE); a operação session.get carrega todos os dados de usuário recebidos no parâmetro. O método recebe a classe Usuario.class e o código do usuário (Integer codigo), e não o objeto Usuario (comandos SQL SELECT); e a operação session.createcriteria(usuario.class).list() retorna uma listagem completa dos usuários cadastrados, por meio de uma consulta forçada ao banco de dados sem qualquer critério. Cabe comentar o método buscaporlogin. Neste método, é realizada uma consulta por meio de um Query (instrução), utilizando a linguagem HQL (parecida com a SQL, mas adaptada para o mundo objeto-relacional). Uma vez que Não há mais de um resultado na consulta, o método consulta.uniqueresult() é invocado. CLASSE DAOFACTORY A classe DAOFactory será o construtor de DataAccessObjects, concentrando em si a reponsabilidade de instanciar todas as classes DAO do sistema. Esta será a classe onde as classes de regra de negócio obterão uma instância das interfaces DAO, e onde será atribuída a Session às instâncias DAOHibernate que serão criadas. Para criar a classe, que deverá estar dentro do pacote financeiro.util, siga os procedimentos mencionados para a criação da classe Usuario, e no campo Name digite DAOFactory. Uma vez criada, o seguinte código deverá ser implementado. 1. package financeiro.util; import financeiro.usuario.usuariodao; 4. import financeiro.usuario.usuariodaohibernate; public class DAOFactory { public static UsuarioDAO criarusuariodao() { 9. UsuarioDAOHibernate usuariodao = new UsuarioDAOHibernate(); 10. usuariodao.setsession(connectionfactory.getsessionfactory() 11..getCurrentSession()); 12. return usuariodao; 13. } } INFRAESTRUTURA DA CONEXÃO AO BANCO DE DADOS OPEN SESSION IN VIEW Para evitar criar uma conexão ao banco de dados a cada operação a ser realizada, e consumir recursos desnecessários do sistema, será utilizada a técnica Open Session in View, descrita na documentação Hibernate. Tal regra define que a sessão Hibernate será aberta no início do processamento da requisição ao servidor, estando disponível e aberta durante a execução de regras de negócio e operações no banco de dados, e será finalizada e efetivada no banco antes da entrega do resultado ao usuário. Para isso, toda requisição que chegar ao servidor precisará ser interceptada., o que é possível usando os Filters do JavaEE. O primeiro passo é a criação da classe ConnectionFactoryFilter. Para tanto, deverá ser criado o pacote financeiro.web.filter, e em seguida, a classe ConnectionFactoryFilter dentro do pacote. Siga o exemplo da criação do pacote financeiro.usuario e classe Usuario. 1/

28 A classe deverá ser criada conforme o modelo abaixo. 1. package financeiro.web.filter; import java.io.ioexception; import javax.servlet.filter; 6. import javax.servlet.filterchain; 7. import javax.servlet.filterconfig; 8. import javax.servlet.servletexception; 9. import javax.servlet.servletrequest; 10. import javax.servlet.servletresponse; import org.hibernate.sessionfactory; import financeiro.util.connectionfactory; public class ConnectionFactoryFilter implements Filter{ private SessionFactory sf; public void destroy() { 22. // TODO Auto-generated method stub 23. } public void dofilter(servletrequest request, ServletResponse response, 27. FilterChain chain) throws IOException, ServletException { 28. // TODO Auto-generated method stub 29. try { 30. this.sf.getcurrentsession().begintransaction(); 31. chain.dofilter(request, response); 32. this.sf.getcurrentsession().gettransaction().commit(); 33. this.sf.getcurrentsession().close(); 34. } catch (Throwable ex) { 35. try { 36. if (this.sf.getcurrentsession() 37..getTransaction().isActive()) { 38. this.sf.getcurrentsession() 39..getTransaction().rollback(); 40. } 41. } catch (Throwable t) { 42. t.printstacktrace(); 43. } 44. throw new ServletException(ex); 45. } 46. } public void init(filterconfig arg0) throws ServletException { 50. // TODO Auto-generated method stub 51. this.sf = ConnectionFactory.getSessionFactory(); 52. } 53. } Ao analisar este código, verificamos algumas particularidades. 1/

29 Conforme podemos observar, executamos com essa classe um procedimento anterior a qualquer outro no código, que é a invocação do método begintransaction() da sessão atual. No método dofilter, a requisição web pode ser interceptada. Nesse ponto, o processamento é passado para a execução normal, e caso essa linha não fosse executada, o objetivo original da requisição não seria alcançado. O método comit() sinaliza a conclusão da transação e o método close() fecha a sessão atual. Caso haja algum erro, o bloco Catch faz o tratamento, e qualquer alteração que tenha sido feita é desfeita pelo método rollback(). Por fim, temos o método init(), que é executado somente quando o aplicativo em questão é colocado no ar, é o método destroy(), que é executado quando o aplicativo é desativado ou o servidor é retirado do ar. Para que toda requisição passe pelo filtro, é necessário realizar uma alteração no arquivo web.xml. Abra-o e realize as seguintes alterações. 1. [...] 2. <filter> 3. <display-name>conexaofilter</display-name> 4. <filter-name>conexaofilter</filter-name> 5. <filter-class> 6. financeiro.web.filter.connectionfactoryfilter 7. </filter-class> 8. </filter> 9. <filter-mapping> 10. <filter-name>conexaofilter</filter-name> 11. <url-pattern>*.xhtml</url-pattern> 12. </filter-mapping> Dessa forma, o sistema é informado que toda e qualquer requisição cuja extensão seja.xhtml, será interceptada pela classe ConnectionFactoryFilter. MAPEAMENTO DA CLASSE USUARIO NO HIBEERNATE Uma vez criado o filtro, é necessário informar ao Hibernate da existência de uma classe mapeada, para que ele considere a existência dessa classe. Para tanto, deverá ser incluído o seguinte código no arquivo hibernate.cfg.xml. <mapping class="financeiro.usuario.usuario" /> CRIAÇÃO DA CLASSE DE REGRAS DE NEGÓCIO Todas as classes de Regra de Negócio que serão criadas no sistema serão, cada uma em seu respectivo pacote, as únicas camadas a se comunicar com a camada de banco de dados. Para criar a classe de regra de negócio do pacote usuário, clique no pacote financeiro.usuario, New, Class e em Name, digite UsuarioRN. Sua estrutura deverá ser conforme abaixo. 1. package financeiro.usuario; import java.util.list; import financeiro.util.daofactory; 1/

30 6. 7. public class UsuarioRN { private UsuarioDAO usuariodao; public UsuarioRN() { 12. this.usuariodao = DAOFactory.criarUsuarioDAO(); 13. } public void salvar(usuario usuario) { 16. Integer codigo = usuario.getcodigo(); 17. if (codigo == null codigo == 0) { 18. this.usuariodao.salvar(usuario); 19. } else { 20. this.usuariodao.atualizar(usuario); 21. } 22. } public void excluir(usuario usuario) { 25. this.usuariodao.excluir(usuario); 26. } public Usuario carregar(integer codigo) { 29. return this.usuariodao.carregar(codigo); 30. } public Usuario buscarporlogin(string login) { 33. return this.usuariodao.buscarporlogin(login); 34. } public List<Usuario> listar() { 37. return this.usuariodao.listar(); 38. } 39. } Ao analisar o código, verifica-se que não há qualquer referência ao Hibernate nesta classe, o que mostra um alto nível de separação entre a camada de acesso a dados e regra de negócio. Verifica-se ainda foi implementado um construtor DAOFactory, e que uma propriedade para cada DAO que for necessária para a classe de instanciação dessa propriedade. Ou seja: cada classe de regra de negócio sempre terá dois elementos padrão: A declaração de uma propriedade com o tipo DAO utilizado na classe; Um construtor com uma instância desse DAO na classe DAOFactory. O método salvar() verifica se se trata de novo cadastro, ou cadastro já existente, e direciona para o método correto (usuariodao.salvar() ou usuariodao.atualizar(), conforme o caso). Os métodos restantes foram comentados anteriormente, na criação da classe UsuarioDAOHibernate. CRIAÇÃO DO BEAN GERENCIÁVEL USUARIOBEAN A classe UsuarioBean será o bean gerenciável do JSF, guardando todos os dados e funcionalidades para a tela de cadastro de usuários. Tal como todas as outras classes Bean, ficará armazenada no pacote financeiro.web. 1/

31 Seguindo o esquema de criação de novos pacotes/novas classes, conforme demonstrado desde o início do projeto, crie um novo pacote chamado financeiro.web e uma nova classe, dentro desse novo pacote, chamada UsuarioBean. ATENÇÃO!!! É possível que a IDE Eclipse acuse um erro, informado que o pacote a ser criado já existe. Isto se deve porque o pacote financeiro.web.filter é tido como pacote-filho do pacote financeiro.web. Neste caso, o aconselhável é: Realizar o backup do código presente na classe ConnectionFactoryFilter, dentro do pacote financeiro.web.filter; Deletar o pacote financeiro.web.filter; Criar o pacote financeiro.web e, então, criar o pacote financeiro.web.filter novamente; Criar as classes UsuarioBean dentro do pacote financeiro.web e ConnectionFactoryFilter na classe financeiro.web.filter. Restaure o codigo desta última. O código da classe UsuarioBean ficará, inicialmente, da forma abaixo. 1. package financeiro.web; import java.io.serializable; import javax.faces.application.facesmessage; 6. import javax.faces.bean.managedbean; 7. import javax.faces.bean.requestscoped; 8. import javax.faces.context.facescontext; import financeiro.usuario.usuario; 11. import financeiro.usuario.usuariorn; 12. (name = "usuariobean") 15. public class UsuarioBean implements Serializable { private static final long serialversionuid = 1L; private Usuario usuario = new Usuario(); 20. private String confirmarsenha; // gerar Getters e Setters } Uma vez que os métodos Get e Set das variáveis já instanciadas forem criados, é necessário agora pensar em como será construída a classe em si. Para tanto, precisamos primeiramente criar o arquivo de visualização, e levantar quais informações serão mostradas na página. Para tanto, será criada a página usuario.xhtml. CRIAÇÃO DE PÁGINAS.XHTML As páginas.xhtml serão criadas, todas, dentro da pasta src/webapp. Para a criação desta página específica, primeiro precisamos criar a pasta público, que a armazenará. 1/

32 Para criara pasta público, clique com o botão direito do mouse em cima da pasta webapp, conforme indicado acima, e então New e Folder [30]. Na próxima tela, basta digitar no campo Folder name a informação publico e clicar em Finish [31]. Para criar o arquivo usuário.xhtml dentro da pasta publico, clique com o botão direito em cima dela e então New e HTML file [32]. Na próxima tela, digite no campo Name o nome usuario.xhtml, clique em Next [33], e então, selecione a opção New Facelete Composition Page no campo Templates [34]. Figura [30]: Criação da Pasta publico Figura [31]: Criação da Pasta Público Figura [32]: Criação da Página usuário.xhtml 1/

33 Figura [33]: Criação da Página usuário.xhtml Figura [34]: Configuração do Template.xhtml Feito isso, o seguinte código deverá ser implementado no arquivo usuario.xhtml. 1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 2. " <html xmlns=" 5. xmlns:ui=" 6. xmlns:h=" 7. xmlns:f=" <h:head> 10. <title>financeiroweb >> Cadastro de Usuário - Versão 1.0</title> 11. </h:head> 12. <h:body> 13. <h1>cadastro de Usuário</h1> 14. <h:form id="cadastro"> 15. <h:messages /> 16. <h:inputhidden value="#{usuariobean.usuario.codigo}" /> 17. <h:inputhidden value="#{usuariobean.usuario.ativo}" /> <h:panelgrid columns="2"> 20. <h:outputlabel value="nome:" for="nome" /> 21. <h:inputtext id="nome" label="nome" 22. value="#{usuariobean.usuario.nome}" size="30" maxlength="30" required="true" requiredmessage="você esqueceu o nome, motherfucker!"> 23. <f:validatelength minimum="10" maximum="30" /> 24. </h:inputtext> <h:outputlabel value="data de Nascimento:" for="data" /> 27. <h:inputtext id="data" label="data Nascimento" value="#{usuariobean.usuario.nascimento}" size="10" maxlength="10" required="true"> 28. <f:convertdatetime datestyle="medium" /> 29. </h:inputtext> <h:outputlabel value="celular:" for="celular" /> 32. <h:inputtext id="celular" label="celular" value="#{usuariobean.usuario.celular}" size="10" /> <h:outputlabel value=" " for=" " /> 35. <h:panelgroup> 1/

34 36. <h:inputtext id=" " label=" " value="#{usuariobean.usuario. }" size="50" maxlength="50" required="true" validatormessage=" inválido"> 37. <f:validateregex /> 38. </h:inputtext> 39. <h:message for=" " /> 40. </h:panelgroup> <h:outputlabel value="idioma:" for="idioma" /> 43. <h:selectoneradio id="idioma" value="#{usuariobean.usuario.idioma}"> 44. <f:selectitem itemvalue="pt_br" itemlabel="português" /> 45. <f:selectitem itemvalue="en_us" itemlabel="english" /> 46. <f:selectitem itemvalue="es_es" itemlabel="espanol" /> 47. </h:selectoneradio> <h:outputlabel value="login:" for="login" /> 50. <h:inputtext id="login" label="login" value="#{usuariobean.usuario.login}" size="15" maxlength="15" required="true" validatormessage="login deve ter no mínimo 5 e no máximo 15 caracters e só pode ter os simbolos '.' e '_'."> 51. <f:validateregex pattern="([a-z] [0-9] [.] [_]){5,15}"/> 52. </h:inputtext> <h:outputlabel value="senha:" for="senha" /> 55. <h:inputsecret id="senha" label="senha" value="#{usuariobean.usuario.senha}" size="10" maxlength="10" required="true" redisplay="true" /> <h:outputlabel value="confirmar Senha:" for="confirmarsenha"/> 58. <h:inputsecret id="confirmarsenha" label="confirmar Senha" 59. value="#{usuariobean.confirmarsenha}" size="10" maxlength="10" required="true" redisplay="true" /> 60. </h:panelgrid> <h:commandbutton action="#{usuariobean.actionsalvar}" value="salvar" /> 63. </h:form> 64. </h:body> 65. </html> É interessante notar o elemento <h:messages /> no início do formulário. Ele irá retornar a mensagem de erro, o que não ocorre caso ela não exista, e o formulário é retornado sem que as alterações sejam gravadas no banco. Os campos ocultos são importantes, pois alimentam totalmente o objeto (neste caso, objeto Usuário), e assim estará pronto para ser salvo no banco. Caso contrário, informações importantes se perderiam. O atributo required, visto em diversos campos, impede que o formulário seja processado sem que o campo seja preenchido. No caso específico de e login, os campos deverão ainda, ser preenchidos com os padrões descritos nos validadores de expressões regulares. Caso o sistema encontre erros, o atributo requiredmessage permite que a mensagem padrão do sistema seja substituída. 1/

35 Uma vez executada a implementação, a classe UsuarioBean deverá ser modificada, para comportar os campos e atributos do formulário. 1. package financeiro.web; import java.io.serializable; import javax.faces.application.facesmessage; 6. import javax.faces.bean.managedbean; 7. import javax.faces.bean.requestscoped; 8. import javax.faces.context.facescontext; import financeiro.usuario.usuario; 11. import financeiro.usuario.usuariorn; 12. (name="usuariobean") 15. public class UsuarioBean implements Serializable { private static final long serialversionuid = 1L; private Usuario usuario = new Usuario(); 20. private String confirmarsenha; public String novo() { 23. this.usuario = new Usuario(); 24. this.usuario.setativo(boolean.true); 25. return "usuario"; 26. } public String salvar() { 29. FacesContext context = FacesContext.getCurrentInstance(); 30. String senha = this.usuario.getsenha(); 31. if (!senha.equals(this.confirmarsenha)) { 32. FacesMessage facesmessage = new FacesMessage( 33. "A senha não foi confirmada corretamente"); 34. context.addmessage(null, facesmessage); 35. return null; 36. } 37. UsuarioRN usuariorn = new UsuarioRN(); 38. usuariorn.salvar(usuario); 39. return "usuariosucesso"; 40. } public Usuario getusuario() { 43. return usuario; 44. } public void setusuario(usuario usuario) { 47. this.usuario = usuario; 48. } public String getconfirmarsenha() { 51. return confirmarsenha; 52. } public void setconfirmarsenha(string confirmarsenha) { 1/

36 55. this.confirmarsenha = confirmarsenha; 56. } 57. } O método novo() cria uma nova instância de usuário e altera a propriedade ativo para true. Então, ela retorna usuário, que significa que a página usuario.xhtml será exibido. O método salvar() inicia com uma chamada do método FacesContext().getCurrentInstance(). Neste caso, a instância será utilizada para adicionar mensagens de erro que possam vir a ser criadas. Então, é feita a validação da senha com a confirmação da senha. Caso não sejam iguais, o programa retornará null, o que significa que ele não será executado, mas continuará na mesma tela. Caso não haja erros nos campos, o método retornará usuariosucesso. Agora, precisamos configurar a camada de visualização. No início do projeto, informamos ao sistema que a página index.html será a primeira página a ser executada, por meio da declaração <welcome-file-list>. Ela, então, funcionará como ponto de entrada ao sistema. Não é interessante, contudo, torna-la uma página de visualização, ou execução de métodos, tendo em vista a necessidade de implementação da segurança no sistema. Sendo assim, ela será tão somente a porta de entrada. O primeiro passo é criar o arquivo. Conforme informado acima, basta clicar com o botão direito do mouse na pasta webapp, selecionar New, HTML file, e na próxima tela, informar o nome index.html. Como já criamos pastas com o template Facelets Composition, não há necessidade de avançar para a próxima página. Basta clicar em Finish. A página index.html deverá ser modificada, e passará a conter somente o seguinte código. <META HTTP-EQUIV="Refresh" CONTENT="0;URL=publico/login.xhtml"> O código é simples de ser entendido. O arquivo fará o redirecionamento automático para a página login.xhtml localizada na pasta publico. O número 0 significa quantos segundos a página aguardará para realizar o direcionamento. Vale lembrar que é necessário verificar no arquivo web.xml qual o nome do arquivo que está dentro da declaração welcome-file-list. Os nomes devem ser coincidentes. O problema é que, agora, a página index.html irá redirecionar o usuário a um arquivo inexistente. Para resolver este problema, cria-se o arquivo login.xhtml, dentro da pasta publico, nos mesmos moldes do arquivo usuário.xhtml, conforme exemplificado anteriormente. Após criado, o seguinte código será implementado. 1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 2. " <html xmlns=" 5. xmlns:ui=" 6. xmlns:h=" 7. xmlns:f=" <h:head> 10. <title>financeiroweb >> Login</title> 11. </h:head> 12. <h:body> 13. <h1>login</h1> 14. <hr /> 15. <h:form> 1/

37 16. <h:commandbutton action="#{usuariobean.novo}" value="registre-se"/> 17. </h:form> 18. <hr /> 19. </h:body> 20. </html> Dessa forma, toda vez que formos redirecionados para esta página, basta clicar no botão Registre-se para invocar o método novo() da classe UsuarioBean, e realizar o cadastro de novo usuário. Uma vez que o usuário tenha sido cadastrado com sucesso no sistema, o método salvar() retorna usuariosucesso. Como ainda não há a página usuariosucesso.xhtml para ser invocada, ela deverá ser criada na pasta publico, seguindo o modelo do arquivo usuário.xhtml. Uma vez criada a página usuariosucesso.xhtml, deverá ser implementado o seguinte código. 1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 2. " <html xmlns=" 5. xmlns:ui=" 6. xmlns:h=" 7. xmlns:f=" <h:head> 10. <title>financeiroweb >> Cadastro de Usuario >> Resultado</title> 11. </h:head> 12. <h:body> 13. <h1> 14. <h:outputtext value="#{usuariobean.usuario.nome}" /> 15., seja Bem-vindo 16. </h1> 17. Seu Cadastro foi efetuado com sucesso 18. <br /> 19. Clique <a href="login.xhtml">aqui</a> para efetuar o login. 20. </h:body> 21. </html> Dessa forma, toda vez que o cadastro de usuários for realizado, o método retornará esta página, para que sejamos novamente redirecionados para a página login.xhtml. Agora, é hora de testar o sistema até este ponto. O primeiro passo é ativar o servidor Apache Tomcat, que instalamos no computador. Para isso, note que, abaixo da tela de códigos, existe um campo com abas abertas. Geralmente, haverá uma aba chamada Servers. No entanto, pode ser que essa situação não se confirme. Partiremos deste pressuposto. Para habilitar a aba Servers, clique em Window na barra de menu, e então em Show View, e em Servers [35]. A aba de servidores deve estar habilitada agora [36]. 1/

38 Figura [35]: Habilitação da Aba Servers Figura [36]: Aba Servers Habilitada Habilitada a aba de servidores, clique no link que aparece no campo, conforme figura [36]. Na primeira tela que aparece, no campo Select the server type, procure pela pasta Apache, e selecione o servidor Tomcat v8.0 Server. Clique em Next [37]. Na tela de seleção do diretório de instalação, clique no botão Browse, e selecione a pasta do servidor que, conforme as orientações deste documento, estarão na pasta C:\Servidores. Clique em Next [38]. Simplesmente clique em Finish na próxima tela, e o servidor estará habilitado no sistema. Figura [37]: Habilitação do Servidor Apache Figura [38]: Seleção do Arquivo Servidor Uma vez habilitado, é necessário executa-lo. Para tanto, dentro da tela de configuração do servidor, selecione a opção Use Tomcat installation (takes controlo f Tomcat installation), e clique no ícone de play à direita [39]. O servidor vai carregar, e uma lista de logs deve aparecer na tela de console. Caso haja algum erro, ele será acusado neste momento. Caso não, o resultado final INFORMAÇÕES: Server startup in XXXX ms irá aparecer. 1/

39 Figura [39]: Funcionamento do Servidor Para verificar se o servidor está funcionando corretamente, abra um navegador, e digite na barra de endereço e execute. A página inicial do Apache Tomcat server deverá aparecer. Perceba também que um novo projeto, chamado Servers foi criado. Uma vez que o servidor esteja funcionando corretamente, é hora de testar o projeto, visando verificar seu funcionamento. Para tanto, clique com o botão direito no projeto FinanceiroWeb, e selecione Run as, e então Run on server [40]. Na próxima tela aparecerão todos os servidores habilitados na IDE. Como somente o servidor Apache Tomcat foi habilitado, somente ele estará disponível. Selecione-o e clique em Next [41] Se tudo correu bem, a tela de login deverá aparecer na área de desenvolvimento [42]. Figura [40]: Inicialização do Servidor Figura [41]: Seleção do Servidor 1/

40 Figura [42]: Servidor em Funcionamento Verifique se o cadastro está funcionando corretamente, realizado o cadastro de um usuário no banco de dados. Uma vez que o sistema esteja configurado corretamente, a página usuariosucesso.xhtml será invocada. Caso ocorra algum erro, será gerada uma exceção desse erro específico. Sugere-se que o desenvolvedor pesquise a origem do erro na web, em especial no fórum stackoverflow.com, para sua resolução. Para verificar se os dados foram corretamente inseridos, abra o banco de dados financeiro_bd, e execute a seguinte SQL. SELECT * FROM usuário; O res56ultado dessa consulta deverá ser a tabela usuário, populada com uma linha, relativa ao cadastro que o usuário acaba de executar. TRATAMENTO DE ERROS PELA CLASSE DAOEXCEPTION Pode acontecer, no entanto, algum erro do sistema. Pode ser uma classe instanciada de maneira incorreta, uma entidade não mapeada, ou mesmo erro de sintaxe. Geralmente, quando isso acontece, o sistema retorna um erro comum na tela de logs. Mas existem uma maneira de direcionar os erros para serem tratados de forma mais eficiente. As classes DAOException, UtilException e RNException servem para encapsular a exceção original, para então relançar, para que a camada superior tome uma ação, ou simplesmente relance. As classes Exception serão criadas dentro do pacote financeiro.util. Para criar as classes DAOException, UtilException e RNException, clique com o botão direito do mouse no pacote financeiro.util, New e então Class. Na tela de criação, digite o nome DAOException, digite java.lang.exception no campo Superclass e marque as opções Construtors from Superclass e Inherited abstract methods. Clique então em Finish [43]. Repita os procedimentos para as demais classes. 1/

41 Figura [43]: Criação da Classe DAOException Após criada, a classe acusará um aviso. Isso se deve porque não foi declarado o campo estático final serialversionuid. Basta declara-lo colocando o cursor sobre o nome da classe, e clicando em Add default version UID. DICA: Sobre o serialversionuid, retirado do blog caelum.com.br: Quando um objeto é serializado no Java, essa sequência de bytes, além de conter seus atributos de instância não transientes, carrega consigo um número que identifica a versão da classe que foi usada durante o processo. Esse é o chamado serialversionuid, ou seja, o identificador de versão de serialização de uma classe. Esse número é utilizado para saber se o objeto que estamos recuperando é de uma versão compatível com a versão da classe que foi utilizada quando serializamos o objeto: em outras palavras, os arquivos.class não precisam ser necessariamente os mesmos para que o processo de serialização ocorra com sucesso. ATENÇÃO!!! Pode se que as variáveis apareçam como arg0, arg1, etc. Isso quer dizer que o Java não está com seus arquivos-fonte em memória para poder obter o nome real dos parâmetros. Para corrigir esse problema: Clique em Window, Preferences [44]; Vá em Java, Installed JREs, selecione a JRE ativa e clique em Edit [45]; Na próxima tela, na lista JRE System Libraries, escolha o arquivo rt.jar e clique em Source Attachment [46]; Na janela seguinte, marque a opção External Location e clique no botão External File [47]; Você deverá localizar um arquivo chamado src.zip, que está dentro da pasta da JRE instalada. Caso não encontre, procure dentro da pasta JDK mais recente. Estão geralmente dentro do diretório de instalação do Java no computador; Uma vez selecionado, clique em Ok, Finish e OK novamente. Agora, delete o arquivo DAOException e crie outro. As variáveis estarão com os nomes corretos. Caso não estejam, instale a versão JDK mais recente e importe novamente o arquivo src.zip. 1/

42 Figura [44]: Preferências da IDE Figura [45]: Edição da JMV Ativa Figura [46]: Edição do Arquivo rt.jar Figura [47]: Seleção do Arquivo src.zip Por fim, salvar o projeto. Uma vez terminada a configuração de cadastro de usuários, com suas respectivas classes, e a configuração geral do sistema para comunicação com o banco de dados, é interessante pensar na administração dos usuários utilizando o elemento datatable. 1/