Criando um Aplicativo para a web com Java EE...

Criando um Aplicativo para a web com Java EE 7

Autor: Jean Robson Batista de Vargas - http://profissionaisjava.com 2


http://profissionaisjava.com



INDICE

Introdução............................................................................................................................................4 MÓDULO 1 - Instalando e Configurando o Java no Windows .............................................................5

Realizando o download e instalando o Java no Windows...............................................................5 Configurando as variáveis de ambiente do Java............................................................................10

Configurando a variável JAVA_HOME........................................................................................11 Configurando a variável CLASSPATH..........................................................................................14 Testando o processo de configuração das variáveis de ambiente ............................................15

MÓDULO 2 - Criando e Configurando Um Ambiente de Desenvolvimento Web Com Java .............17 Criando, entendo e executando o ambiente de desenvolvimento ...............................................17 Criando uma aplicação Java para Web com Maven ......................................................................23 Componentes da estrutura de uma aplicação Java para web.......................................................27 Configurando o projeto para utilizar JSF.......................................................................................30 Adicionando dependências do JSF no projeto Java para web.......................................................33

MÓDULO 3 - Fazendo Com Que o Mundo Orientado a Objetos se Comunique com o Mundo Relacional - Banco de Dados..............................................................................................................34

Criando a base de dados................................................................................................................38 Adicionando as Dependências do Hibernate e do PostgresSQL....................................................41 Criando o arquivo hibernate.cfg.xml .............................................................................................43 Criando a Classe Livros Para Persitência de Dados........................................................................46 Criando o DAO da aplicação...........................................................................................................52

MÓDULO IV - Criado Uma Aplicação Simples de CRUD com JAVA Web ...........................................57 Managed Beans..............................................................................................................................57 Arquivos de Configuração faces-config.xml e web.xml .................................................................59 Páginas web do projeto .................................................................................................................60 Instalando o Tomcat e Executando a Aplicação ............................................................................64

CONCLUINDO .....................................................................................................................................69

Introdução

Este ebook tem o propósito de trazer, de forma resumida, os principais componentes que norteiam a construção de um aplicativo java para web.

O primeiro módulo traz o processo de instalação, configuração e teste de uma pequena aplicação em java.

No segundo módulo, vamos configurar o ambiente para o desenvolvimento web com java. Instalaremos uma ferramenta (IDE) de geração e manipulação de código, criaremos e entenderemos a estrutura de uma aplicação web para java, etc.

No terceiro módulo começaremos a trabalhar com base de dados em java. Para isso instalaremos um banco de dados relacional e realizaremos o processo de mapeamento objeto relacional, o qual une o mundo relacional (tabelas) com o mundo orientado a objetos (classes).

No quarto módulo, realizaremos o começo de nossa aplicação web, com a tecnologia de desenvolvimento em java conhecida como Java Server Faces (JSF) .

Por fim, realizaremos uma introdução a biblioteca Primefaces, que tem a função de expandir as funcionalidades do JSF, adicionando vários recursos visuais a aplicação, bem como a utilização de Ajax e instalaremos um servidor web para testar nossa aplicação java web.

Por fim, teremos uma aplicação web simples montada, utilizando recursos de crud básico, como consultas, inserções, alterações e exclusões.

Bons estudos.



MÓDULO 1 - Instalando e Configurando o Java no Windows

Realizando o download e instalando o Java no Windows

Caso você não tenha a JDK/JRE instalado em seu computador é necessário que faça o download e instalação do mesmo.

Para isso é necessário ir até o site da oracle no seguinte endereço:

http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html?ssSourceSiteId=otnpt

Iremos trabalhar com o JDK 7, o qual já vem com JRE presente em seu pacote de instalação

Figura 1 - Relação de Pacotes de Instalação da JDK do Java

Foquei no ambiente Windows para download e instalação do Java, pois é o sistema operacional que estou utilizando neste computador onde estou criando este ebook. Caso você possua outro sistema operacional como Linux ou MacOS, o processo de instalação é feito de forma diferenciada.



Posteriormente, no blog http://profissionaisjava.com, farei uma postagem especifica para a instalação do Java nos sistemas operacionais citados anteriormente e mandarei por e-mail o link dos posts. Então, vou manter o foco de instalação e configuração do Java no ambiente Windows.

Voltando a figura 1, escolhi a versão de x64, para windows 64 bits, que faz referência ao arquivo jdk-7u71-windows-x64.exe. Caso seu sistema operacional seja de 32 bits, escolha a versão referente a x86, ou seja, para plataformas de 32 bits.

Clique sobre o arquivo citado anteriormente e você poderá ser levado ao mirror para baixar o arquivo ou o processo de download será feito de forma automática.

Após concluir o processo de download, vá até o arquivo e execute-o dando um duplo clique sobre o mesmo, para que o processo de instalação seja iniciado. A seguinte tela poderá ser exibida:

Figura 2 - Tela de Controle de Conta de Usuário do Windows

Neste passo, o UAC (Controle de Contas de Usuário), poderá pedir a você que dê permissões ao aplicativo de instalação do JDK para que possa alterar as configurações no sistema. Clique sobre o botão Sim. Após, você será remetido para primeira tela de instalação do JDK.



Figura 3 - Tela de Bem Vindo do Programação de Instalação do JDK do Java

Clique sobre o botão Next para ser remetido para a próxima tela.

Figura 4 - Tela que Demonstra as Ferramentas do JDK 7



Aqui estão os pacotes de ferramentas que fazem parte do Kit de Desenvolvimento do Java 7. Não modifique nada. Todos serão instalados em nosso computador conforme os padrões de instalação já definidos no instalador. Clique sobre o botão Next para continuar.

O instalador processará alguns dados e logo mostrará o path (caminho) aonde a JRE será instalada. Observe:

Figura 5 - Instalador do JDK exibindo o Path de Instalação da JRE

Clique sobre o botão Next para continuar e para que o processo de instalação dos arquivos seja executado e posteriormente finalizado conforme mostra a figura a seguir:

Figura 6 - Processo de Instalação em Processamento e Conclusão



Clique sobre o botão Close para finalizar o processo de instalação. Neste ponto, já estamos com o JDK e a JRE instalados em nosso computador. Você pode observar isso, indo até C:\Program

Files\Java.

Figura 7 - Pastas criadas pelo Instalador do JDK

Para testar se o processo de instalação ocorreu de forma correta, basta abrir janela de comando (prompt de comando) do Windows e digitar a seguinte instrução:

java -version

Caso o processo de instalação tenha sido feito de forma correta, a versão do java será exposta, conforme demonstra a figura a seguir:

Figura 8 - Prompt de Comando - Visualizando a Versã77o Instalada do Java

Partindo do pressuposto que tudo está correto até aqui, nosso próximo passo é configurar as variáveis de ambiente do Java. Isso será visto a seguir.



Configurando as variáveis de ambiente do Java

O propósito de configurar as variáveis de ambiente do Java é para garantir que o acesso as pastas de instalação, tanto do JDK, como do JRE, estejam acessíveis a outros programas que necessitem do java para sua execução.

Embora todo o processo de instalação no ambiente Windows ocorra via assistentes (wizards) e o JDK e a JRE estejam disponíveis na lista de programas em nosso computador, existem programas Java, como o Tomcat, por exemplo, que ignora tal processo de instalação e simplesmente procura a instalação do Java através de variáveis de ambiente.

Variáveis de ambiente nada mais são que apontadores, identificados através de aliases (apelidos), que indicam ou dão acesso a determinadas funcionalidades/aplicativos instalados em nosso computador.

Uma variável de ambiente muito conhecida e padrão no ambiente Windows é o Path, a qual indica, monta, informa ao sistema operacional, quais aplicativos deverão estar disponíveis em qualquer "lugar" aonde estejamos em nosso computador.

No caso para o JDK/JRE iremos fazer a configuração de duas variáveis:

1. JAVA_HOME: indica para o sistema operacional e aplicativos que necessitam do Java para execução aonde está o JRE ou JDK instalado. Neste caso em especifico, apontaremos para a pasta do JDK. Observe:

Figura 9 - Pasta do JDK 1.7 Utilizada Como Caminho Para a Variável JAVA_HOME

2. CLASSPATH: responsável por indicar o caminho das bibliotecas (jars) que serão utilizadas em nossos projetos. Podemos indicar algumas de inicio e, com o tempo, conforme exista necessidade, podemos ir adicionado. Para iniciar, geralmente apontamos para alguns jars, que estão presentes na pasta lib do JRE. Observe:



Figura 10 - Pasta Lib do JRE e suas bibliotecas (jars)

Configurando a variável JAVA_HOME

Para começar, vamos configurar a variável JAVA_HOME. Para isso, vá até o Painel de Controle, clique Sistema e Segurança, após em Sistema e por último em Configurações avançadas

do sistema. A seguinte caixa de dialogo será exposta:



Figura 11 - Caixa de Diálogo Propriedades do Sistema

Nesta caixa de diálogo, podemos realizar varias configurações referentes ao nosso sistema operacional. O que nos interessa aqui, é focar no que é relacionado as variáveis de ambiente. Então clique sobre o botão Variáveis de Ambiente, para que uma nova caixa de diálogo seja exposta.

Figura 12 - Caixa de Diálogo Para Criar e Editar as Variáveis de Ambiente

A caixa de diálogo Variáveis de ambiente é exposta. Aqui realizaremos a configuração das variáveis de ambiente do Java citadas anteriormente mas, neste momento, gostaria de salientar



um grande detalhe, ou seja, observe que esta caixa de diálogo possui duas áreas de configuração: Variáveis de ambiente para o usuário XXX (Jean - eu no caso) e Variáveis do sistema.

Ignore totalmente o que está relacionado as variáveis de usuário pois, o que for configurado aqui, servem apenas para o usuário "logado". Por exemplo, neste caso o usuário Jean está logado no computador. No momento que o usuário João acessar o computador, as variáveis configuradas anteriormente não estarão configuradas para ele pois.

Então, foque no que é relacionado as variáveis de sistema, ou seja, o que você configurar, criar aqui, estará disponível para qualquer usuário.

O primeiro passo é criar a variável JAVA_HOME e configura-la. Para isso clique no botão Novo, no grupo Variáveis do sistema. Entre com os dados conforme exibido na figura a seguir:

Figura 13 - Criando e Configurando a Variável JAVA_HOME

Em Nome da variável, digite JAVA_HOME em letras MAIÚSCULAS. Em Valor da variável, entre com o path (caminho) de instalação do JDK instalado em seu computador. Para finalizar, clique sobre o botão OK.

A variável JAVA_HOME será adiciona a lista de variáveis do sistema mas, para finalizar o procedimento de criação e configuração, devemos disponibiliza-la para todo o sistema operacional.

Para isso, o Windows possui a variável Path, que mantém adicionada a ela as demais variáveis de sistema criadas, bem como caminhos (configurações de folders/pastas) especificados de forma manual, sem ter outra variável de ambiente criada.

Procure na lista de variáveis de sistema pela variável Path e clique sobre o botão Editar. A seguinte caixa de diálogo será exibida:

Figura 14- Configurando a Variável de Sistema Path



Em Nome da variável NÃO FAÇA NADA. Em Valor da variável, vá até o final do conteúdo da caixa e digite: ;%JAVA_HOME%\bin. Clique sobre o botão OK para concluir.

Pronto. A variável JAVA_HOME está configurada. O valor digitado ;%JAVA_HOME%\bin, será explicado logo a seguir.

Configurando a variável CLASSPATH

Poderíamos deixar para configurar esta variável posteriormente, visto que a inclusão de bibliotecas Java (.jars) em nível de sistema serve apenas para quando determinado programa, que precisa do Java e consequentemente de tal biblioteca, verifique se a mesma está disponível (configurada) para acesso. Mas, vamos realizar de forma completa todo o processo de configuração de variáveis de ambiente para o Java.

Da mesma forma que você criou e configurou a variável JAVA_HOME anteriormente, faça o mesmo procedimento para a variável CLASSPATH, conforme demonstra a figura:

Figura 15 - Criando e Configurando a Variável CLASSPATH

Em Nome da variável digite CLASSPATH. Em Valor da variável, o conteúdo não ficou totalmente visivel conforme demonstra a figura. Então, digite:

.;%JAVA_HOME%\lib\tools.jar;%JAVA_HOME%\lib\jconsole.jar

onde:

• %JAVA_HOME% significa a mesma coisa que C:\Program Files\Java\jdk1.7.0_71, caminho configurado para a variável JAVA_HOME anteriormente. Os percentuais (%) são convenções para o sistema operacional Windows e devem OBRIGATORIAMENTE serem utilizados, pois indicam que o apontador se refere a uma variável já pré-configurada.

• \lib corresponde a pasta lib presente abaixo de C:\Program Files\Java\jdk1.7.0_71. Logo, \bin (configurado no tópico anterior), também corresponde a um folder, o qual contém o compilador Java, conhecido como javac e que será visto logo a seguir.

• tools.jar e jconsole.jar são bibliotecas java disponíveis no folder \lib.



Concluindo, juntando tudo o que descrito teríamos o seguinte:

• C:\Program Files\Java\jdk1.7.0_71\lib\tools.jar.

• C:\Program Files\Java\jdk1.7.0_71\lib\ jconsole.jar.

Figura 16 - Path e Listagem de .Jars Configurados na Variável CLASSPATH

Desta forma, as bibliotecas tools.jar e jconsole.jar estão disponíveis para qualquer aplicativo Java que precise delas.

Devo salientar que a variável CLASSPATH é configurada conforme existe a necessidade de adicionar bibliotecas e deixa-las disponíveis para qualquer programa Java. O que foi configurado anteriormente é apenas um exemplo e serve apenas para salientar o processo de configuração.

Testando o processo de configuração das variáveis de ambiente

Gosto de testar tudo o que faço e nosso procedimento agora será verificar se nosso processo de configuração foi feito de forma correta.

Para isso, abra a tela de de prompt de comando de comando do Windows e digite a seguinte instrução:

javac



Figura 17 - Testando o Processo de Configuração das Variáveis de Ambiente

Isso correspondente ao compilador do Java, ou seja, javac é responsável por compilar um programa Java tornando-o com capacidade de execução em determinada plataforma de ambiente operacional sendo, neste caso, o Windows.

Mas o objetivo aqui não é discutir a capacidade de compilação javac e sim testar o processo de configuração de variáveis de ambiente do Java. Então, caso você tenha as mesmas mensagens exibidas na figura acima, isso garante que o processo de configuração obteve sucesso.

Mas porque garante? Garante pelo simples fato de que o compilador javac, não esta configurado de forma natural quando instalamos o JDK/JRE em nosso computador. Este compilador está apenas na pasta bin do JDK ou JRE e não esta disponível seu acesso de forma direta no processo de instalação convencional.

Então, quando atribuímos a variável de sistema Path o valor ;%JAVA_HOME%\bin, estamos garantindo que tanto o compilador javac, assim como os demais utilitários que estão abaixo de \bin estejam disponíveis.

Concluímos aqui o processo de configuração das variáveis de ambiente do Java.

Nosso próximo passo é montar um ambiente de desenvolvimento para Java aonde, retornaremos, com certeza, a vários conceitos estudados até aqui.



MÓDULO 2 - Criando e Configurando Um Ambiente de Desenvolvimento Web Com Java

Criando, entendo e executando o ambiente de desenvolvimento

Para criar a aplicação Java Web deste ebook utilizaremos a ferramenta Eclipse.

O Eclipse é caracterizado como uma IDE, ou seja, uma ferramenta que tem o propósito de auxiliar o desenvolvedor de software, aumentando sua produtividade na produção de suas aplicações. Ele não é utilizado apenas para desenvolvimento de software Java, mas também para outras linguagens como C++ e PHP.

Vamos iniciar. Para realizar download do Eclipse IDE vá até site http://www.eclipse.org/.

Vá até se sessão downloads, e escolha a versão Eclipse IDE for Java EE Developers.

Figura 18 - Eclipse Configurado Para Desenvolvimento Web em Java

Não esqueça de escolher a versão para 32 ou 64 bits de acordo com seu Windows. No meu caso em particular é versão de 64 bits. Você será direcionado para a sessão de mirrors para download.

Escolha o primeiro link e salve o arquivo compactado em uma pasta de fácil acesso.



Figura 19 - Mirror Presente no Brasil Para Download do Eclipse

Tenho por premissa salvar na área de trabalho para fins didáticos, mas você pode salvar no folder/pasta que quiser, desde que essa pasta tenha permissão de leitura e escrita. Após o término do download, descompacte o arquivo em uma pasta com o nome de Eclipse.

Acesse a pasta e visualize seu conteúdo. Na pasta você um aplicativo “Executável” conforme mostra a figura a seguir:

Figura 20 - Executável do Eclipse

Dê um duplo clique sobre o ícone para executar o Eclipse IDE. Supondo que a JDK/JRE já esteja instalada e o processo de execução esteja correndo de forma correta, será exibida a tela de abertura da Eclipse IDE e após outra caixa de diálogo, referente ao workspace.



Figura 21 - Tela de Inicialização e Workspace

Workspace nada mais é que um diretório padrão aonde as configurações do Eclipse e os projetos criados a partir dele serão salvos. Claro que você pode gravar seus projetos em outros folders/pastas, mas o Eclipse toma esse diretório padrão como base.

Marque a opção Use this as the default and do not ask again. Isso garante que o Eclipse utilizará SEMPRE a pasta indicada no path do item Workspace e, consequentemente, essa caixa de diálogo não será mais exposta.

Não citei anteriormente, mas estamos trabalhando com a versão Luna do Eclipse IDE, sendo está a mais atualizada até o momento que estou criando este artigo. Geralmente, os conceitos vistos aqui, servem tanto para as versões anteriores, como as que virão a ser criadas.



Após, seremos enviados para área de trabalho do Eclipse IDE e veremos a guia Welcome.

Figura 22 - Eclipse em Execução

Até este momento, realizamos o processo de download, instalação e execução do Eclipse. Agora vamos realizar um pequeno tour pela ferramenta.

Feche a guia Welcome, pois ela está sobre toda a área de trabalho da ferramenta.

A área de trabalho do Eclipse IDE será exposta com suas ferramentas. A figura a seguir demonstra essa área de trabalho com um pequeno comentário em cada região da tela.



Figura 23 - Área de Trabalho do Eclipse

Onde:

• Área de Gerenciamento de Projetos: responsável por gerenciar toda a estrutura de folders/pastas (conhecidos como packages em java) e os arquivos que estes contém. Observe que por padrão o Eclipse disponibiliza a Guia Project Explorer mas, saliento que existem outras, que gerenciam tais folders e arquivos de forma mais otimizada. Veremos isso em outros artigos.

• Área Para Trabalho Com Arquivos: é neste local onde “abriremos” nossos arquivos fonte e os editaremos.

• Área de Gerenciamento de Estrutura Interna de Arquivos: Quando estamos com um arquivo aberto e existe a necessidade de visualizar o seu conteúdo de forma mais resumida ou até mesmo acessar determinada parte deste arquivo de forma rápida, utilizamos a guia Outline.

• Área de ferramentas Gerais: Esta área contém ferramentas que são utilizadas para fazer a instalação de servidores (Tomcat, Weblogic, JBoss, etc.), depuração de aplicações, visualização de erros e console de dados e assim por diante.



De forma prática, tudo o que foi descrito anteriormente é exibido na figura a seguir:

Figura 24 - Eclipse em Ação

Observe na guia Package Explorer nosso projeto com o nome de ProjetoTeste. Esse projeto possui uma classe java chamada Teste1.java, sendo que seu conteúdo é exibido no centro da área de trabalho da ferramenta.

Na guia Outline, podemos visualizar, de forma resumida, a estrutura de métodos desta classe. Para acessar determinado método de forma rápida, basta dar clique sobre o método desejado.

Para finalizar, como exemplo, gerei um erro java, de forma que possamos visualizar, na área de ferramentas gerais, na guia Problems, alguns “bugs” de codificação.

O objetivo aqui era criar um ambiente de desenvolvimento e não estudar o Eclipse IDE de forma mais aprofundada, mas resolvi tocar em alguns tópicos que achei relevante.

O projeto utilizado (ProjetoTeste) anteriormente como exemplo será descartado e criaremos no lugar dele outro projeto, com foco em uma aplicação Java para web. Isto será visto a seguir.



Criando uma aplicação Java para Web com Maven

Quando me refiro ao ambiente de desenvolvimento, não me refiro apenas a ferramenta de criação e manipulação de códigos Java e sim, ao contexto da aplicação num todo.

Neste ebook criaremos uma aplicação Java para Web simples do zero mas, mantendo o foco naquilo que realmente é importante, ou seja, entender toda a estrutura da aplicação e as ferramentas e utilitários que a rodeiam.

Criaremos agora um projeto do tipo Maven Project. Vá até o menu File, New, Maven

Project.

Figura 25 - Criando um projeto do tipo Maven Project

Poderíamos criar um projeto Java para Web de forma tradicional, ou seja, utilizando a opção Dynamic Web Project mas, desta forma, não teríamos o recurso avançado para gerenciamento de dependências proporcionado pelo Maven.

Em Java, assim como em outras linguagens de programação, o grande calcanhar de Aquiles é quando se faz referência ao grande número de bibliotecas e componentes que fazem parte da aplicação. No momento de empacotar o software para coloca-lo, por exemplo, em produção, se isso for feito de forma manual, podemos realizar tal procedimento de forma incorreta, trazendo bibliotecas e componentes errados ou até mesmo faltando.

Então, essa é a principal função do Maven, ou seja, gerenciar estes pacotes de componentes, para que no momento deste empacotamento do software nada dê errado. Não teríamos motivo algum para não utiliza-lo no projeto que será criado aqui.



Continuando, clique sobre a opção Maven Project, para que a seguinte caixa de diálogo seja exposta:

Figura 26 - Definindo o arquétipo do projeto Maven

Nesta caixa de dialogo, iniciamos o processo de configuração de nosso projeto Maven sendo que, possuímos duas opções, ou seja, com ou sem a utilização de arquétipos.

Arquétipos são para o Maven arquivos em formato .XML que tem a função de definir a estrutura e consequentemente as dependências que determinado projeto Java necessita. Em nosso caso em especifico, não utilizaremos arquétipo algum, bastando selecionar a opção Create a simple project (skip archetype selection) e após clicar sobre o botão Next para ser remetido para a próxima caixa de diálogo.



Figura 27 - Configurando o projeto Maven

Temos aqui:

• Group Id: pode-se considerar este item como sendo aquele que determina o nome da empresa ou grupo ao qual o projeto pertence.

• Artifact Id: corresponde ao nome do projeto.

• Version: Versão do projeto que está sendo criada.

• Packaging: define como nosso aplicativo deverá ser empacotado, ou seja, neste caso, o Maven saberá que nossa aplicação deverá ser do tipo Java Web, pois a opção war foi selecionada. Quando o projeto é criado no Eclipse, logo todo o formato e estrutura da aplicação é automaticamente criado.

• Description: Uma descrição de nosso sistema. É opcional.



Entre com as informações conforme descrito na figura e para finalizar clique sobre o botão Finish para que o projeto seja criado no Eclipse.

Figura 28 - Aplicação LivrariaWeb Criada e sua visualização na Guia Project Explorer

Caso você não esteja visualizando a guia Project Explorer, é provável que você esteja com uma perspectiva que não seja JavaEE. Para resolver o problema, basta que você observe no canto superior direito, pelo menos este é o padrão da ferramenta, o botão Open Perspective. Clicando nele a caixa de diálogo Open Perspective será exposta, bastando que você selecione a perespectiva JavaEE e após clique sobre o botão OK.

Pronto! Nosso projeto Java para Web está criado, sua estrutura está muito bem definida e gerenciada pelo Maven. Agora o próximo passo é entender os componentes que fazem parte desta aplicação.

Figura 29 - Janela Open Perspective



Componentes da estrutura de uma aplicação Java para web

Entender como é a estrutura de uma aplicação java para web é muito importante, pois desta forma, além de reconhecer e localizar os principais elementos (arquivos e folders), saberemos qual a função especifica de cada um dentro da aplicação.

Para iniciar, vamos entender como funciona a estrutura de um projeto do tipo Dynamic

Web Project. Observe a figura:

Figura 30 - Estrutura de uma aplicação Java Web Tradicional

Vou descrever aqui os itens principais que fazem para da estrutura exibida anteriormente.

• ProjetoWebExemplo: corresponde ao nome do projeto Java.

• Java Resources: permite/organiza o acesso a recursos da aplicação como códigos fontes (pasta src), bibliotecas gerais do projeto (Libraries) e assim por diante.

• WebContent: folder que realmente organiza a estrutura de arquivos da aplicação web. Aqui colocaremos nossos formulários JSF, imagens da aplicação e assim por diante.

• WEB-INF: mantém a pasta lib, responsável por gerenciar as bibliotecas (.jars) utilizados nesta aplicação. Também mantém arquivos com funções especificas dentro da aplicação.

• Faces-config.xml: arquivo responsável por manter regras de navegação, definir escopo e declaração de managed beans, etc. A partir da versão 2.0 do JSF não é mais obrigatório.



• Web.xml: é conhecido como Deployment Descriptor da aplicação, ou seja, realiza as configurações gerais da aplicação, como declaração de servlets, gerenciamento de tempo de timeout, definir parâmetros de conexão a banco de dados, definir as páginas iniciais da aplicação e assim por diante.

Toda essa estrutura estudada anteriormente ainda é valida quando se trata de um projeto criado a partir de um Maven Project com um packaging feito via war, ou seja, quando definimos no Maven que desejamos criar um projeto com este tipo de empacotamento, estamos dizendo para ele que o mesmo deve providenciar toda a estrutura de pastas/folders estudada anteriormente mas, agregando os recursos de gerenciamento de pacotes e deploy do Maven.

Figura 31 - Estrutura de uma aplicação Java Web criada a partir do Maven

Embora os itens estudados anteriormente não estejam aparecendo na estrutura exibida na imagem anterior, os mesmos serão criados conforme formos adicionando determinadas funcionalidades, como por exemplo, a utilização de JSF (Java Server Faces), mas isso será visto posteriormente. Outros serão substituídos, mas veremos isso com o tempo.

O que nos interessa aqui é agregar conhecimento com base no que está sendo exposto na imagem acima. Temos aqui:

• src/main/java: diretório responsável por armazenar os arquivos .java (código fonte) da aplicação.

• src/main/resources: diretório que armazena determinados arquivos de configuração da aplicação. Estes arquivos devem ficar obrigatoriamente armazenados neste folder. São adicionados conforme vamos utilizando determinadas funcionalidades Java em nosso projeto.



• src/main/webapp: Pasta para conteúdo Web. Folder relativo a WebContent em um projeto do tipo Dynamic web project.

• src/test/java: folder que contém arquivos para testes unitários.

• src/test/resources: folder que contém arquivos de configuração para testes unitários.

• pom.xml: é um arquivo conhecido como Project Object Model, que tem a função de conter a estrutura, as dependências e várias outras características de nosso projeto. Como exemplo, para utilizar o conjunto de funcionalidades do JSF, devemos declarar aqui as dependências necessárias para isso. Observe:

Figura 32 - Estrutura do arquivo pom.xml

Observa-se claramente as informações que inserimos em nosso projeto quando iniciamos o seu processo de criação. Também, na área em vermelho, nota-se a declaração de dependências do JSF. O Maven automaticamente fará o download das bibliotecas necessárias, observe:

Figura 33 - Download da biblioteca realizado pelo Maven



Note, na região em preto, que o Maven automaticamente fez o download para a máquina local do arquivo (biblioteca) jsf-impl-2.2.9.jar. Esse processo ocorre para todas as dependências declaradas no projeto.

O objetivo aqui era entender as estruturas de pastas e arquivos presentes para um projeto Java web nos tipos Maven Project (packaging War) e Dynamic Web Project. Não iremos mais aprofundar o assunto.

Nosso próximo objetivo é adicionar e configurar o projeto para ter a capacidade de trabalhar com JSF e isto será visto a seguir.

Configurando o projeto para utilizar JSF

Embora já tenhamos criado o projeto Java com o Maven, o mesmo está apenas configurado de forma estruturalmente correta. Não temos nele ainda nem um recurso que nos possibilite utilizar componentes e funcionalidades do JSF (Java Server Faces), que hoje é a base (especificação) de desenvolvimento para qualquer aplicativo Java para web.

Para configurar a utilização de JSF, deve-se clicar com o botão contrário do mouse sobre o nome do projeto, neste caso livrariaweb. No meu de contexto, você deve clicar sobre a opção Properties para que a seguinte caixa de diálogo seja exposta:

Figura 34 - Caixa de propriedades para o projeto livrariaweb



Clique sobre a opção Project Facets e após selecione a opção JavaServer Faces e aponte para a versão 2.2 do JSF, que será a utilizada neste projeto.

Note que a opção Further configuration avaliable está ativa na área em amarelo na figura. Clique sobre essa opção para que possamos realizar mais algumas configurações.

Figura 35 - Caixa de diálogo Modify Faceted Project

Em JSF, aponte para Disable Library Configuration. Aqui poderíamos adicionar manualmente as bibliotecas do JSF mas, deixaremos essa opção inibida e adicionaremos as dependências diretamente no arquivo pom.xml visto anteriormente.

Observe que na opção JSF Configuration File, existe um apontamento para a pasta WEB-INF, que antes não aparecia na estrutura do projeto web criado com o Maven anteriormente. Está pasta será criada agora e dentro dela será criado o arquivo faces-config.xml, também visto anteriormente.

Em JSF Servlet Name e JSF Servlet Class Name, temos o nome e a classe do Servlet que será o responsável por interpretar nossas páginas JSF. Isso será visto posteriormente e o conteúdo



destas opções será adicionado ao arquivo web.xml, que será criado automaticamente a partir de agora.

Para finalizar, em URL Mapping Patterns, definimos a extensão que deverá ser utilizada em nossas páginas JSF. Em outras palavras, sempre que tivermos uma páginas JSF com este tipo de extensão, a mesma será interpretada pelo Servlet citado anteriormente.

Clique sobre o botão OK e observe que o folder WEB-INF e os arquivos citados anteriormente foram automaticamente criados.

Figura 36 - Folder WEB-INF e arquivos faces-config.xml e web.xml criados

Observe o conteúdo dos arquivos faces-config e web.xml.

Figura 37 - Conteúdo do arquivo faces-config.xml

Figura 38 - Conteúdo do arquivo web.xml



Agora nosso projeto está configurado para utilizar JSF. O próximo passo é adicionar as dependências (bibliotecas - .jars) necessárias. Veremos isso a seguir.

Adicionando dependências do JSF no projeto Java para web

Abra o arquivo pom.xml e adicione as seguintes dependências na seção <dependencies>: <dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-api</artifactId>

<version>2.1.7</version>

</dependency>

<dependency>

<groupId>com.sun.faces</groupId>

<artifactId>jsf-impl</artifactId>

<version>2.1.7</version>

</dependency>

<dependency>

<groupId>org.primefaces</groupId>

<artifactId>primefaces</artifactId>

<version>5.0</version>

</dependency>

As duas primeiras dependências se referem explicitamente as bibliotecas do JSF, em sua versão 2.1.7.

A terceira dependência faz referência ao framework primefaces, que é uma extensão super melhorada do JSF e hoje é um dos frameworks top de mercado para o desenvolvimento Java para web.

Você poderá obter mais informações em http://www.primefaces.org, nas seções de documentação e showcase.

Não é objetivo deste ebook realizar o aprofundamento em JSF e/ou PrimeFaces, mas é importante cita-los aqui, visto que os utilizaremos, de forma super básica, no exemplo de crud que será visto posteriormente.

Essas são as configurações básicas necessárias para implementar a utilização de componentes JSF em nosso projeto. O próximo passo é fazer com que os mundos relacional (banco de dados) e orientado a objetos (Java/classes) se comuniquem.



MÓDULO 3 - Fazendo Com Que o Mundo Orientado a Objetos se Comunique com o Mundo Relacional - Banco de Dados

Download e Instalação do Banco de Dados

Utilizaremos o banco de dados PostgreSQL como repositório de dados de nosso projeto.

O primeiro passo é realizar o download deste banco de dados na seguinte url:

http://www.postgresql.org/download/

Figura 39 - Realizando o download do Banco de Dados Postgres

Salientei na imagem anterior a questão de ser a versão do Postgres para Windows, pois é neste sistema operacional que este projeto está sendo criado. Caso você esteja utilizando outro sistema operacional, terá que clicar no link correspondente a sua versão.

Clique sobre o link para a versão em Windows. Você será remetido para página de instaladores.



Figura 40 - Link de download do Windows Installer do PostgreSQL

Clique sobre o link de Download para que possamos escolher qual versão do Postgres iremos realizar o download para posterior instalação.

Figura 41 - Selecionado a versão do instalador do PostgreSQL conforme o sistema operacional

Como estou utilizando um sistema operacional de 64 bits, realizei o download referente a versão Win x86-64, conforme está salientado em vermelho na figura anterior. Caso você possua um sistema operacional de 32 bits, deverá baixar o instalador referente a versão Win x86-32.

Após o término do processo de download, vá até o instalador e execute-o.



Faça o procedimento de instalação no formato Next to Next, mantendo as configurações conforme sugeridas pelo instalador mas, quando chegar na tela referente a senha do super usuário postgres, defina a seguinte senha para ele: postgres.

Tanto senha, como nome de usuário serão os mesmos mas, você poderá definir outra senha a seu gosto, mas você terá que mudá-la posteriormente em seus códigos java caso faça isso, pois os exemplos vistos de conexão a banco de dados serão com o usuário e senha descritos anteriormente.

Figura 42 - Definindo o password para o usuário Postgres

Clique no botão Next para continuar. Na próxima tela, você terá que definir a porta de acesso. Mantenha o valor indicado (porta 5432) pelo instalador. e clique sobre o botão Next para continuar.



Figura 43 - Definindo a porta de acesso ao banco de dados PostgreSQL

A partir da próxima tela, continue no método Next to Next até que o processo de instalação inicie.

Quando o processo de instalação estiver concluido, você será remetido a seguinte tela:

Figura 44 - Finalizando a instalação do Banco de Dados

Desmarque a opção referente ao Stack Builder e clique sobre o botão Finish.

Neste ponto, concluímos a instalação do banco de dados Postgres em nosso computador. O próximo passo é acessar este banco de dados através de um utilitário vindo no pacote do instalador e criar uma base de dados (database) que será utilizada em nosso projeto.



Criando a base de dados

Para gerenciar as bases de dados do Postgre, foi instalado em nosso computador o utilitário PgAdmin 3. Acesse este utilitário para ter acesso as bases de dados. Observe:

Figura 45 - Executando o utilitário PgAdmin III

Observe que foi instalado a versão 9.4 do Postgre, no servidor localhost (máquina local), na porta 5432. Também note o servidor está com um X vermelho. Isso ocorre pois não estamos logados no banco de dados ainda. Para isso, clique sobre o nome do servidor para que a tela de logon apareça.

Insira a senha postgres, conforme definimos anteriormente e clique sobre o botão OK, para efetuar o processo de logon. Caso tudo esteja correto, o X vermelho sumirá a estrutura de árvores de objetos abaixo do servidor será exposta. Observe:



Figura 46 - Treeview exibindo os databases existentes

O próximo passo é criar o database para ser utilizado em nosso projeto. Para isso, clique com botão contrário do mouse sobre Databases e selecione a opção New Database.

Figura 47 - Criando o database da aplicação

Você será remetido para a caixa de diálogo New Database. Defina o nome do database como livrariawebdb e clique sobre o botão OK para concluir. Não faremos configuração alguma a mais neste database.

Figura 48 - Definindo o nome e criando o database da aplicação

Para finalizar, após a criação do deste database devemos criar uma sequence, que será utilizada por gerar as chaves primárias de cada registro cadastrado na tabela de livros. Para isso, na janela do utilitário pgAdmin III, na barra de ferramentas, clique sobre o botão Execute

arbitrary SQL queries, para que a seguinte caixa de diálogo seja exposta.



Figura 49 - Criando a sequence hibernate_sequence_livros

Digite no editor a seqüência de comandos conforme está descrito na figura acima e clique sobre o botão Execute query. Após, na guia Messages, observe se a mensagem Query returned

successfully foi exibida, mostrando que tudo foi feito de forma correta.

Na treeview Server Groups do utilitário pgAdmin III, você poderá visualizar a sequence criada.

Figura 50 - Visualizando a sequence



Note também, que em Tables, não existe nenhuma tabela criada. Isso será feito posteriormente.

Com relação a instalação de banco de dados e criação de database e sequence o que vimos até aqui é o suficiente. O próximo passo é configurarmos nosso projeto para utilizar JPA, através do framework Hibernate e com isso, poderemos realizar mapeamento objeto-relacional entre tabelas e classes. Veremos isso a seguir.

Adicionando as Dependências do Hibernate e do PostgresSQL

Para adicionar as dependências do Hibernate, devemos ir até a url http://hibernate.org/orm/downloads/, no item Maven Repository e copiar os itens selecionados em vermelho na figura a seguir:

Figura 51 - Maven e a lista de dependencias para a utilização do hibernate

Após copiar tais itens, os mesmos devem ser colados no arquivo pom.xml que, lembrando, é o arquivo utilizado pelo Maven para gerenciar as dependências do projeto.

Para finalizar a adição de dependências ao projeto, vamos agora adicionar as que são referentes ao banco de dados de Postgres. Para isso, vá até a seguinte url: http://mvnrepository.com/artifact/postgresql/postgresql/9.1-901.jdbc4.



Figura 52 - Maven e a lista de dependencias para a utilização do Postgres

Do mesmo jeito que você fez para as dependências do hibernate, copie o que está em amarelo na figura acima e cole-o na área de dependências do arquivo pom.xml. Automaticamente todas as dependências serão baixadas.

Seu arquivo pom.xml e a relação de dependências deverão ficar como na figura a seguir:

Figura 53 - Lista de bibliotecas baixadas pelo Maven



Criando o arquivo hibernate.cfg.xml

Este arquivo é responsável por conter determinadas configurações que são utilizadas para configurar o Hibernate em uma aplicação.

A partir deste ponto devemos começar a organizar nosso projeto em packages, que nada mais são que pastas. Para isso, criaremos um package (folder), com o nome de util, dentro do folder livrariaweb.

Clique com o botão contrário do mouse sobre livrariaweb. No menu de contexto, selecione as opções New, Package. A seguinte caixa de diálogo será exposta:

Figura 54 - Criando o package livrariaweb.util

Em name, o folder livraweb já virá preenchido. Basta que você digite .util e por fim clique sobre o botão Finish para que o novo folder seja criado.

A partir da criação deste folder (util), criaremos o arquivo de configurações para o hibernate citado anteriormente. Então, clique sobre o package livrariaweb.util com o botão contrário do mouse e selecione as opções: New, Other.

Na tela do assistente (wizard), selecione XML File e clique sobre o botão Next.



Figura 55 - Criando um arquivo do topo XML File

Na próxima caixa de diálogo digite hibernate.cfg.xml para o nome do arquivo e após sobre o botão Finish.

Figura 56 - Criando o arquivo hibernate.cfg.xml

O arquivo será criado automaticamente dentro do package livrariaweb.util.

Abra o arquivo, adicione o seguinte conteúdo a ele e após salve-o. <?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC "-

//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>

<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>

<property name="hibernate.connection.url">

jdbc:postgresql://127.0.0.1:5432/livrariawebdb?autoReconnect=true

</property>

<property name="hibernate.connection.username">postgres</property>

<property name="hibernate.connection.password">postgres</property>

<property name="hibernate.show_sql">true</property>

<property name="hibernate.format_sql">true</property>

<property name="connection.pool_size">5</property>



<mapping class="livrariaweb.bean.Livro" />

</session-factory>

</hibernate-configuration>

Note que o conteúdo deste arquivo configura o Hibernate para utilizar o banco de dados Postgres com base em tudo o que fizemos anteriormente.

O próximo passo é criarmos uma classe utilitária, que será utilizada pelo Hibernate, para que ele possa ler as configurações necessárias para se "conectar" com a base de dados.

Essa classe utilitária também será no package livrariaweb.util. Então, selecione o package citado e clique sobre ele com o botão contrário do mouse. Após, selecione as opções New, Class.

Na caixa de diálogo New Java Class, no item name digite HibernateUtil.java, que será o nome da classe. Para finalizar, clique sobre o botão Finish para que a classe seja criada automaticamente.

Abra a classe HibernateUtil.java e adicione a ela o seguinte conteúdo: package livrariaweb.util;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.SessionFactory;

@SuppressWarnings("deprecation")

public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {

try {

sessionFactory = new AnnotationConfiguration().

configure("livrariaweb/util/hibernate.cfg.xml")

.buildSessionFactory();

} catch (Throwable ex) {

throw new ExceptionInInitializerError(ex);

}

}

public static SessionFactory getSessionFactory() {

return sessionFactory;

}

}



Note que nesta classe estamos criando uma sessionFactory, ou seja, ela conterá todas as informações necessárias para posteriormente criarmos uma conexão com a base de dados.

Como estas configurações não estão presentes de forma direta nesta factory, as mesmas foram descritas no arquivo hibernate.cfg.xml, que é lido automaticamente quando esta linha é executada: sessionFactory = new AnnotationConfiguration().

configure("livrariaweb/util/hibernate.cfg.xml")

Se tudo foi feito de forma correta até, sua estrutura de folder e files no Project Explorer, para este package, deve estar desta forma:

Figura 57 - Package livrariaweb.util e seus arquivos

Criando a Classe Livros Para Persitência de Dados

Utilizaremos neste ebook apenas uma classe, que será responsável por representar no mundo orientado a objetos (no Java) a tabela de livros que realmente conterá os dados referentes ao nosso crud de livros.

Não farei grandes relacionamentos ou algo do tipo. O negócio é ter uma classe que represente uma entidade (tabela) de um banco de dados e, a partir disso, possamos realizar operações básicas de crud, como inclusão, exclusão e alteração de registros.

Mas antes de criar a classe Livro, vamos criar outro package com o nome de bean, dentro do folder livrariaweb. Faça isso da mesma forma feita anteriormente para o package

livrariaweb.util.

Depois de criado o package, iremos criar dentro dele a classe Livro. Para isso, clique com o botão contrário do mouse sobre livrariaweb.bean e após clique sobre as opções New, Class. Em name, coloque o nome da classe de Livro e após clique sobre o botão Finish.

A classe será automaticamente aberta do Eclipse e pode ser visualizada na estrutura de arquivos do Project Explorer.

Figura 58 - Classe Livros



O próximo passo é inserirmos os atributos na classe, que nada mais são que a representação dos campos que serão gerados na tabela Livro no banco de dados Postgres.

Esses atributos e a própria classe virão acompanhados de anotações, que nada mais são que informações que identificam e permitem manter a relação entre a classe no java e tabela no banco de dados.

O arquivo da classe Livro já deve estar aberto em seu Eclipse. O mesmo deverá ficar como mostra a figura a seguir:

Figura 59 - Classe Livro e seus atributos

A anotação @Entity indica que esta classe representa uma tabela do banco de dados. Neste caso em especifico, ela representará a tabela Livros.

A outra anotação, @SequenceGenerator indica a sequence que criamos anteriormente e será utilizada para gerar as chaves primárias, para cada registro, inserido na tabela Livros no banco de dados.

As anotações @Id e @GeneratedValue indicam que o atributo idLivro, que representa a coluna id_livro no banco de dados, servirá para representar a chave primária de cada registro /objeto.

Para gerar os gets e sets destes atributos, basta clicar com o botão contrário do mouse na área branca da classe Livro e no menu de contexto, selecionar as opções Source, Generatte Getters

and Setters.

Na caixa de diálogo que aparecerá, basta selecionar todos os itens que são demonstrados na figura a seguir:



Figura 60 - Gerando os getters e setters da classe Livro

Após, clique sobre o botão OK. Todos os getters e setters serão gerados automaticamente.

Para finalizar, vamos geras os métodos hashCode e Equals. Para isso, clique com o botão contrário do mouse e no menu no de contexto, selecione as opções Source, Generate HashCode()

and Equals().



Figura 61 - Gerando hashCode() and equals() classe Livro

Mantenha todas os atributos marcados e clique sobre o botão OK. Os métodos serão gerados automaticamente.

Para finalizar, vamos criar uma classe que será responsável por “testar” o que fizemos até aqui. Antes, devo lembrar, que quando criamos a sequence, também demonstrei que a tabela de Livros não existia no banco de dados. Então, a classe que criaremos agora, executará um método java, que “lerá” as informações presentes no arquivo hibernate.cfg.xml e fará, através de nossa classe, que a tabela Livros seja criada automaticamente, pois em nosso projeto, possuímos a Classe Livro, que está anotada como uma entidade.

Vamos lá. Clique com o botão contrário do mouse sobre Java Resources. Através das opções New, Class, crie uma classe com o nome de GeraTabela.

Preencha a classe com as codificações conforme são exibidas a seguir:



package livrariaweb;

import livrariaweb.bean.Livro;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.tool.hbm2ddl.SchemaExport;

public class GeraTabela {

@SuppressWarnings("deprecation")

public static void main(String[] args) {

AnnotationConfiguration conf = new AnnotationConfiguration()

.configure("util/hibernate.cfg.xml");

conf.addAnnotatedClass(Livro.class);

SchemaExport sE = new SchemaExport(conf);

sE.create(true, true);

System.out.println(" A Tabela " + Livro.class.getName() + " foi

criada.");

}

}

Salve as alterações e agora vamos executar a classe. Para isso, vá até o menu Run, após Run as e por último clique sobre Java Application. Se tudo estiver correto, o processo de execução começara automaticamente e as informações de execução serão exibidas na guia Console, observe:



Figura 62 - Tela de console do Eclipse

Depois que o processo de execução for completado, poderemos ver a tabela criada no banco de dados, observe:

Figura 63 - Exibindo a criação da tabela de Livros no utilitário PgAdmin III

Tanto a tabela, quanto os campos, seguem os nomes definidos em @Table(name=””) e @Colum(name=””).

Uma classe Java deste tipo, também é conhecida entre os desenvolvedores como sendo um bean (POJOS), ou seja, uma classe que possui algumas características próprias, como um construtor vazio, atributos que possuem getters e setters associados a eles, são serializáveis e assim por diante.



Neste ponto, já estamos unido ambos os mundos relacional e orientado a objetos. O próximo é passo é criamos uma interface e uma classe utilitária que serão responsáveis por permitir que os métodos de CRUD de nosso projeto sejam executados. Isso será visto a seguir.

Criando o DAO da aplicação

DAO (Data Access Object), nada mais é que um padrão (design pattern) que tem a função de abstrair operações relativas a banco de dados. É claro, que este pattern é representado no Java por um objeto, que implementa uma interface e, através dela, é que faremos acesso a estes métodos de CRUD.

Vamos criar outro package a partir de livrariaweb com o nome de dao. Faça todo o procedimento para criação de packages visto nos passos anteriores.

Agora, selecione o package livrariaweb.dao com o botão contrário do mouse e no menu de contexto selecione as opções New, Other. Na caixa de dialogo do wizard, selecione a opção interface e clique sobre o botão Next.

Figura 64 - Criando uma Interface

Na próxima tela, em Name digite LivroDao para o nome da interface e clique sobre o botão Finish. O arquivo será criado e aberto automaticamente.

Adicione a ele o seguinte conteúdo:



package livrariaweb.dao;

import java.util.List;

import livrariaweb.bean.Livro;

public interface LivroDao {

public boolean insereLivro(Livro livro);

public boolean alteraLivro(Livro livro);

public boolean excluiLivro(Livro livro);

public Livro consultarLivro(Livro livro);

public List<Livro> listarLivros();

}

Onde:

• insereLivro: insere um livro na tabela;

• alteraLivro: altera dados de um livro pré-cadastrado;

• excluiLivro: exclui um livro cadastrado;

• consultarLivro: busca dados de apenas um livro em especfico;

• listarLivros: traz todos os livros cadastrados.

Agora iremos criar a classe que realizará a implementação destes métodos, visto que a interface apenas garante o processo de assinatura e encapsulamento.

Agora, selecione o package livrariaweb.dao com o botão contrário do mouse e no menu de contexto selecione as opções New, Class. Em Name digite LivroDaoImpl para o nome da classe e clique sobre o botão Finish.

Adicione o seguinte conteúdo a classe:

package livrariaweb.dao; import java.util.List; import livrariaweb.bean.Livro; import livrariaweb.util.HibernateUtil; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction; public class LivroDaoImpl implements LivroDao { private Session session = null; private Transaction transaction = null; public boolean insereLivro(Livro livro) { boolean retorno = false; try { session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction(); System.out.print("DAO - autor: " + livro.getAutor());



session.persist(livro); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; } public boolean alteraLivro(Livro livro) { boolean retorno = false; try { session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction(); session.update(livro); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; } public boolean excluiLivro(Livro livro) { boolean retorno = false; try { session = HibernateUtil.getSessionFactory().openSession(); transaction = session.beginTransaction(); session.delete(session.get(Livro.class, livro.getIdLivro())); transaction.commit(); retorno = true; } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } return retorno; } public Livro consultarLivro(Livro livro) {



Livro l = null; try { session = HibernateUtil.getSessionFactory().openSession(); l = (Livro) session.get(Livro.class, livro.getIdLivro()); } catch (HibernateException e) { e.printStackTrace(); } finally { session.close(); } return l; } public List<Livro> listarLivros() { List<Livro> list = null; try { session = HibernateUtil.getSessionFactory().openSession(); list = session.createQuery("select l from Livro l").list(); } catch (HibernateException e) { e.printStackTrace(); } finally { session.close(); } return list; } }

Onde:

• session = HibernateUtil.getSessionFactory().openSession(): a partir da classe HibernateUtil e do objeto sessionFactory uma sessão com o banco de dados é aberta. Tal sessão é atribuída a variável session.

• session.persist: insere um registro no banco de dados.

• session.update: atualiza um registro no banco de dados.

• session.delete: exclui um registro no banco de dados.

• session.get: obtem um registro no banco de dados.

• session.createQuery: permite definir uma SQL para ser executada no banco dados. Neste caso, traz uma lista de livros.

• transaction = session.beginTransaction(): abre um processo de transação no banco de dados.

• transaction.commit(): comita, persiste as informações enviadas para o banco de dados.

• transaction.rollback(): desfaz tudo caso ocorra algum problema durante o processamento de alguma transação.

Seu package livrariaweb.dao e os arquivos criados anteriormente devem estar na seguinte forma no Project Explorer:



Figura 65 - Package livrariaweb.dao e seus arquivos

Sintetizando, temos nesta classe a implementação de todos os métodos necessários para realizar operações de CRUD no projeto que será criado posteriormente. Maiores conhecidos sobre Hibernate podem ser vistos no site http://hibernate.org/.

Aqui finalizamos este módulo. Instalamos o banco de dados, criamos o database e a sequence, adicionamos as dependências necessárias para trabalhar com Hibernate e Postgres, configuramos o Hibernate, criamos um JavaBean (POJO), testamos as configurações do Hibernate

através de uma classe java que utiliza o Bean criado e por fim criamos a interface e classe de implementação para métodos de CRUD.

O próximo passo é criarmos a aplicação web. Veremos isso no módulo IV.



MÓDULO IV - Criado Uma Aplicação Simples de CRUD com JAVA Web

Managed Beans

Iremos criar agora uma classe conhecida como Managed Bean, que nada mais é que a classe utilizada pelo JSF para relacionar a comunicação entre páginas web (.xhtml) e as implementações de manipulação de dados implementados em nosso DAO.

Em outras palavras, uma página JSF não consegue se comunicar diretamente com o banco de dados e muito menos realizar operações de CRUD nele. Então, essa é a função de uma classe do tipo managed bean, ou seja, agir como um controlador (controller) entre a primeira (páginas

.xhtml) e a segunda camada (DAOs, beans, etc.).

Clique sobre o package livrariaweb e crie outro package com o nome de mb.

Agora, dentro do package livrariaweb.mb crie uma classe java com o nome de LivroMB.java e adicione a ela o seguinte conteúdo.

package livrariaweb.mb; import javax.faces.application.FacesMessage; import javax.faces.context.FacesContext; import javax.faces.model.ListDataModel; import livrariaweb.bean.Livro; import livrariaweb.dao.LivroDao; import livrariaweb.dao.LivroDaoImpl; public class LivroMB { private LivroDao livroDao = new LivroDaoImpl(); private Livro livro; private boolean exibirForm = false; public Livro getLivro() { return livro; } public void setLivro(Livro livro) { this.livro = livro; } public ListDataModel getLivros() { return new ListDataModel(livroDao.listarLivros()); }



public String adicionarLivro() { this.limparLivro(); this.exibirForm(); return null; } public String alterarLivro() { this.exibirForm(); return null; } public String salvarLivro() { if (livro.getIdLivro() == null) { livroDao.insereLivro(livro); } else { livroDao.alteraLivro(livro); } this.mostrarMensagem(livro.getTitulo() + " foi salvo!"); this.ocultarForm(); return null; } public String excluirLivro() { livroDao.excluiLivro(livro); this.mostrarMensagem(livro.getTitulo() + " foi excluido!"); return null; } public String cancelarCadastroLivro() { this.ocultarForm(); return null; } private void limparLivro() { livro = new Livro(); } private void exibirForm() { exibirForm = true; } private void ocultarForm() { exibirForm = false; } private void mostrarMensagem(String mensagem) { FacesContext.getCurrentInstance().addMessage(null,



new FacesMessage(mensagem)); } public boolean isExibirForm() { return exibirForm; } }

Onde:

• private LivroDao livroDao = new LivroDaoImpl(): obtem uma instancia de LivroDaoImpl para acesso aos métodos de manipulação de dados.

• getLivro / setLivro: gets e sets referente ao objeto Livro.

• private boolean exibirForm = false: exibe ou oculta o formulário para cadastro/alteração de dados dos livros.

• getLivros: obtem toda a lista de livros.

• adicionarLivro() / alterarLivro() / salvarLivro() / excluirLivro : respectivamente, adiciona, altera dados, salva informações e exclui um livro da base de dados.

• cancelarCadastroLivro(): cancela o cadastro/alteração de um livro.

• limparLivro(): cria uma nova instancia do bean Livro.

• exibirForm() / ocultarForm(): exibe/oculta a visualização do formulário de cadastro e alteração de dados.

• mostrarMensagem(): mostra as mensagens da aplicação.

Seu package livrariaweb.mb e o arquivo criado anteriormente devem estar na seguinte forma no Project Explorer:

Figura 66 - Package livrariaweb.mb e sua classe

Arquivos de Configuração faces-config.xml e web.xml

Agora precisamos registrar essa para que o JSF entenda que a mesma é um managed bean. Para isso, abra o arquivo faces-config.xml, localizado no path conforme demonstra a figura a seguir:

Figura 67 - Arquivos de configuração da aplicação



Para finalizar, adicione o seguinte conteúdo a ele:

<?xml version="1.0" encoding="UTF-8"?>

<faces-config

xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee

http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd"

version="2.2">

<managed-bean>

<managed-bean-name>LivroMB</managed-bean-name>

<managed-bean-class>livrariaweb.mb.LivroMB</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>

</faces-config>

Onde:

• LivroMB: é o apelido (alias) que utilizaremos nos formulários JSF.

• livrariaweb.mb.LivroMB: indica o package (livrariaweb.mb) e por fim a classe LivroMB

• session: é o escopo do bean.

Aproveitando que estamos no folder WEB-INF, abra o arquivo web.xml e acrescente a ele o conteúdo a seguir, sem retirar as demais configurações já pré-estabelecidas anteriormente:

<welcome-file-list>

<welcome-file>index.html</welcome-file>

</welcome-file-list>

Páginas web do projeto

Nossa aplicação web terá uma página html com o nome de index.html. Ela fará o redirecionamento da aplicação para outra página que criaremos posteriormente.

Clique no folder webapp e, com o botão contrário do mouse selecione as opções New,

Other.

Na caixa de diálogo, escolha a opção HTML File e clique sobre o botão Next e, para finalizar, em Name digite index.html e após clique sobre o botão Finish.

Na página index.html, adicione o seguinte conteúdo:

<!DOCTYPE html>

<html>

<head>

<meta charset="ISO-8859-1">



<META HTTP-EQUIV="Refresh" CONTENT="0,URL=listagem.xhtml">

</head>

<body></body>

</html>

Aqui apenas cabe salientar a seguinte linha: <META HTTP-EQUIV="Refresh" CONTENT="0,URL=listagem.xhtml">. Essa linha é responsável por redirecionar a aplicação para a página listagem.xhtml que nada mais é que uma página JSF que exibirá todos os livros cadastrados na base de dados, bem como permitir a manipulação destes dados.

Clique novamente no folder webapp e, com o botão contrário do mouse selecione as opções New, Other e crie outra página do tipo HTML File com o nome de listagem.xhtml.

Adicione a ela as linhas abaixo:

<html xmlns="http://www.w3.org/1999/xhtml"

xmlns:h="http://java.sun.com/jsf/html"

xmlns:f="http://java.sun.com/jsf/core"

xmlns:p="http://primefaces.org/ui">

<h:head>

</h:head>

<title>CRUD com Hibernate e JSF usando Eclipse e Banco de Dados

PostGres</title>

<h:body>

<f:view>

<div align="center">

<h:form id="form">

<h:messages />

<p:dataTable var="item" value="#{LivroMB.livros}" border="1"

cellpadding="1" cellspacing="1"

rendered="#{LivroMB.livros.rowCount > 0}">

<f:facet name="header">

<p:outputLabel value="Relação de Livros Cadastrados" />

</f:facet>

<p:column>


<h:outputText value="Titulo" />

</f:facet>

<h:outputText value="#{item.titulo}" />

</p:column>

<p:column>


<h:outputText value="Editora" />

</f:facet>

<h:outputText value="#{item.editora}" />

</p:column>

<p:column>


<h:outputText value="Autor" />

</f:facet>

<h:outputText value="#{item.autor}" />

</p:column>

<p:column rendered="#{!LivroMB.exibirForm}">


<h:outputText value="Opções" />

</f:facet>

<h:commandLink action="#{LivroMB.alterarLivro}">

<h:outputText value="Alterar" />

<f:setPropertyActionListener value="#{item}"

target="#{LivroMB.livro}" />

</h:commandLink>

<h:commandLink action="#{LivroMB.excluirLivro}">

<h:outputText value="Excluir" />

<f:setPropertyActionListener value="#{item}"

target="#{LivroMB.livro}" />

</h:commandLink>

</p:column>

<f:facet name="footer">

<h:outputText value="Quantidade de livros cadastrados:

#{LivroMB.livros.rowCount}" />

</f:facet>

</p:dataTable>

<h:commandLink action="#{LivroMB.adicionarLivro}" value="Novo livro"

rendered="#{!LivroMB.exibirForm}" />



<p:panelGrid border="1" columns="2" rendered="#{LivroMB.exibirForm}">


<h:outputText value="Cadastro de livro" />

</f:facet>

<p:outputLabel for="nome" value="Titulo: " />

<p:inputText id="nome" value="#{LivroMB.livro.titulo}"

required="true" />

<p:outputLabel for="email" value="Editora: " />

<p:inputText id="email" value="#{LivroMB.livro.editora}"

required="true" />

<p:outputLabel for="autor" value="Autor: " />

<p:inputText id="autor" value="#{LivroMB.livro.autor}"

required="true" redisplay="true" />

<f:facet name="footer">

<h:panelGroup>

<h:commandButton value="Salvar"

action="#{LivroMB.salvarLivro}" />

<h:commandButton value="Cancelar"

action="#{LivroMB.cancelarCadastroLivro}"

immediate="true" />

</h:panelGroup>

</f:facet>

</p:panelGrid>

</h:form>

</div>

</f:view>

</h:body>

</html>

Aqui temos um formulário JSF estritamente SIMPLES mas, com uma manipulação de dados (CRUD) totalmente funcional.

O primeiro "link" é um botão do tipo commandLink padrão do JSF que tem a função de cadastrar um novo livro. É óbvio que não temos livro algum cadastrado na base de dados, logo apenas esse link "Novo livro" será visualizado se executarmos a aplicação.



O datatable utilizado é um componente da suite Primefaces. Esse tipo de componente é responsável tanto no JSF, como qualquer outro framework web para java, de servir como um conteiner para exibição de coleções, listas. Neste caso em especifico, escolhi utilizar o do PrimeFaces, pois os componentes desta suite já vem com um arquivo .css pré-configurado. Logo, visualmente, causa um efeito muito melhor que simplemesmente visualizarmos uma tabela "crua" no navegador. Observe:

Com componente nativo do JSF:

Figura 68 - Relação de Livros com datatable JSF puro

Com componente nativo do Primefaces:

Figura 69 - Relação de Livros com datatable do PrimeFaces

Para a tela de manutenção e inclusão de livros, utilizei um componente do tipo panelGrid

do Primefaces. Observe:



Figura 70 - Tela de cadastro e manutenção de livros

É claro que se pode aplicar um arquivo de folhas de estilo (.css) em componentes nativos do JSF, mas não é o objetivo aqui. Isso é apenas para demonstrar as vantagens em se utilizar frameworks de mercado, como o Primefaces, dando assim uma "turbinada" nos componentes base do JSF, tanto em layout, como em outros recursos, como por exemplo a utilização de Ajax.

Bem até aqui criamos o projeto web, mas não o executamos até agora. As telas exibidas anteriormente servem apenas para demonstrar como nossa aplicação ficará.

Instalando o Tomcat e Executando a Aplicação

Vamos agora realizar o dowload e instalação do Tomcat 7. Para isso, utilize a seguinte url:

http://tomcat.apache.org/download-70.cgi.

Faça o download em Binary Distributions, no item Core, do arquivo .zip.



Figura 71 - Site para download do Tomcat 7

De preferência salve o arquivo em uma pasta aonde você tenha permissões de leitura e escrita, visto que estamos utilizando o Windows e, em alguns casos, pode ocorrer problemas de permissão com o utilitário UAC. Feito o download, descompacte o arquivo .zip e volte para o Eclipse.

Agora vá até Guia Servers e clique com o botão contrário do mouse abra o menu de contexto. Após, selecione New, Server.

Figura 72 - Criando um novo servidor no Eclipse

Na próxima caixa de diálogo, na treeview selecione Apache e após Tomcat v7.0 Server.



Em Server's host name e Server name mantenha os nomes conforme a sugestão do wizard.

Em Server runtime environment, clique sobre o botão Add e em Tomcat installation

directory e aponte para pasta aonde o Tomcat foi descompactado.

Figura 73 - Registrando o servidor Tomcat



Vá clicando sobre os botões Finish até criar o servidor.

Com o servidor criado, devemos agora adicionar nossa aplicação a ele. Para isso, clique com botão contrario do mouse sobre o servidor criado na guia Servers. Após, selecione a opção Add and Remove.

Na próxima caixa de diálogo, selecione o projeto livrariaweb e clique no botão Add e após Finish.

Figura 74-Apontando para a pasta de instalação do Tomcat

Figura 75-Adicionando o aplicativo web no servidor Tomcat



A aplicação é automaticamente adicionada no servidor Tomcat criado e agora poderá ser executada.

Faça o start do servidor como mostra a figura a seguir:

O servidor foi starteado. Observe:

Para finalizar, o próximo passo agora é abrir o browser e executar nossa aplicação com a seguinte url:

Figura 76-Apontando para a aplicação livrariaweb

Figura 77-Aplicação adicionada no servidor

Figura 78-Start do servidor

Figura 79-Tomcat inicializado



http://localhost:8080/livrariaweb/

Caso exista algum registro na tabela, a listagem de livros será exposta. Caso contrário, apenas o link para cadastrar um novo livro será exibido.

CONCLUINDO

Se avaliarmos o que estudamos neste ebook, veremos que partimos do básico, desde a instalação do Java em nosso computador, até o ponto de criarmos uma aplicação java para web.

Deixo aqui o desafio para se tornar um expert em Java e fazer com que o conteúdo desde ebook e de muito livros de mercado se tornem obsoletos para o conhecimento que você irá adquirir na sua vida sendo um desenvolvedor Java. Afinal, estamos nessa vida para crescer, adquirindo conhecimento e, com isso, realizando grandes conquistas.

Fique com Deus e conte comigo, Jean Vargas, para o seu crescimento pessoal e intelectual e não esqueça de acessar o meu blog, http://profissionaisjava.com, onde dou várias dicas, tanto para iniciantes, como profissionais na área de TI, sobre Java e tecnologias que rodeiam está fantástica linguagem de programação.

Figura 80-Aplicação em execução no browser

Criando um Aplicativo para a web com Java EE...

Documents

Transcript of Criando um Aplicativo para a web com Java EE...