tutorial java web com jsf 2

5/24/2018 Tutorial Java Web Com Jsf 2

1/78

Tutorial JAVA Web com JSF2.0, Facelts, Hibernate 3.5

com JPA 2.0, Spring 3.0 e

PrimeFaces 2.2.1

Autor: Diego Carlos Rezende

Graduando em Sistemas de Informao

Universidade Estadual de Gois - UEG UnUCET

Anpolis

Outubro, 2011


2/78

Sumrio

Figuras ............................................................................................ 2Tabelas ........................................................................................... 3Apresentao ................................................................................... 5Configurao do Banco de Dados ......................................................... 6Configurando o TomCat ...................................................................... 7Criando o projeto ............................................................................ 10Configurando o projeto .................................................................... 14Estruturando o projeto... .................................................................. 18Programando - Modelo e suas dependncias ........................................ 20Programando - Persistncia .............................................................. 29Programando - Conectando com o Banco de dados ............................... 33Configurando o Spring ..................................................................... 35Programando - Fbrica de Beans ....................................................... 39Programando - Criando nossos controladores....................................... 41Programando - Controlando a viso.................................................... 49Programando - Internacionalizao por Bundle ..................................... 53Programando - Gerenciando a viso ................................................... 57Programando - Criando nosso layout .................................................. 63Programando - Facelets e template .................................................... 65Programando - Criando as pginas ..................................................... 68Rodando a aplicao ........................................................................ 74Exerccio ........................................................................................ 76Agradecimentos .............................................................................. 77


3/78

Figuras

Figura 01 - New Others ...................................................................... 7Figura 02 - Criando Server ................................................................. 7Figura 03 - Selecionando Server .......................................................... 8Figura 04 - Escolha do diretrio do TomCat ........................................... 8Figura 05 - Configurao do Server Location .......................................... 9Figura 06 - Criando um Dynamic Web Project ...................................... 10Figura 07 - Configurao do projeto ................................................... 11Figura 08 - Gerar web.xml ................................................................ 12Figura 09 - Configurao do JSF no web.xml........................................ 13Figura 10 - Bibliotecas ..................................................................... 14Figura 11 - Package ......................................................................... 18Figura 12 - Pacotes do projeto........................................................... 18Figura 13 - New>Annotation ............................................................. 20Figura 14 - New>Class ..................................................................... 22Figura 15 - New>Interface ............................................................... 29Figura 16 - New>CSS File ................................................................. 63Figura 17 - New>HTML File ............................................................... 65Figura 18 - Add and Remove... .......................................................... 74Figura 19 - PickList de projetos ......................................................... 74


4/78

Tabelas

Tabela 01 - Criando banco de dados ..................................................... 6Tabela 02 - Criando tabelas ................................................................ 6Tabela 03 - web.xml ........................................................................ 15Tabela 04 - index.html ..................................................................... 17Tabela 05 - RequiredField.java .......................................................... 21Tabela 06 - Entity.java ..................................................................... 23Tabela 07 - Reino.java ..................................................................... 25Tabela 08 - Filo.java ........................................................................ 28Tabela 09 - IGenericDAO.java ........................................................... 29Tabela 10 - GenericDAO.java ............................................................ 31Tabela 11 - Connect.java.................................................................. 33Tabela 12 - jdbc.properties ............................................................... 34Tabela 13 - spring.xml ..................................................................... 36Tabela 14 - SpringFactory.java .......................................................... 39Tabela 15 - ValidatorControl.java ....................................................... 42Tabela 16 - For each em modo rtulo ................................................. 44Tabela 17 - MessagesControl.java ...................................................... 45Tabela 18 - IControl.java .................................................................. 46Tabela 19 - Control.java ................................................................... 47Tabela 20 - MessagesWeb.java .......................................................... 49Tabela 21 - Converter.java ............................................................... 51Tabela 22 - messages_pt_BR.properties ............................................. 53Tabela 23 - messages_en_US.properties ............................................. 54Tabela 24 - faces-config.xml ............................................................. 55Tabela 25 - MB.java ........................................................................ 58Tabela 26 - ReinoMB.java ................................................................. 60Tabela 27 - FiloMB.java .................................................................... 62


5/78

Tabela 28 - template.css .................................................................. 64Tabela 29 - template.xhtml ............................................................... 66Tabela 30 - CadReino.xhtml .............................................................. 69Tabela 31 - CadFilo.xhtml ................................................................. 71


6/78

Tutorial JSF, Facelets, Hibernate com JPA, Spring e PrimeFaces - 5

Apresentao

Com este tutorial pretendo explicar o funcionamento de um CRUD bsicopara cadastro de Reino e Filo com apenas o nome dos mesmos em um

programa para a Web envolvendo o JSF 2.0 para a camada de viso,

Facelets para organizao dos templates e das pginas, Hibernate para a

camada de persistncia juntamente com o JPA, Spring para a camada de

controle (injeo de dependncias) e o PrimeFaces como interface rica para

a camada de viso. Contm tambm um validador usando o Java Reflection.

Para explicao de Spring e um pouco do Hibernate usarei tutoriais deoutros autores que julgo muito bons, sendo que citarei quando necessrio e

onde dever ser feito a leitura dos mesmos.

Na construo da aplicao, alm dos frameworks citadas acima, tambm

foram usadas as seguintes tecnologias:EclipseHelios para a IDE (Helios ou

Indigo) para desenvolvimento Java EE; Apache Tomcat 7 como servidor;

SQL Server 2005 como banco de dados.

O intuito deste tutorial a disseminao do conhecimento, apenas peopara manter os crditos dos autores, tantos deste tutorial, como dos citados

aqui tambm.

Para um melhor aproveitamento, tente no copiar o cdigo, use as

ajudas do Eclipse, as dicas contidas no tutorial e o perfeito CTRL + espao

que a IDE nos fornece. Nos arquivos XML aconselho o CTRL + C, CTRL + V

mesmo.

A explicao do Spring e Hibernate encontra-se no blog do Felipe Saab,que explica muito bem sobre os dois, e para a compreenso deste tutorial

faz-se necessrio a leitura do artigo dele,de Spring Hibernate (parte 1 ao

4), tambm necessrio o conhecimento do bsico de Java.
http://www.eclipse.org/downloads/http://www.eclipse.org/downloads/http://www.eclipse.org/downloads/http://tomcat.apache.org/download-70.cgihttp://tomcat.apache.org/download-70.cgihttp://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://tomcat.apache.org/download-70.cgihttp://www.eclipse.org/downloads/


7/78


Configurao do Banco de Dados

No seu SQL Server j instalado, abra-o e crie a database para o sistema:01. CREATE DATABASEportal_virtual;

Tabela 01 - Criando banco de dados

Agora hora de criar a tabelas onde iremos salvar os dados:

01. USEportal_virtual;02.03. CREATE TABLEreino (04. id_reinoINT IDENTITY NOT NULL,

05. nomeVARCHAR(50)NOT NULL,06. PRIMARY KEY (id_reino)07. )08.09. CREATE TABLEfilo (10. id_filoINT IDENTITY NOT NULL,11. nomeVARCHAR(50)NOT NULL,12. id_reinoINTNOT NULL,13. PRIMARY KEY (id_filo),14. FOREIGN KEY (id_reino) REFERENCESreino(id_reino)

15. );Tabela 02 - Criando tabelas

Pronto, basta apenas criar o Usurio de acesso. No projeto defini o

usurio para o banco de dados portal_virtual com o login: ueg e senha:

portueg; voc pode, ento, criar o mesmo usurio com login e senha no seu

SQL Server, ou mudar o usurio e a senha do software no arquivo

properties do JDBC para o usurio do seu banco de dados, explicarei como

fazer essa ultima parte mais adiante.

Banco de dados criado, vamos para o JAVA.


8/78


Configurando o TomCat

Baixe o Eclipse no site citado na Apresentao e o descompacte ondedesejar, depois baixe o Apache TomCat em zip ou instalador, descompacte-

o em uma pasta a sua escolha. Para abrir o Eclipse necessrio ter o Java

JDK instalado e configurado as variveis de ambientes.

Vamos criar o Server para rodar a aplicao WEB: no Eclipse, clique com

o boto direito e v em: New>Other...e procure por Server, depois clique

em Next:

Figura 01 - New Others

Figura 02 - Criando Server


9/78


Na prxima aba selecione o Apache/Tomcat v7.0 Server:

Figura 03 - Selecionando Server

Clique em Next e o Wizard pedir a pasta onde o TomCat foi

instalado: Clique em Browse... e selecione a pasta onde descompactou oarquivo:

Figura 04 - Escolha do diretrio do TomCat


10/78


Cliquem em Finish e agora voc tem seu servidor de aplicao para

rodar seu projeto localmente. Vamos definir ento onde ficar os arquivos

temporrios do projeto para teste: Na aba de Server clique duas vezes no

seu novo Servidor - Tomcat v7.0 Server at localhost - e em Server

Locations clique na segunda opo - Use tomcat installation - salve e

feche a aba:

Figura 05 - Configurao do Server Location

Seu Tomcat j est funcionando, se quiser test-lo, de Start (boto

Play um pouco acima do nome do Tomcat v7.0 da figura) e tente abrir a

pgina localhost:8080, se abrir uma pgina do Tomcat, est tudo ok.


11/78


Criando o projeto

Em seu Eclipse com o Tomcat rodando, crie seu projeto web: botodireito > New > Other... (Figura 01) e procure por Dynamic Web Project:

Figura 06 - Criando um Dynamic Web Project

Clique em Next e ser pedido o nome do projeto e algumas

informaes da configurao do mesmo. Usaremos o Wizard do Eclipse

para nos ajudar a fornecer algumas coisas prontas, ento para isso, digite o

nome projeto e selecione em Configuration a opo JavaServer Faces

v2.0 Project, seno aparecer a opo verifique a verso do mdulo se estem 3.0. Com essa simples mudana o Eclipse criar o arquivo faces-

config.xml automaticamente que necessrio para fazer algumas

configuraes do JSF. S para informao, na verso do JSF 1.2 e

anteriores, todas as configuraes eram feitas nesse arquivo XML, a partir

da verso 2.0 comeou-se a usar annotation, no sendo necessrio mais o

uso do faces-config, entretando, ainda tem uma configurao que no

conseguir encontrar a annotation da mesma, o que me fora a usar este

arquivo ainda.


12/78


Figura 07 - Configurao do projeto

Defini o nome do meu projeto como portal-virtual e essa ser a forma a

qual irei me referir durante todo o tutorial, para comandos de acesso e

configuraes de pacotes e arquivos mude para o nome que voc escolheu,

caso no seja o mesmo.

Clique em Next, na prxima aba ser perguntando onde ser salvo os

arquivos Java e onde ser salvo o .class no Tomcat, simplesmente

mantenha a configurao clicando em Next. Na outra aba serperguntando a pasta de deploy, onde ficar todas as pginas webs, pastas


13/78


criadas e .class para rodar a aplicao. Nesta parte tambm mantenha as

configuraes (mudanas no Context root ir mudar a forma de acessar a

pgina web), apenas pea para o Wizard geraro deployment do web.xml

automaticamente, assim o Eclipse ir gerar a lista de arquivos para

inicializao sozinho:

Figura 08 - Gerar web.xml

V para a prxima aba clicando em Next. Nesta parte o Wizard te

ajuda a configurar o JSF 2.0 j que selecionou que existir o framework,

para isso ele pede as bibliotecas do JavaServer Faces e como ser feito o

acesso e chamada da servlet. Voc pode escolher baixar as bibliotecas do

JSF pelo Eclipse ou que o Wizard no configure esta etapa, para istoselecione: Disable Library Configuration.

Como as bibliotecas se encontram no CODE desabilite a opo de

configurao da biblioteca. Logo abaixo tem a configurao de mapeamento

da servlet do JSF, por padro o acesso a qualquer pgina JSF vem

configurado, pelo Eclipse, como /faces/*.

Vamos com um pouco de explicaes... JSF uma tecnologia para a

construo da interface do usurio, no passa de uma servlet de viso, quetraz HTML e um pouco de JSP embutidos, o que voc faria em algumas

linhas de cdigo tendo que saber todas as tecnologias citadas, voc faz em

uma no JSF. Mas para uma pgina contendo o cdigo do framework

funcionar, voc deve adicionar a biblioteca do JSF para o projeto e dizer

para o servidor que a pgina precisa passar pela servlet do JSF para uma

renderizao, ou seja, ela ter que ser reescrita de forma que o

navegador a reconhea (voltar as vrias linhas de HTML). E como fazerisso?
http://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibshttp://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibshttp://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibs


14/78


Figura 09 - Configurao do JSF no web.xml

Essa configurao da imagem fica no web.xml, mas o Eclipse nos ajuda,

antes mesmo de criar o projeto, a faz-la. Como informei acima,

precisarmos de uma forma para avisar que uma pgina usa o JSF, e isso

feita na hora de abrir a pgina pela URL, a configurao que eu fiz diz que

toda vez que eu digitar uma pgina na URL e ela terminar com .jsf, essa

pgina deve passar pela servlet do JSF e renderiz-la. Exemplo, se tenhouma pgina na aplicao que o nome dela HelloWorld.xhtml, mas para

acessar ela digito: www.testejava.com.br/HelloWorld.jsf, e no web.xml tem

a configurao citada, o servidor sabe que a pgina contm JSF e ir abri-la

de forma a reconhecer todas linhas contidas no cdigo. Se no entender

bem o que foi dito agora, mais pra frente isso ficar mais claro.

Clique em Finish e teremos nosso projeto criado (Caso abra uma

mensagem pedindo para muda de perspectiva para JAVA Web, clique emYes). Vamos agora adicionar as bibliotecas para o projeto funcionar.


15/78


Configurando o projeto

Em seu projeto, v em WebContent/WEB-INF/lib, copie e cole todos .jarque se encontrar na pasta libs doCODE,h

uma diviso de pasta nos sites, copie todas

as bibliotecas de todas as pasta para a

pasta /lib do seu projeto sem criar nova

pasta. Ficar mais ou menos assim:

Conforme figura ao lado tambm, crie as

pastas css, images, pages etemplate dentro do diretrio /WebContent

(para isso clique com boto direito, New-

>Folder ou New->Other...->Folder).

Bibliotecas criadas, vamos habilitar os

frameworks e visualizar no que o Eclipse j

nos ajudou. Dentro do diretrio /WEB-INF

temos o arquivo web.xml, abra-o. Se for a

primeira vez que abre um arquivo XML, ele

deve abrir no modo Design, clique no modo

Source para visualizar o cdigo-fonte (fica

acima da barra de

Markers/Servers/Console, bem no rodap

do web.xml aberto no Eclipse). Segue

abaixo como o web.xml deve ficar, logo

depois explico o cdigo:

Figura 10 - Bibliotecas

portal-virtual

index.html
http://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibshttp://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibshttp://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibshttp://code.google.com/p/portal-virtual/source/browse/#svn%2FTutorial%2Flibs


16/78


Faces Servletjavax.faces.webapp.FacesServlet 1

Faces Servlet*.jsf

Resource Servletorg.primefaces.resource.ResourceServlet

Resource Servlet/primefaces_resource/*

primefaces.THEMEredmond

Tabela 03 - web.xml

Arquivos XML se iniciam com a tag para a definio da versodo xml e o tipo de codificao (UTF-8), depois vem a tag falando que aquilo

um arquivo do tipo web.xml , esse arquivo, principalmente o

que j citei, mais CTRL C + CTRL V, no h necessidade de decorar isso,

apenas entender como funciona.

O display-name apenas o nome do projeto, no faz interferncia na

aplicao. O wellcome-file-list (gerado porque foi marcado a opo generate

deployment citado na criao do projeto) outro elemento opcional,

inicialmente ele vem uma lista de index.algumaExtenso, que ir buscar no

/WebContext os arquivos em ordem de listagem e tentar execut-los

quando voc tentar acessar o site, exemplificando: o projeto executar

localmente, ento para acessar ele voc digita no browser:

localhost:8080/portal-virtual, tendo o arquivo do wellcome-file-list no

/WebContext o browser tentar abrir a pgina, no tendo nenhum da lista

citado, dar erro dizendo que no existe a aplicao, mesmo que tenha um

arquivo (por exemplo, teste.xhtml) dentro da pasta, ele no ser aberto seno foi citado na lista de entrada, para abrir a pgina citada no estando no


17/78


wellcome-file-list ter que ser feita do seguinte modo:

localhost:8080/portal-virtual/teste.xhtml. Nesse wellcome-file-list ainda h

um detalhe, no se pode usar nenhuma pgina que necessite de biblioteca

para abrir, aceita apenas extenses XHTML, HTML, JSP, ou seja, voc no

pode colocar uma pgina .jsf como inicializao do projeto, j que

necessrio usar bibliotecas para exibir a pgina, logo explico como

solucionar o problema. Coloquei, na lista de inicializao, o arquivo

index.html, pois tenho ele na pasta /WebContent que a pgina inicial do

projeto.

O comando servlet serve para definir as servlets existentes no projeto,

dentro dela temos que definir, obrigatoriamente, seu nome e a classe ondedeve ser buscada para execuo da mesma. A primeira que temos a Faces

Servlet, sua classe de compilao fica na biblioteca do JSF que adicionamos

ao projeto no caminho citado na tabela. Logo depois vem o mapeamento da

servlet, ou seja, onde iremos us-la, primeiro dizemos qual a servlet que

queremos mapear, no nosso caso a Faces Servlet que acabamos de criar, e

depois dizemos a url que ela deve ser chamada, no caso *.jsf. Volto na

explicao que disse acima sobre JSF, quando voc pedir no browser

alguma pgina da aplicao e voc diz que sua extenso .jsf a pgina ir

passar pela classe javax.faces.webapp.FacesServlet e ir renderizar o que

aparecer para o usurio, exemplificando: tenho um arquivo chamado

teste.xhtml, dentro dele tenho comandos do JSF, quando eu tentar acess-

la, se apenas dizer que ela uma pgina simples: localhost:8080/portal-

virtual/teste.xhtml, provavelmente ir abrir uma pgina aparecendo apenas

os comandos HTML utilizados e o resto em branco, ou dar um erro, j se

for dito na URL que tem que passar pela servlet do JSF:

localhost:8080/portal-virtual/teste.jsf, mesmo que no exista esse arquivo

.jsf, a aplicao sabe (j que foi mapeado) que isso um comando para

chamar a Faces Servlet, e ir procurar alguma pgina com nome de teste

(independente se .html, .xhtml) e far sua execuo pela servlet, assim

ir exibir a pgina com todos comandos sem problemas.

A prxima servlet a interface rica do Primefaces, dizemos onde sua

classe, definimos seu nome, no mapeamento dizemos onde pegar osrecursos, e depois definimos o parmetro do tema do mesmo (verifique que


18/78


h a biblioteca do tema no diretrio /lib), a servlet no um recurso

acessvel por URL como o JSF.

Com esse arquivo web.xml a aplicao ir funcionar com JSF e

Primefaces. O Spring pode ser inicializado com o projeto criando sua servlet

no web.xml, mas fiz uma pesquisa no Google sobre o framework e apareceu

muito pouco o uso desta prtica. Nesse exemplo fiz uma inicializao

diferente que dar para entender bem o Spring, a forma dele ser

inicializado ser apenas um detalhe que no far diferena para o

aprendizado. Se quiser verificar, nesse siteh um uso do Spring inicializado

pelo web.xml.

Vamos criar a pgina de inicializao do projeto, o index.html citado no

wellcome-file-list:

Tabela 04 - index.html

A pgina contm apenas um cabealho mandando recarregar a pgina e

ir para a URL template/template.jsf, com isso resolvemos o problema do

wellcome-file-list no poder abrir uma pgina JSF direto. Somente com esse

cabealho, ao tentar acessar localhost:8080/portal-virtual, o browser far o

redirecionamento para localhost:8080/portal-virtual/template/template.jsf,

como a pgina no existe, dar erro. Vamos agora para os cdigos JAVA.
http://www.javaframework.org/portal/2010/03/14/hello-world-com-spring-3-para-um-projeto-web/http://www.javaframework.org/portal/2010/03/14/hello-world-com-spring-3-para-um-projeto-web/http://www.javaframework.org/portal/2010/03/14/hello-world-com-spring-3-para-um-projeto-web/


19/78


Estruturando o projeto...

Vamos criar os pacotes inicialmente e explicarei como ser dividida anossa arquitetura, clique com o boto direito sobre o nome do projeto,

New->Package ou New->Other->Package.

Figura 11 - Package

Em web, se padroniza que os nomes dos pacotes devem vir com o site ao

contrrio e depois o nome do pacote desejado, exemplo, quero criar opacote Teste para meu website www.tutoriais.com.br, ento meu pacote

ficara: br.com.tutoriais.teste, ou se usa o nome do projeto, usando o

mesmo exemplo: no meu site tutoriais tenho o projeto artigos, ento meu

pacote pode ser tambm: br.com.artigos.teste.

Vamos criar os seguintes pacotes: annotation, bundle, control, model,

persistence, sets, e view. Dentro de view ainda teremos o control e o

managed. Usei a base do nome de pacotes como br.ueg.portalVirtual.Criados os pacotes, ficar mais ou menos assim (no se importem com a

cor do package):

Figura 12 - Pacotes do projeto

O primeiro pacote (annotation) ficar as anotaes que criaremos; no

bundle ter apenas arquivos .properties para internacionalizao e

manuteno do JDBC ou qualquer outro que seja necessrio; j em control


20/78


ficar nossas classes responsveis pelo controle do projeto/validaes, ou

seja, a camada intermediria entre a persistncia e a viso; em

persistence a nossa persistncia que far a comunicao com o banco de

dados; em sets ficam as configuraes, tanto do Spring como de banco de

dados; em view fica tudo designado para a viso, sendo que dentro de view

temos control e managed, o primeiro so controladores que a viso obriga

voc a criar e no managed so os gerenciadores da viso, como usamos o

JSF nesse pacote que ficam as classes de ManagedBean.


21/78


Programando - Modelo e suas dependncias

Pronto nossa estrutura, vamos comear a programar, nossa camada maisbaixa o modelo, mas antes de cri-la, devemos criar nossas annotations

que sero utilizadas pela camada citada. No Java, annotation so chamadas

com o @nomeDaAnnotation, elas so marcaes que podem ficar na classe,

no mtodo ou no atributo e podem conter atributos para serem

preenchidos, no JSF 2.0 trabalhamos com annotation em vez de XML, a

nica parte XML que fizemos at agora, e no passa disso, foi no web.xml.

Para criar uma annotation devemos criar uma interface, s que na verdade

criamos uma @interface, isso define que aquela classe uma annotation.

Clique com o boto direito no projeto e v em New>Annotation:

Figura 13 - New>Annotation

Defina o nome da Annotation como RequiredField e a salve no pacote

especfico para ela: br.ueg.portalVirtual.annotation, a responsabilidade

dessa classe marcar atributos que so obrigatrio o preenchimento.

packagebr.ueg.portalVirtual.annotation;

import java.lang.annotation.ElementType;


22/78


import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)public@interfaceRequiredField{

}

Tabela 05 - RequiredField.java

Veja que a classe no tem corpo, usei-a apenas como marcador de

campos obrigatrios. necessrio definir o tipo de elemento onde ser

usado a annotation, no nosso caso para atributos (elementType.FIELD), e

temos que definir a poltica de reteno que ser em execuo

(RetentionPolicy.RUNTIME), sem a definio da poltica a annotation no

ir funcionar bem.

Vamos agora para a camada mais baixa: o modelo. Dentro do pacote

/model crie a classe Entity (New->Class), marque-a como abstract. Veja na

figura que temos Superclass e Interfaces logo abaixo do nome da classe, o

primeiro serve para voc buscar a classe que deseja extender (extends) e o

segundo para adicionar interfaces (implements). Clique em Add... e

procure a interface java.io.Serializable e a adicione:


23/78


Figura 14 - New>Class

packagebr.ueg.portalVirtual.model;

importjava.io.Serializable;

@SuppressWarnings("serial")publicabstractclassEntity implementsSerializable{

publicabstractlonggetId();

@OverridepublicinthashCode() {

finalintprime = 31;intresult = 1;result = prime * result + Long.signum(getId() ^ (getId()

>>> 32));returnresult;

}


24/78


@Overridepublicbooleanequals(Object obj) {

if(this== obj)returntrue;

if(obj == null)returnfalse;

if(getClass() != obj.getClass())returnfalse;

Entity other = (Entity) obj;if(getId() != other.getId())

returnfalse;returntrue;

}

publicabstractString getSearchColumnTable();publicabstractString getSearchColumnEntity();

}

Tabela 06 - Entity.java

Se no pediu para implementar o Serializable na classe, ento digite o

implements como segue na tabela, logo depois do nome dado a class.

Antes da declarao da classe temos uma annotation do Eclipse de

advertncia, no h necessidade dela, serve apenas para no deixar a

classe marcada com o sinal de ateno (@SuppressWarning apenas uma

anotao para que o Eclipse no faa algumas validaes e deixe de avisar

algumas coisas, nesse caso a SuppressWarning pede para no avisar sobre

o serial ID que toda classe que implementa o Serializable deve ter, mas no

faz interferncia na aplicao, por isso apenas um pedido de ateno que

eu mandei ignor-lo).

Essa classe abstrata apenas um marcador, ela obriga a implementar o

mtodo de getId retornando um long, que ser a chave primria do objeto.

Toda objeto que ser persistido no banco de dados deve implementar uma

classe de marcao informando que o objeto virar um array of bytes(dados que sero persistidos), e o Serializable serve exatamente como

marcador para tal objetivo. Repare que os mtodos hashCode e equals

esto marcados como @Override, isso quer dizer que eles foram

sobrescritos, e usei o Eclipse para fazer isso automaticamente para mim

(clique como boto direito sobre o cdigo da classe, v em

Source>Generate hashCode() and equals()...), como essa classe no tem

nenhum atributo, no possvel pedir para o Eclipse gerar o hashCode e

equals, ento crie o atributo id (private long id;) e pea para gerar


25/78


automaticamente, depois de gerado, apague o atributo e substitua nos

mtodos hashCode e equal o uso do atributo id pelo mtodo getId, repare

tambm que no lugar do resultado da Id no hashCode tem o mtodo de

converso Long.signum(long i) que converte um Long em Integer.

Por ltimo temos os mtodos abstratos getSearchColumnTable e

getSearchColumnEntity, esse mtodos servem para criamos um s mtodo

de busca para qualquer classe (ver no pacote de persistncia), o primeiro

retorna qual o nome da coluna no banco de dados que usaremos como

pesquisa e o ltimo o nome do atributo da classe que usaremos para

efetuar a busca.

Todas classes no pacote /model devem herdar a Entity.

No banco de dados temos as tabelas reino e filo, devemos entrar criar as

classes para fazer a correspondncia no projeto:


importjavax.persistence.Column;import javax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.OneToMany;importjavax.persistence.Table;

import br.ueg.portalVirtual.annotation.RequiredField;

@SuppressWarnings("serial")@javax.persistence.Entity@Table(name = "reino")publicclassReino extendsEntity {

@Id@GeneratedValue@OneToMany(targetEntity = Filo.class, mappedBy = "reino")@Column(name = "id_reino")privatelongid;

@Column(name = "nome")@RequiredFieldprivateString reino;

publicReino() {}

publicReino(longid, String reino) {this.id= id;this.reino= reino;

}

publiclonggetId() {

returnid;}


26/78


publicvoidsetId(longid) {this.id= id;

}

publicString getReino() {

returnreino;}

publicvoidsetReino(String reino) {this.reino= reino;

}

@OverridepublicString getSearchColumnTable() {

return"nome";}

@Override

publicString getSearchColumnEntity() {return"reino";

}

}

Tabela 07 - Reino.java

Aqui j temos o uso do JPA verifique que acima da declarao da classe

Reino h 2 annotation: @Entity e @Table, essas mesmas annotation existe

no Hibernate, mas utilizo a do JPA para haver maior flexibilidade de

tecnologias.O Hibernate um framework de persistncia que pode ou no utilizar as

especificaes do JPA, j que o Hibernate tem suas prprias especificaes

(nada mais que CTRL + C, CTRL + V no JPA). Vamos ver ento o Hibernate

como um container e o JPA como a ferramenta para fazer o container

funcionar. Se utilizarmos o Hibernate, ele por si s tem suas ferramentas

para entrar em funcionamento, mas e se no quisermos aquele container?

Se quisermos trocar por outro que atenda nossas necessidades no

momento, teremos que adicionar o novo container e mudar tudo que usa o

container para as novas ferramentas. O JPA j essa ferramenta, se

usarmos no projeto as especificaes do JPA, podemos mudar o container

(Hibernate) por outro com o mnimo de implicaes possveis, por isso uso

sempre as especificaes do JPA em vez do Hibernate.

A partir de agora, se voc no fez a leitura do artigo do Felipe Saab sobre

Spring e Hibernate isso o prejudicar numa melhor compreenso, ento,

leia!
http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/


27/78


A annotation @Entity um marcador informando que aquela classe ser

persistida e tem uma correspondente no banco de dados. A @Table(name)

informa qual o nome da tabela correspondente aquele objeto, ou seja, no

nosso banco de dados criamos a tabela reino e nossa classe Reino faz

referencia a essa tabela.

Foi criado ento o atributo id, do tipo long, e como annotation para esse

atributo temos: @Id, que determina que esse atributo a primary key do

objeto; @GeneratedValue, marcao para que quando a entidade for

persistida gere um valor automaticamente, ou seja, no h necessidade de

defini-la quando quiser salvar um novo registro; @OneToMany, essa

annotation do tipo relacional, serve para dizer que esse atributo umaforeign key de outra tabela, veja que foi definido os atributos targetEntity e

mappedBy, o targetEntity para onde esse valor vai, ou seja, onde ele ser

a foreign key, o mappedBy quer dizer quem est o mapeando, de onde

deve se pegar esse valor (a primary key da tabela reino); e por ultimo

temos o @Column, como o prprio nome diz, nessa annotation voc define

qual o nome da coluna no banco de dados.

Como ultimo atributo temos o reino, do tipo String, e suas annotationsso: @Column, para definir a coluna da tabela; e @RequiredField, ai est

nossa annotation, marcando o atributo reino como campo obrigatrio,

depois veremos como vamos utiliz-la.

Crie dois construtores para instnciar a classe sem fazer nada e outro

passando os parmetros id e reino associando aos atributos locais, o ltimo

construtor necessrio para uma validao no JSF que veremos depois.

Segue os mtodos getters and setters dos atributos, para ger-losautomaticamente clique com o boto direito sobre o cdigo da classe, v

em Source -> Generate Getters and Setters... selecione todos os atributos e

clique em Ok, caso voc j tenha pedido para o Eclipse adicionar os

mtodos obrigatrios no implementados, delete o mtodo getId() e deixe o

Generate Getters and Setters recri-lo.

Por ltimo temos os mtodos getSearchColumnTable e

getSearchColumnEntity que a classe Entity nos obrigou a escrever, o

primeiro retorna o nome da coluna no banco de dados que usamos para


28/78


pesquisa (nome, veja que o mesmo da annotation @Column do atributo

reino), o ltimo retorna o nome do atributo que representa a coluna de

pesquisa, ou seja o prprio atributo reino.

Prxima entidade que temos no banco de dados o Filo:


importjavax.persistence.Column;import javax.persistence.GeneratedValue;importjavax.persistence.Id;import javax.persistence.JoinColumn;importjavax.persistence.ManyToOne;importjavax.persistence.Table;

import br.ueg.portalVirtual.annotation.RequiredField;

@SuppressWarnings("serial")@javax.persistence.Entity@Table(name = "filo")publicclassFilo extendsEntity {

@Id@GeneratedValue@Column(name = "id_filo")privatelongid;@Column(name = "nome")@RequiredFieldprivateString filo;

@ManyToOne(optional = false, targetEntity = Reino.class)@JoinColumn(name = "id_reino", referencedColumnName ="id_reino")

@RequiredFieldprivateReino reino;

publicFilo() {}

publicFilo (longid, String filo, Reino reino) {this.id= id;this.filo= filo;this.reino= reino;

}

publiclonggetId() {returnid;

}

publicvoidsetId(longid) {this.id= id;

}

publicString getFilo() {returnfilo;

}

publicvoidsetFilo(String filo) {this.filo= filo;

}


29/78


publicReino getReino() {returnreino;

}

publicvoidsetReino(Reino reino) {this.reino= reino;

}

@OverridepublicString getSearchColumnEntity() {

return"filo";}

@OverridepublicString getSearchColumnTable() {

return"nome";}

}

Tabela 08 - Filo.java

A classe segue o mesmo esquema que a anterior, verifique que o atributo

da annotation @Table passou a ser filo, o nome da tabela que

corresponde esse objeto no banco de dados. Temos o atributo id com suas

annotations, o atributo filo que um campo obrigatrio (@RequiredField) e

temos o atributo reino (tambm obrigatrio), sendo a nossa foreign key que

mapeamos na classe Reino, mas temos que fazer as especificaes dorelacionamento na classe Filo tambm, para isso temos a annotation

@ManyToOne (inverso do que foi declarado no Reino) dizendo que um

atributo obrigatrio (false para optional) e que ele vem da classe Reino;

logo depois de qual coluna o valor vem pela annotation @JoinColumn,

informando o nome da coluna de destinoid_reino, na tabela filo, e o nome

da coluna de origem, tambm id_reino, na tabela reino (definido pelo

targetEntity do @ManyToOne). De uma olhada na SQL do seu banco dedados para ver as comparaes.

Depois segue os construtores da classe com seus getters and setters e os

mtodos abstratos de Entity que nos obrigou a escrever agora retornam os

nomes da coluna de pesquisa relacionados a entidade (filo de

getSearchColumnEntity) e do banco de dados (nome de

getSearchColumnTable).

Terminamos o nosso modelo, vamos para a persistncia do mesmo.


30/78


Programando - Persistncia

Para a persistncia, necessitamos do Hibernate, criaremos uma classegenrica que deve receber algum objeto que herde Entity, ou seja, nosso

modelo, e ir fazer qualquer ao no banco de dados a partir disso. Uma

classe de persistncia bsica (CRUD) ter apenas os comandos para salvar,

listar, buscar, alterar e deletar, para isso criaremos uma interface contendo

as assinaturas desses mtodos. V ento no pacote de persistncia, clique

com o boto direito sobre ele -> New -> Interface e defina o nome da

interface para IGenericDAO:

Figura 15 - New>Interface

package br.ueg.portalVirtual.persistence;

importjava.util.List;

import br.ueg.portalVirtual.model.Entity;

publicinterfaceIGenericDAO {

publiclongsave(E entity);publicvoidupdate(E entity);publicvoiddelete(E entity);publicList findByCriteria(E entity, String value);publicList findByHQL(E entity, String value);List getList(E entity);

}

Tabela 09 - IGenericDAO.java

Logo aps o nome da interface temos o uso de Generics (), essa

pratica utilizada pelo Java no ArrayList, HashMap, entre outros. Serve

para no precisarmos definir o tipo do elemento para a classe,

generalizamos para um tipo E (Elemento) e quando instnciamos a classe

que definimos qual o tipo dela, exemplo, no ArrayList se usa generics,

mas s quando voc da um new ArrayList voc define o tipo que o

ArrayList ir utilizar. O mesmo acontece com nossa interface, ela persiste o

tipo E que extende de Entity, no sabemos qual o tipo, apenas obrigamos

que qualquer classe que seja usada no Generics, tenha extendido o Entity.

Segue, na interface, as assinaturas dos mtodos de salvar, atualizar,deletar, procurar e listar a entidade.


31/78


Agora hora de implementar esses mtodos, clique com o boto direito

sobre o pacote de persistncia e v em New -> Class e crie a classe

GenericDAO:

package br.ueg.portalVirtual.persistence;


import org.hibernate.criterion.DetachedCriteria;import org.hibernate.criterion.Restrictions;import org.springframework.orm.hibernate3.HibernateTemplate;


publicclassGenericDAO implementsIGenericDAO{

privateHibernateTemplate hibernateTemplate;

publicvoid setHibernateTemplate(HibernateTemplatehibernateTemplate) {

this.hibernateTemplate= hibernateTemplate;}

@Overridepubliclongsave(E entity) {

return(Long) hibernateTemplate.save(entity);}

@Overridepublicvoidupdate(E entity) {

hibernateTemplate.update(entity);}

@Overridepublicvoiddelete(E entity) {

hibernateTemplate.delete(entity);}

@SuppressWarnings("unchecked")@OverridepublicList findByCriteria(E entity, String value) {

DetachedCriteria criteria =DetachedCriteria.forClass(entity.getClass()).add(Restrictions. like(entity.getSearchColumnEntity(), "%"+value+"%"));

returnhibernateTemplate.findByCriteria(criteria);}

@SuppressWarnings("unchecked")@OverridepublicList findByHQL(E entity, String value) {

String hql = "from "+ entity.getClass().getSimpleName() +" where "+ entity.getSearchColumnTable() +" like '%"+value+"%'";

returnhibernateTemplate.find(hql);}

@SuppressWarnings("unchecked")


32/78


@OverridepublicList getList(E entity) {

return(List)hibernateTemplate.loadAll(entity.getClass());

}

}

Tabela 10 - GenericDAO.java

A classe GenericDAO, assim como sua interface, tambm usa Generics.

Assim que der o implements passe o mouse sobre o erro que aparecer na

classe e pea para add unimplemented methods, crie o atributo

hibernateTemplate, do tipo HibernateTemplate, que o mtodo que oferece

os servios de persistncia do Hibernate, crie um setHibernateTemplate

para o Spring gerenciar a instncia desse objeto. Se voc leu o artigo do

Felipe Saab,sabe que o Spring gerencia a instncia de uma classe e injeta

os objetos necessrios para os atributos existente nela (injeo de

dependncia). A classe GenericDAO ser gerenciada pelo Spring, o objeto

hibernateTemplate no e no ser inicializado pelo Java, e o nosso

framework que ficar responsvel por isso, logo veremos que o Spring ter

uma instncia de um objeto do tipo HibernateTemplate, com todos seus

atributos setados, ento injetaremos esse objeto no hibernateTemplate danossa classe de persistncia, a partir da ele poder fazer aes, resumindo,

em vez de no construtor da classe GenericDAO eu passar um new

HibernateTemplate() para o objeto e depois setar os atributos obrigatrios,

deixo essa parte para o Spring e no preciso me preocupar o tempo que

esses objetos ficaram na memria e de que forma, o prprio framework

gerencia isso, da melhor forma que ele achar necessrio.

Como o Spring tratar da inicializao do hibernateTemplate, tomemos o

como inicializado e vamos us-lo sem preocupao. Para cada mtodo

criado na interface de persistncia h um correspondente no Hibernate,

para o save, o Hibernate tem o mesmo mtodo, que precisa que se passe

um objeto com os atributos setados e que tenham annotations de

persistncia que indiquem qual a tabela e a coluna dos atributos, ento o

Hibernate far a persistncia do mesmo.

O mesmo se segue para os outros mtodos, uma pequena observao

para o mtodo de busca, que pode ser feito por Criteria ou por HQL, no
http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/


33/78


primeiro, voc cria um objeto que voc define a tabela onde voc quer

pesquisar atravs do objeto anotado, de que forma quer pesquisar, no

nosso caso usando o LIKE, qual coluna que dever ser analisada e o objeto

a ser comparado com a coluna. Por isso criamos um DetachedCriteria para

a classe em anlise (entity.getClass) e pedimos uma pesquisa usando o

LIKE para o atributo de pesquisa (getSearchColumnEntity). O Criteria

analisa o objeto, e no os registros no banco de dados, ento ele vai na

classe, verifica suas annotations, depois escreve uma SQL correspondente

para fazer a consulta.

No HQL acontece da mesma forma, s que em vez de criarmos um objeto

que far a pesquisa, nos escrevemos a SQL, o que nos da maior liberdade.S que diferente do Criteria, o HQL j vai direto para o banco de dados, usa

apenas a annotation para saber o nome da tabela, ento devemos escrever

o mais prxima da forma que a SQL deve ficar. Nossa SQL para consulta,

na tabela reino, seria: SELECT * FROM Reino WHERE nome LIKE

%valorASerConsultado%;. O HQL resume algumas coisas desnecessrias,

voc no precisa falar que uma consulta, ento omitimos o SELECT *, j

que essa sua nica funo, dizemos qual a classe onde est a annotation

da tabela (Reino, atravs do mtodo entity.getClass().getSimpleName que

retorna o nome da classe sem o pacote) e a coluna a ser pesquisada (nome,

que foi definido no mtodo getSearchColumnTable) e depois o valor a ser

analisado. Com isso pudemos visualizar melhor o uso dos mtodos

abstratos de Entity.

Por ltimo temos o listar, que mandar carregar todos os dados de uma

tabela (classe anotada no Java).

Temos nossa persistncia criada, vamos configurar a conexo com o

banco de dados, depois o Spring.


34/78


Programando - Conectando com o Banco de dados

Precisamos criar uma conexo com o nosso banco de dados para podefazer as aes que definimos na classe GenericDAO. J adicionamos o driver

jdbc que far a comunicao entre o Java e o SQLServer (espero!) agora

basta estabelecermos a conexo com o database criado. Para isso, crie uma

classe com o nome de Connect no nosso pacote de configuraes

(br.ueg.portalVirtual.sets), para facilitar nosso trabalho, extenda a classe

DriverManagerDataSource do Spring:

packagebr.ueg.portalVirtual.sets;

importjava.util.ResourceBundle;

import org.springframework.jdbc.datasource.DriverManagerDataSource;

publicclassConnect extendsDriverManagerDataSource{

privateResourceBundle jdbc;

publicConnect() {jdbc=

ResourceBundle.getBundle("br/ueg/portalVirtual/bundle/jdbc" );

this.setDriverClassName(jdbc.getString("driverClassName"));this.setUrl(jdbc.getString("url"));this.setUsername(jdbc.getString("username"));this.setPassword(jdbc.getString("password"));

}

}

Tabela 11 - Connect.java

A classe tem apenas um atributo chamado jdbc do tipo ResourceBundle.

Bundle um arquivo do tipo .properties que contm apenas texto, sendo

que cada linha composta por: texto, sinal de igualdade e mais texto; o

lado esquerdo da igualdade a chave para se pesquisar e o lado direito da

igualdade o valor que representa a chave (seria a key e value de um

HashMap, por exemplo). Ento para se obter o lado direito da igualdade,

voc deve buscar enviando o texto do lado esquerdo.

No construtor da nossa classe inicializamos nosso ResourceBundle

pedindo para pegar o Bundle jdbc(arquivo jdbc.properties) que fica no

pacote br.ueg.portalVirtual.bundle. Nossa classe Connect responsvel porestabelecer a conexo com o banco de dados, para isso precisamos definir


35/78


alguns atributos no nosso gerenciador do driver para que ele possa

entender que banco de dados utilizamos, como dever criar as SQLs e

qual database analisar. Como citei anteriormente, devemos extender o

DriverManagerDataSource do Spring para facilitar nossas vidas, e nessa

super-classe temos os atributos DriverClassName, URL, Username e

Password que so necessrios preencher. O primeiro diz qual banco de

dados utilizamos, a URL diz o caminho da database, e dois ltimos

informam o usurio e senha para se logar no banco de dados. Como

utilizamos o SQLServer o DriverClassName

com.microsoft.sqlserver.jdbc.SQLServerDriver (isso para o Driver original

da Microsoft), nossa URL ser o banco de dados instalado localmente namquina, especificando qual database em seguida, ento para dizer que

usaremos o servidor local, a URL ser: jdbc:sqlserver://127.0.0.1:1433 do

banco de dados portal_virtual (databaseName=portal_virtual) e depois

colocamos o usurio e a senha que setamos no banco de dados. At agora

eu informei o que tem que ser passado para os atributos, mas no cdigo da

classe de conexo est diferente, veja que eu peo para o Bundle uma

String, mandando suas respectivas chaves de busca, ou seja, mandei o lado

esquerdo da igualdade de um Bundle. Vamos ento construir esse

ResourceBundle para que a classe funcione, clique com o boto direito

sobre o pacote de bundles e depois v em New>Other...>File, digite o

nome jdbc.properties ( necessrio digitar a extenso do arquivo) e

Finish:

driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver url=jdbc:sqlserver://127.0.0.1:1433;databaseName=portal_virtual username=ueg

password=portuegTabela 12 - jdbc.properties

Na criao do banco de dados citei que voc poderia criar o mesmo

usurio que uso no projeto ou alterar o arquivo Properties que tem as

informaes do banco de dados. Esse o arquivo, se voc no criou o

mesmo usurio e senha, pode alterar agora nesse arquivo, caso contrrio,

mantenha as configuraes e sua classe Connect funcionar perfeitamente

pegando os dados de conexo desse arquivo.


36/78


Configurando o Spring

As bibliotecas do Spring j foram adicionadas quando configuramos oprojeto (preciso repetir que espero?! =D), ento basta configurar a sua

inicializao e o que ele deve fazer no projeto. H duas formas de

configurao do Spring, por annotation e por XML, eu gosto de annotation,

pra mim XML cai em desuso a cada dia, alm de ser mais chato, mas se

voc usar annotation haver um problema no controlador de viso do

Spring (justamente na annotation @Controler), que ainda no consegui

resolv-lo, e se usarmos annotation seria bom configura a inicializao do

Spring junto ao projeto, que citei anteriormente que tambm est caindo

em desuso. Decidi, ento, usar XML para a configurao e a no

inicializao do Spring junto ao projeto, depois mando outra verso do

tutorial explicando como funciona com annotation, apesar de que mesmo

usando annotation, voc deve criar o XML do Spring dizendo que vai usar

annotation... Pois bem, na nossa camada de configuraes

(br.ueg.portalVirtual.sets) crie uma XML com o nome de spring, New >

Other... > XML File:


37/78


br.ueg.portalVirtual.model.Reino br.ueg.portalVirtual.model.Filo

org.hibernate.dialect.SQLServerDialect trueupdate

Tabela 13 - spring.xml

Iniciamos nosso XML, depois definimos que ele um arquivo do Spring

com a tag dentro dessa tag esto todos os pacotes do Spring

que utilizaremos (acha que aquele tanto de biblioteca muito... no viu

nada ainda!). O aop (xmlns:aop) declarado a programao orientado a

aspectos do Spring, se quiser retir-la, fique a vontade, est ai para alguns

testes meus e a possvel incorporao da AOP no prximo (se houver)

tutorial. Nesse arquivo XML tambm use o mtodo CTRL + C, CTRL + Vpara nossa tag inicial.

Depois de definir que o arquivo um configurador do Spring, iniciamos

com a tag ela designa os objetos que usaremos, seria a instancia

do objeto, e o primeiro objeto declarado foi nossa conexo com o banco de

dados, que dei o nome de dataSource (id do bean) e informei para o Spring

onde se localiza essa classe para ele fazer sua instancia :

br.ueg.portalVirtual.sets.Connect (o nico atributo dessa classe nos oinstanciamos no construtor da mesma, ento no necessrio pedir para o


38/78


Spring gerenci-lo). Definido essa tag, j temos a conexo com o banco de

dados criada, e podemos referenci-la pelo id dado (dataSource).

Na prxima tag temos a definio da sessionFactory, um atributo

necessrio para inicializar o hibernate, setamos seu nome e a localizao da

classe nos pacotes do Spring e definimos algumas propriedades (atributos),

como fizemos o uso das annotations do JPA para configurao das

entidades, devemos definir a propriedade do atributo annotatedClasses

com isso o Hibernate ir ler as annotations contidas nas classes e no ir

procurar um arquivo XML para fazer as anlises. Essa propriedade uma

lista de entidades declaradas para o uso no projeto, e por isso devemos

definir quais so. Como criamos apenas duas, Reino e Filo, dizemos sualocalizao no value da lista. Prximo propriedade a ser declarada o

hibernateProperties, sendo que essa propriedade tem propriedades dentro

delas a ser definidas (mais atributos), mas no necessrio definir todos,

nesse projeto definimos o dialect que seria a linguagem utilizada pelo

banco de dados, como usamos o SQLServer, o dialect :

org.hibernate.dialect.SQLServerDialect, depois definimos para mostrar a

SQL (true), isso serve apenas para testes no desenvolvimento, quando for

implantar o projeto normalmente desabilita essa opo, j que ser apenas

algo escrito no console sem uso nenhum. Por ultimo definimos o

hbm2ddl.auto, essa propriedade diz como deve tratar o banco de dados, se

tem um alto controle: criar tabelas, salvar, atualizar e listar dados, definido

por create, e se pode apenas salvar, atualizar e listar os dados, definido

por update (que o nosso caso), tem mais alguns tipos, mas no irei cit-

los. Se estiver setado o hbm2ddl como create, voc nem precisaria criar as

tabelas, apenas criava a database e executava o projeto que ele criaria

sozinho, mas prefiro no usar esse recurso.

Como ltima propriedade do hibernateProperties, precisamos passar a

conexo com o banco de dados para o Hibernate poder fazer alguma coisa,

como j definimos ela pelo Spring, basta passar o a referncia pelo nome

que a demos: ref=dataSource e por aqui termina a definio da sesso do

Hibernate.


39/78


Lembra que nossa classe GenericDAO temos um atributo do tipo

HibernateTemplate, vamos agora setar as propriedades desse objeto e criar

uma instancia pelo Spring, e a prxima tag de isso. Definimos o

id do HibernateTemplate e a localizao da classe, depois definimos suas

propriedades, que apenas uma: sessionFactory, como estamos

controlando essa instancia tambm pelo Spring, basta passar a referncia

da mesma, assim como j fizemos e pronto, temos um objeto do tipo

HibernateTemplate.

Vamos utilizar o objeto que acabamos de criar na nossa classe de acesso

aos dados do banco. Crie a tag com o id de genericDAO e passe

onde se localiza a nossa classe GenericDAO, como ns mesmo criamos essaclasse, sabemos que h a necessidade de definir apenas uma propriedade,

a hibernateTemplate, e como j temos a instancia desse objeto pelo Spring,

passe apenas a referncia da mesma.

Pronto, nosso Spring j est configurado, gerenciando o Hibernate e

fazendo injeo de dependncia na classe GenericDAO. O Spring enorme

e pode fazer vrias coisas, e com esse tanto de linhas no XML apenas

configuramos o que foi citado. Poderamos gerenciar tambm outrasclasses, mas como citei que h um problema no controlador da viso do

Spring, preferi no estender essa injeo de dependncias.

Spring configurado, mas como iremos instanciar a GenericDAO? Como a

aplicao saber que estamos utilizando o Spring? Para resolver isso,

vamos criar uma classe de instanciao dos beans definidos no XML (apenas

a GenericDAO).


40/78


Programando - Fbrica de Beans

No tutorial doFelipe Saab,ele citou o AplicationContext para retornar asinstancias dos objetos controlados pelo Spring, e disse que o BeanFactory

seria outro mtodo de trazer esses objetos, s que bastante simples. Fiz a

anlise dos dois e decidi criar a minha fbrica de beans, ou a minha

extenso do AplicationContext.

Para isso, crie uma classe com o nome de SpringFactory e extenda a

classe ClassPathXmlApplicationContext do Spring:

packagebr.ueg.portalVirtual.sets;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclassSpringFactory extendsClassPathXmlApplicationContext {

privatestaticClassPathXmlApplicationContext instance= null;

publicstaticClassPathXmlApplicationContext getInstance() {if(instance== null) {

instance= newClassPathXmlApplicationContext( "br/ueg/portalVirtual/sets/spring.xml" )

; }returninstance;

}

privateSpringFactory() {}

}

Tabela 14 - SpringFactory.java

Essa classe usa o Design Pattern (Padro de Projeto) Singleton. Esse

mtodo faz com que haja somente uma instancia da classe que o

implemente na aplicao toda. Esse mtodo bastante usado e soluciona

vrios problemas, nesse caso no necessrio o uso desse Design Pattern,

o usei porque gosto e no ficar gerando a mesma instancia do

AplicationContext em diferentes objetos.

Para esse Padro de Projeto funcionar, voc tem que desabilitar a

possibilidade de instanciar a classe, fazendo com que o construtor seja

privado, e crie um mtodo esttico que retorne a instancia do objeto, nesse
http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/http://www.javasimples.com.br/spring-2/spring-framework-parte-5-spring-web-mvc/


41/78


mtodo ele ir verificar se h alguma instancia ou no, no havendo ele

gera a instancia.

No mtodo esttico eu retornei um ClassPathXmlApplicationContext que

pode ser convertido em um AplicationContext contendo os mtodos de

retorno de beans configurados no spring.xml (Veja a semelhana com o

mtodo que o Felipe Saab usa).

Agora que temos nossa classe que traz os objetos gerenciados pelo

Spring, vamos construir nosso controlador.


42/78


Programando - Criando nossos controladores

Na camada de controle, ficaro nossas classes de controle depersistncia, de validao e de mensagens, tambm poderia ficar nesse

pacote as regras de negcios, se existissem. Vamos comear com os

controladores auxiliares, crie, ento, a classe ValidatorControl:

packagebr.ueg.portalVirtual.control;

importjava.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;importjava.util.ArrayList;


import br.ueg.portalVirtual.annotation.RequiredField;import br.ueg.portalVirtual.model.Entity;

publicclassValidatorControl {

privateList emptyFields;

publicValidatorControl() {emptyFields= newArrayList();

}

@SuppressWarnings("rawtypes")publicbooleanisEmpty(Entity entity) {

clean();booleanempty = false;Class entityClass = entity.getClass();Field[] fields = entityClass.getDeclaredFields();for(Field currentField:fields) {

try{

currentField.getAnnotation(RequiredField.class);Object fieldValue = getField(entity,

currentField.getName());if(fieldValue == null||

fieldValue.equals("")) { empty = true;emptyFields.add(currentField.getName());

}}catch(Exception e) {

// do nothing yet}

}returnempty;

}

publicbooleanisEmpty(String value) {clean();

booleanempty = false;if(value == null|| value.equals("") ) {empty = true;


43/78


emptyFields.add("Busca");}returnempty;

}

@SuppressWarnings({ "unchecked", "rawtypes"})privateObject getField(Entity entity, String fieldName) throws

SecurityException, NoSuchMethodException, IllegalArgumentException,IllegalAccessException, InvocationTargetException {

Class entityClass = entity.getClass();Method method = entityClass.getMethod("get"+

fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1));returnmethod.invoke(entity);

}

publicvoidclean() {emptyFields.clear();

}

publicList getEmptyFields() {returnemptyFields;

}

}

Tabela 15 - ValidatorControl.java

Devo dizer que essa umas das minhas classes favoritas, pois usa o Java

Reflection para validar qualquer classe que extenda Entity (=D), e aqui

que veremos o uso da nossa annotation @RequiredField.

Para nvel de conhecimento, Reflection uma prtica que podemos

analisar a classe em tempo de execuo, assim descobrimos quais atributos

ela tem, seus mtodos e podemos at invoc-los. No uma prtica

recomendada para quem est iniciando no Java, pois requer um

conhecimento maior da linguagem, mas errando que se aprende.

Tem algumas caractersticas que definem a Reflection, que a

introspeco e a interseco. No Java tem a introspeco que a

capacidade da classe se auto-examinar, a interseco a capacidade de

tomar uma deciso em tempo de execuo. Essa prtica muito mais do

que foi citado, mas somente isso o bastante para ter conhecimento do

que estamos usando. Para mais informaes tem umas boas explicaes na

OracleeGUJ.

Nossa classe tem como atributo uma lista de String com nome de

emptyFields, que usaremos para relacionar todos os campos obrigatrios
http://download.oracle.com/javase/tutorial/reflect/index.htmlhttp://download.oracle.com/javase/tutorial/reflect/index.htmlhttp://www.guj.com.br/articles/10http://www.guj.com.br/articles/10http://www.guj.com.br/articles/10http://www.guj.com.br/articles/10http://download.oracle.com/javase/tutorial/reflect/index.html


44/78


que no foram preenchidos. O construtor apenas inicializa essa lista com

nada dentro.

Vamos entender os mtodos dessa classe de baixo para cima (bottom-

up). Como ltimo mtodo temos o getEmptyFields que retorna o atributo de

lista de nomes de campos que no foram preenchidos. O mtodo clean()

serve para limpar a lista.

No mtodo getField temos alguns throws, esses throws significam que

podem acontecer as exceptions citadas e no sero tratadas nesse mtodo,

obrigando a quem us-lo fazer esse tratamento. E agora comea o Java

Reflection! Criamos uma varivel local do tipo Class que recebe a Class do

parmetro entity, com essa varivel que teremos acesso aos mtodos

internos, atributos o que j citei que a Reflection pode fazer, e na prxima

linha j vemos o exemplo disso, pedimos a entityClass para nos dar o

mtodo get*NomeDoCampo*, isso foi feito porque nossa Entity nada mais

que um POJO, ento todos atributos so privates e para verificar seus

valores preenchidos, devemos pegar seu respectivo mtodo get. Ento

invocamos o mtodo get do atributo e os retornamos.

O prximo mtodo um polimorfismo de sobrecarga de mtodo doprimeiro. Em vez de receber uma Entity, recebe uma String, esse mtodo

serve para verificar se a String no est vazia, valida ento se o campo de

busca foi preenchido. Veja que ele limpa a lista e faz as verificaes na

String, caso esteja vazia, adiciona a lista o campo que no foi preenchido:

Busca, edita o booleano que representa o retorno do mtodo para true e o

retorna.

E por ltimo, ou primeiro mtodo, temos o isEmpty que recebe umobjeto do tipo Entity, verifica quais so os campos obrigatrio e retorna se

tem algum no preenchido. O mtodo recebe um Entity, mas essa classe

abstrata, no tem como instanci-la, ento ser enviado um objeto que a

extenda. A primeira coisa que o mtodo faz chamar o mtodo clean,

criamos uma varivel local do tipo boolean que ser o retorno desse mtodo

e o inicializamos com false (temos como hiptese inicial que a entidade est

com os campos preenchidos).


45/78


Criamos um objeto do tipo Class, e mandamos o Class do objeto entity

que veio como parmetro do mtodo (entity.getClas()), pegamos os

campos dessa Class e a associamos a um vetor do tipo Field, e a nova

varivel fields tem todos os campos da classe entity. Agora devemos

percorrer esses campos e ver se esto preenchidos. Usei o for para fazer

o lao de repetio, mas veja que a assinatura do for um pouco

diferente, esse jeito de utiliz-lo se chama for each que cria um lao de

repetio para um vetor (ou lista) percorrendo-o todo, seria a mesma coisa

que:

for(inti = 0; i


46/78



importjava.util.ResourceBundle;

publicabstractclassMessagesControl {

privatestaticResourceBundle messages;

publicMessagesControl() {messages=

ResourceBundle.getBundle("br/ueg/portalVirtual/bundle/messages" );}

protectedString getMessage(String typeMessage) {returnmessages.getString("erro_"+ typeMessage);

}

publicabstractvoidaddMessage(String message);

}

Tabela 17 - MessagesControl.java

No nosso controlador abstrato de mensagens temos o ResourceBundle

como atributo, um construtor que inicializa o nosso Bundle de mensagens

(ainda ser criado) e um mtodo protected getMessage que recebe como

parmetro o tipo da mensagem, e retornamos a String da chave enviada

pelo Bundle messages. Logo depois temos um mtodo abstrato

addMessage(). Tive alguns problemas em extender essa classe, por causado FacesContext do JSF, e tive que tirar a inicializao do bundle do

construtor. Essa classe tem como responsabilidade pegar mensagens do

bundle e obrigar quem a implemente criar um mtodo para adicionar a

mensagem e exibi-la, independente se Java Desktop, Web ou Mobile,

quem a implemente que far a distino.

Agora sim podemos criar nosso controlador de persistncia, e como

para CRUD, criaremos uma interface para ter uma melhor organizao:packagebr.ueg.portalVirtual.control;


publicinterfaceIControl {

publicList getListAll(E entity);publicLong save(E entity);publicvoidupdate (E entity);publicList findByCriteria(E entity, String value);publicList findByHQL(E entity, String value);

publicvoiddelete (E entity);


47/78


}

Tabela 18 - IControl.java

A nossa interface contm apenas as assinaturas para fazer a persistncia,

idntica a IGenericDAO, nem h a necessidade dessa interface, a classe

Control pode implementar a IGenericDAO mesmo, mas a criei para fazer

uma diferenciao, que pode haver.

Nosso controlador de persistncia (Control) assim como a DAO

genrico, qualquer classe que extenda Entity poder ser controlada e

persistida pelo objeto. Tambm uso o Generics do Java como j expliquei

anteriormente.

Vamos ento criar a classe que implementa nossa interface, veja que o

Control trabalha parecido como uma fachada para a persistncia, ele

apenas iria chamar os mtodos do GenericDAO, mas antes, faz algumas

validaes o que torna um controlador pr-persitncia:




import br.ueg.portalVirtual.persistence.GenericDAO;import br.ueg.portalVirtual.sets.SpringFactory;import br.ueg.portalVirtual.view.control.MessagesWeb;

publicclassControl implementsIControl {

privateGenericDAO persistence;privateValidatorControl validator;privateMessagesControl messages;

@SuppressWarnings("unchecked")publicControl() {

persistence= (GenericDAO)

SpringFactory.getInstance().getBean("genericDAO", GenericDAO.class);validator= newValidatorControl();messages= newMessagesWeb();

}

@OverridepublicList getListAll(E entity) {

returnpersistence.getList(entity);}

@OverridepublicLong save(E entity) {

if(!validator.isEmpty(entity)) {returnpersistence.save(entity);

} else{List emptyFields =


48/78


validator.getEmptyFields();for(inti = 0; i < emptyFields.size(); i++) {

messages.addMessage(emptyFields.get(i));}

}

return(long) 0;}

@Overridepublicvoidupdate(E entity) {

if(!validator.isEmpty(entity)) {persistence.update(entity);

} else{List emptyFields =

validator.getEmptyFields();for(inti = 0; i< emptyFields.size(); i++) {

messages.addMessage(emptyFields.get(i));}

}

}

@OverridepublicList findByCriteria(E entity, String value) {

if(!validator.isEmpty(value)) {returnpersistence.findByCriteria(entity, value);

} else{

messages.addMessage(validator.getEmptyFields().get(0));}returnnull;

}

@OverridepublicList findByHQL(E entity, String value) {

if(!validator.isEmpty(value)) {returnpersistence.findByHQL(entity, value);

} else{

messages.addMessage(validator.getEmptyFields().get(0));}returnnull;

}

@Overridepublicvoiddelete(E entity) {persistence.delete(entity);

}

}

Tabela 19 - Control.java

No Control temos como atributos a persistence, do tipo GenericDAO, o

validator e o messagesControl, ou seja, temos a camada inferior de

persistncia (GenericDAO) e os controladores secundrios (validator e

messages). No construtor inicializamos os atributos, veja que a inicializao


49/78


do GenericDAO usa nossa fbrica de beans, instanciando o objeto via

Spring, e no com o new como os outros embaixo dele. Verifique tambm

que o MessagesControl recebe a instancia do MessagesWeb, essa ltima

classe extende MessagesControl, e iremos implement-la na camada de

viso. Como o MessagesControl abstract no se pode instanci-lo.

Como primeiro mtodo, temos o de listagem, como no necessrio

fazer nenhuma validao, chamamos a camada inferior e pedimos para

trazer a listagem do item. Depois segue os mtodos de save e update, os

dois seguem a mesma lgica, ento vou explic-los juntos. Primeiro

verificado se todos os campos foram preenchidos atravs do

ValidatorControl mandando a entidade que queremos persistir para aanlise. Se no houver campos obrigatrios vazios, chamamos o

GenericDAO e salvamos/atualizamos, caso contrrio, chamado o

MessagesControl e pedimos para adicionar a mensagem de erro (campo

obrigatrio no preenchido).

Os prximos mtodos findByCriteria e findByHQL trabalham de forma

semelhante, primeiro analisam se o campo de busca foi preenchido

chamando o ValidatorControl, se sim, pedem para o GenericDAO fazer abusca, caso contrrio pede para o MessagesControl criar mensagem de

erro.

Por ltimo temos o delete, tambm sem validaes, apenas peo para

excluir o item selecionado atravs da camada inferior.

Terminamos nossa camada intermediria, vamos a ltima camada, a

viso.


50/78


Programando - Controlando a viso

Como estvamos falando de controlador, vamos comear criando nossocontrolador de mensagens da viso. Crie a classe MessagesWeb no pacote

de controle da viso: br.ueg.portalVirtual.view.control, e extenda o

MessagesControl:

packagebr.ueg.portalVirtual.view.control;

import javax.faces.application.FacesMessage;import javax.faces.context.FacesContext;

import br.ueg.portalVirtual.control.MessagesControl;

publicclassMessagesWeb extendsMessagesControl {

publicMessagesWeb() {super();

}

@OverridepublicvoidaddMessage(String message) {

FacesMessage msg = newFacesMessage(FacesMessage.SEVERITY_WARN, "Erro", getMessage(message));

FacesContext.getCurrentInstance().addMessage(null, msg);

}

}

Tabela 20 - MessagesWeb.java

Essa classe bem simples, no seu construtor apenas chamamos o

construtor da classe superior (mtodo super()). Implementamos o mtodo

addMessage que o MessagesControl nos obriga a faz-lo. Como se trata de

um controlador de mensagens para a Web, criamos uma varivel local do

tipo FacesMessage, essa classe faz parte do JSF e guarda mensagens deerros e alerta, basta adicionarmos algum item e a pgina que tiver um

componente de mensagens ir exibi-la (simples no?). Instanciamos o

FacesMessage passando um tipo de mensagem para exibir o cone

corresponde ao mesmo (SEVERITY_WARN, mensagem de ateno apenas)

e a mensagem que desejamos exibir. Na prxima linha adicionamos a

mensagem a instancia do JSF.


51/78


J temos um controlador de mensagens funcionando, e nem preciso

chamar mtodos para exibir mensagem, basta criar um componente que

exiba as mensagens salvas no JSF.

Na viso temos o componente ComboBox (ou SelectOne) que mostra

uma lista de opes para selecionarmos e escolhermos uma. Iremos criar a

ComboBox para o Reino, que possui os atributos id e reino. Ser exibido

apenas o nome do reino (reino), mas precisaremos enviar o id e o reino do

item selecionado para o gerenciador da viso, e o JSF no faz isso sozinho.

Ele apenas pega o item que deseja exibir (Reino), transforma em String e

voc escolhe o que tem que aparecer (itemLabel), depois de selecionado o

item se mantm em String e voc escolhe o que deve ir para o gerenciador(itemValue), quando voc quer mandar a entidade toda (Reino, em vez de

s id ou s reino) d um erro, pois no d para passar a String para o

objeto desejado, para solucionar esse problema criamos um conversor.

Vamos criar nosso conversor do Reino e tentarmos entende-lo. No pacote

de controladores da viso, crie a classe Converter e implemente a classe

Converter do faces.converter:

packagebr.ueg.portalVirtual.view.control;

import javax.faces.component.UIComponent;import javax.faces.context.FacesContext;import javax.faces.convert.FacesConverter;

import br.ueg.portalVirtual.model.Reino;

@FacesConverterpublicclassConverter implements javax.faces.convert.Converter{

@OverridepublicObject getAsObject(FacesContext context, UIComponent

component, String value) {

intindex = value.indexOf(':');

if(index != -1) {returnnewReino(Long.parseLong(value.substring(0,

index)),value.substring(index + 1));

}returnvalue;

}

@OverridepublicString getAsString(FacesContext context, UIComponentcomponent,


52/78


Object value) {

try{Reino optionItem = (Reino) value;returnoptionItem.getId() + ":"+

optionItem.getReino();} catch(Exception e) { }return(String) value;

}

}

Tabela 21 - Converter.java

A classe possui a annotation @FacesConverter que diz para o JSF que

essa classe se trata de um conversor de entidades. Quando implementamos

o Converter do faces.converter, ele nos obriga a criar os mtodos

getAsObjet e getAsString, o primeiro transforma String em Object, e o

outro transforma Object em String.

Essa classe CTRL + C, CTRL + V, alterando para a sua necessidade,

sendo que estamos criando agora o conversor para a entidade Reino, e

poderamos definir isso dentro da annotation @FacesConverter definindo os

atributos delas dessa forma: @FacesConverter(forClass=Reino.class); mas

como uso somente um conversor, no fiz essa declarao. Vamos agora

entender a classe.

O mtodo getAsObject pega a String do ComboBox (que veio do

getAsString), procura onde fica o : pelo indexOf, se houver os : que a

String passou pelo mtodo getAsString e podemos fazer a converso sem

nenhum problema, para isso repartimos a String na quantidade de atributos

da classe (Reino tem dois atributos, id e reino) e instanciamos o objeto.

Veja que temos um new Reino, convertendo a primeira String at o : em

long (id) e depois passamos o valor pra frente do : sem converso (reino)

e retornamos o objeto do tipo Reino.

O mtodo getAsString faz o inverso, ele recebe um objeto e tenta

converte-lo no tipo Reino (Reino optionItem = (Reino) value;) se a

converso for possvel, ento retornamos todos os atributos do tipo como se

fossem uma String, separando-os com :, caso haja algum problema

apenas h uma tentativa de converter o objeto em String direto.


53/78


Esses so os controladores da viso, antes de ir para os gerenciadores da

viso, ou ManagedBeans, vamos criar as mensagens que usaremos nas

telas, ou seja, mais Bundle (=D).


54/78


Programando - Internacionalizao por Bundle

J criamos o Bundle do JDBC, que sua nica funo reunir, em seuarquivo, todos os dados para configurar e criar uma conexo com o banco

de dados. Agora usaremos o Bundle para outra causa, alm de reunirmos

todas as mensagens na tela em um arquivo .properties, tambm o

usaremos para internacionalizar o nosso projeto, ou seja, iremos facilitar a

possvel alterao de lnguas no website.

No pacote de Bundle, crie o arquivo messages_pt_BR.properties

(New>Other... >File):####################### Mensagens de Erro #######################erro_reino = OcampoReinoobrigatrio!erro_filo = OcampoFiloobrigatrio!erro_Busca = necessriopreencherocampodebuscaparaefetuaraao!

####################### Comuns #######################button_save = Salvarbutton_list = Listarbutton_cancel = Cancelarbutton_search = Buscarcolumn_edit = Editar

column_delete = Excluir

####################### Mensagens utilizadas no caso de uso ManterReino #######################reino_title = ManterReinoreino_add = AdicionarReinoreino_header = CadastrarReinoreino_headerEdit = EditarReinoreino_reino = Reino:reino_reinoColumn = Reinoreino_empty = Nohreinosregistrados.

####################### Mensagens utilizadas no caso de uso ManterFilo #######################filo_title = ManterFilofilo_add = AdicionarFilofilo_header = CadastrarFilofilo_headerEdit = EditarFilofilo_filo = Filo:filo_filoColumn = Filofilo_empty = Nohfilosregistrados.filo_select = Selecioneum

####################### Mensagens utilizadas no template#######################template_register = Cadastrar

Tabela 22 - messages_pt_BR.properties


55/78


Veja que separei as mensagens em: mensagens de erro (lembra do

MessagesControl?); comuns; caso de uso Manter Reino; caso de uso Manter

Filo; e da tela template. Esse Bundle feito durante a confeco das telas,

voc no lembra de todas as mensagens e botes que uma tela vai ter

antes.

No h o que explicar nesse Bundle, temos a chave de pesquisa a

esquerda e o valor a direita, utilizamos esse Bundle na confeco de

mensagens de erro e na tela. Antes de configurar a internacionalizao,

vamos criar as mensagens em ingls, usei o pouco conhecimento que tenho

e o Google Tradutor e criei o messages_en_US.properties:

####################### Mensagens de Erro #######################erro_reino = ThefieldKingdomisrequired!erro_filo = ThefieldPhylumisrequired!erro_Busca = Pleasefillthefieldofsearchtoperformtheaction!

####################### Comuns #######################button_save = Savebutton_list = Listbutton_cancel = Cancelbutton_search = Searchcolumn_edit = Editcolumn_delete = Delete

####################### Mensagens utilizadas no caso de uso ManterReino #######################reino_title = KeepKingdomreino_add = AddKingdomreino_header = RegisterKingdomreino_headerEdit = EditKingdomreino_reino = Kingdom:reino_reinoColumn = Kingdomreino_empty = Therearenotregisteredkingdom.

####################### Mensagens utilizadas no caso de uso ManterFilo #######################filo_title = KeepPhylum

filo_add = AddPhylumfilo_header = RegisterPhylumfilo_headerEdit = EditPhylumfilo_filo = Phylum:filo_filoColumn = Phylumfilo_empty = Therearenotregisteredphylum.filo_select = Selectone

####################### Mensagens utilizadas no template#######################template_register = Register

Tabela 23 - messages_en_US.properties


56/78


Essa so as mensagens traduzidas, espero que esteja certo, vamos ento

configurar o Bundle para funcionar nas telas que criaremos, voc j viu

como configurar um Bundle no cdigo do Java, usando o ResourceBundle,

mas para ele ser acessvel por qualquer tela devemos configurar o nosso

arquivo no faces-config.xml que o Eclipse, provavelmente, j criou. O

arquivo fica no diretrio /WebContent/WEB-INF, perto do web.xml, ao abri-

lo, assim como todo XML, ir abrir na forma no-cdigo - Introduction, para

poder visualizar o cdigo e alter-lo clique em Source:

br.ueg.portalVirtual.bundle.messages

msg

pt_BRpt_BRen_US

br.ueg.portalVirtual.bundle.messages

Tabela 24 - faces-config.xml

Se o Eclipse criou esse arquivo, ele vem com a tag

preenchida, essa tag apenas define que um arquivo do JSF e sua verso,

caso voc tenha criado, use o CTRL + C e CTRL + V. Caso no estivssemos

querendo configurar por annotation o JSF, aqui que configuraramos as

pginas, regras de navegaes e todo o resto. Como vamos utilizar

annotation apenas a configurao do Bundle ficar nesse arquivo, j que

no encontrei como configurar por annotation.

Crie a tag (no use CTRL + C; CTRL + V, use o CTRL +

ESPAO), dentro crie a nela temos que definir ondeest o arquivo de internacionalizao e o seu nome base


57/78


(br.ueg.portalVitual.bundle e o nome sem a definio do idioma: messages)

e o nome d

tutorial java web com jsf 2

Documents

tutorial java web

dynamic web project

server location

banco de dados

ueg unucetanpolisoutubro

diego carlos rezendegraduando

new others