Untitled - Profissionais Java

Transcrição

Criando um Aplicativo para a web com Java EE 7
Criando um Aplicativo para a
web com Java EE 7
http://profissionaisjava.com
Autor: Jean Robson Batista de Vargas - http://profissionaisjava.com
2
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
3
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-downloads1880260.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.
5
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.
6
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
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
8
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.
9
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:
1
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:
1
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
1
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
1
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.
1
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
1
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.
1
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.
1
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.
1
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.
1
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.
2
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.
2
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.
2
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.
2
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.
2
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.
2
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.
Figura 29 - Janela Open Perspective
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.
2
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.
2
•
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.
2
•
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
2
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
3
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
3
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
3
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.
3
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.
3
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.
3
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.
3
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.
3
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:
3
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.
3
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
4
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.
4
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
4
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.
4
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
4
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;
}
}
4
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
4
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:
4
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().
4
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:
4
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:
5
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.
5
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:
5
package livrariaweb.dao;
import java.util.List;
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.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());
5
session.persist(livro);
transaction.commit();
retorno = true;
} catch (HibernateException e) {
transaction.rollback();
e.printStackTrace();
} finally {
session.close();
}
return retorno;
}
public boolean alteraLivro(Livro livro) {
try {
session.update(livro);
retorno = true;
} finally {
session.close();
}
return retorno;
}
public boolean excluiLivro(Livro livro) {
try {
session.delete(session.get(Livro.class, livro.getIdLivro()));
retorno = true;
} finally {
session.close();
}
return retorno;
}
public Livro consultarLivro(Livro livro) {
5
Livro l = null;
try {
l = (Livro) session.get(Livro.class, livro.getIdLivro());
} finally {
session.close();
}
return l;
}
public List<Livro> listarLivros() {
List<Livro> list = null;
try {
list = session.createQuery("select l from Livro l").list();
} 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:
5
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.
5
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.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());
}
5
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,
5
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
5
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">
6
<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}">
6
<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.
6
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:
6
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.
6
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.
6
Em Server's host name e Server name mantenha os nomes conforme a sugestão do wizard.
Figura 73 - Registrando o servidor Tomcat
Em Server runtime environment, clique sobre o botão Add e em Tomcat installation
directory e aponte para pasta aonde o Tomcat foi descompactado.
6
Figura 74-Apontando para a pasta de instalação do 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.
Figura 75-Adicionando o aplicativo web no servidor Tomcat
Na próxima caixa de diálogo, selecione o projeto livrariaweb e clique no botão Add e após
Finish.
6
Figura 76-Apontando para a aplicação livrariaweb
A aplicação é automaticamente adicionada no servidor Tomcat criado e agora poderá ser
executada.
Figura 77-Aplicação adicionada no servidor
Faça o start do servidor como mostra a figura a seguir:
Figura 78-Start do servidor
O servidor foi starteado. Observe:
Figura 79-Tomcat inicializado
Para finalizar, o próximo passo agora é abrir o browser e executar nossa aplicação com a
seguinte url:
6
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.
Figura 80-Aplicação em execução no browser
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.
6

Untitled - Profissionais Java

Transcrição

Documentos relacionados

Houve um problema com o certificado digital do nosso

Windows xp Instalação do driver de biometria disponível na página

Núcleo Desenvolvimento

Tiago Faustino

Clique aqui para acessar o manual de como preparar o Mozilla

Guia de Instalação

Contato com a imprensa: Capital Informação

Introdução à Java - Professor Baesse

Currículo Completo Versão PDF - Wiliam Machado Executivo de TI

Acesso da Webrádio pelo TUNEIN