jun 27 2010

Hibernate com Hibernate Tools

Category: HibernateEdson Gonçalves @ 1:30

Olá Pessoal, tudo bom? Como vão vocês?

O artigo que veremos fala sobre a utilização do Hibernate Tools, um excelente plugin para o Eclipse IDE, oficial da Red Hat, feito para trabalhar com o Hibernate.

Dúvidas e críticas são sempre bem vindas.

Obtendo e instalando o Eclipse IDE

Para desenvolver este exemplo, utilizei a versão do Eclipse IDE 3.6, em um ambiente voltado para o trabalho com Java EE. Para obter o Eclipse IDE, já configurado com o ambiente Web, vá ao endereço http://www.eclipse.org/downloads/ e clique em Eclipse IDE for Java EE Developers. Lembre-se de selecionar o seu sistema operacional.

Ao baixar, descompacte em um local desejado de sua máquina.

O plugin JBoss Tools

Para a versão do Eclipse 3.6, o atual enquanto escrevo este artigo, temos uma versão em desenvolvimento compatível do plugin JBoss Tools. Para obtê-lo, basta baixar a versão de desenvolvimento atual, encontrada em um dos diretórios existentes dentro deste endereço:

http://download.jboss.org/jbosstools/builds/nightly/trunk/

Podemos baixar o Hibernate Tools separadamente ou, como fiz, baixando o JBoss Tools completo. O arquivo que obtive, no momento em que escrevo é o JBossTools-Update-3.2.0.v201006240331N-H369-M1.zip. Com o Eclipse IDE fechado, ao baixar o plugin, descompacte e mova seu conteúdo  sobre o diretório eclipse. Isto fará a instalação do  plugin JBoss Tools. Depois de adicionarmos o plugin, inicie o Eclipse.

Atenção: Por se tratar de uma versão em desenvolvimento, o endereço passado neste artigo poderá sofrer alterações. Portanto, sempre verifique a última versão no endereço http://download.jboss.org/jbosstools/builds/. As versões de desenvolvimento costumam causar instabilidade no Eclipse, portanto, façam seu uso em um ambiente de testes.

O banco de dados

Utilizaremos o banco de dados MySQL, que pode ser adquirido clicando aqui. O banco de dados que utilizaremos para executar o exemplo se chamará hibernatenapratica.

Criando o projeto

Iniciem alterando a perspectiva. No ícone Open Perspective,  cliquem em Other.

Figure 1 – Alterando a Perspectiva

Figura 1 – Alterando a Perspectiva

Selecionem em seguida a Perspectiva Hibernate.

Figure 2 – Seleção da perspectiva Hibernate

Figura 2 – Seleção da perspectiva Hibernate

Na view Package Explorer, cliquem com o direito do mouse e selecionem, no menu de contexto, o item Project.

Figure 3 – Criando um novo projeto pela view Package Explorer através do menu de contexto

Figura 3 – Criando um novo projeto pela view Package Explorer através do menu de contexto

Na caixa de dialogo New Project, selecionem Java>Java Project e cliquem no botão Next.

Figure 4 – Seleção da opção Java Project

Figura 4 – Seleção da opção Java Project

Em New Java Project, digitem o nome do seu projeto. Irei utilizar o nome ProjUtilizandoHibernateTools. Em seguida, cliquem no botão Finish.

Figure 5 – Criação de um projeto Java

Figura 5 – Criação de um projeto Java

Ao surgir a caixa de dialogo Open Associated Perspective, cliquem no botão No. Nós não precisaremos da perspectiva Java apenas para editar o projeto, uma vez que nossa intenção é trabalhar única e exclusivamente com o Hibernate.

Figure 6 – Pergunta automática de alteração de perspectiva feita dependendo do tipo de projeto criado

Figura 6 – Pergunta automática de alteração de perspectiva feita dependendo do tipo de projeto criado

As bibliotecas

Para trabalhar com o Hibernate 3.5, primeiramente será preciso configurar os arquivos no projeto. Para adicionar as bibliotecas que necessitamos ao projeto, cliquem com o direito do mouse sobre o mesmo, na view Package Explorer e, no menu de contexto, selecionem Properties.

Figure 7 – Bibliotecas do projeto

Figura 7 – Bibliotecas do projeto

Vocês podem baixar as bibliotecas do Hibernate clicando aqui. No site, em Download, no menu lateral esquerdo, encontramos as bibliotecas para serem baixadas. A versão, no momento em que escrevo, é a 3.5.1.

Os arquivos que utilizaremos no projeto serão os encontrados em:

  • Hibernate Core

Ao baixar os arquivos, descompacte-os.  Vocês precisarão das seguintes bibliotecas:

  • hibernate3.jar
  • antlr-2.7.6.jar
  • commons-collections-3.1.jar
  • dom4j-1.6.1.jar
  • javassist-3.9.0.GA.jar
  • jta-1.1.jar
  • slf4j-api-1.5.8.jar
  • hibernate-jpa-2.0-api-1.0.0-CR-1.jar

Além destes arquivos, será necessário utilizar as bibliotecas da Simple Logging Facade for Java, SLF4J. Baixem os arquivos com todas as bibliotecas da SLF4J aqui.

Ao descompactar o arquivo, vocês encontrarão a seguinte biblioteca:

  • slf4j-jdk14-1.5.11.jar

Por fim, também necessitaremos da biblioteca JDBC do MySQL, que pode ser obtida clicando aqui. A versão 5.1.10 era, no momento em que este artigo começa a ser escrito, a versão mais atual. Entretanto, é possível que, com o tempo, isto esteja alterado.

Para o projeto, precisaremos do seguinte JAR:

  • mysql-connector-java-5.1.10-bin.jar

Criando o JavaBean Categoria

Com o direito do mouse em seu projeto, vamos até o item New>Other. Na caixa de diálogo New, selecionem Java>Class. Na caixa de diálogo New Java Class, preencham o pacote (br.com.integrator) e o nome da classe, no caso Categoria, em Name. Confirmem a criação no botão Finish.

Figure 8 – Criando a classe Categoria

Figura 8 – Criando a classe Categoria

Alterem a classe Categoria conforme mostrado na Listagem 1.

Listagem 1 – O JavaBean Categoria

package br.com.integrator;

import java.io.Serializable;

import java.lang.Long;

import java.lang.String;

public class Categoria implements Serializable {

private Long id;

private String categoria;

private String descricao;

public Long getId() {

return id;

}

public void setId(Long id) {

this.id = id;

}

public String getCategoria() {

return categoria;

}

public void setCategoria(String categoria) {

this.categoria = categoria;

}

public String getDescricao() {

return descricao;

}

public void setDescricao(String descricao) {

this.descricao = descricao;

}

}

Mapeando a tabela no Hibernate utilizando a forma tradicional

Para mapear a tabela correspondente no banco de dados a classe Categoria, através do Hibernate, temos que criar um XML como forma tradicional de utilização do framework.

Selecionem o pacote e a classe na view Package Explorer e, com o direito do mouse, selecionem o item New>Hibernate XML Mapping file (hbm.xml).

Figure 9 – Seleção do item Hibernate XML Mapping file (hbm.xml) no menu de contexto

Figura 9 – Seleção do item Hibernate XML Mapping file (hbm.xml) no menu de contexto

Na caixa de diálogo New Hibernate XML Mapping Files (hbm.xml), teremos os dois itens selecionados: o pacote e a classe. Caso tenhamos esquecido de selecionar um ou ambos, podemos clicar nos botões que estão na lateral direita (Add Class e Add Package). Continuem no botão Next.

Figure 10 – Criação do arquivo XML de mapeamento do Hibernate

Figura 10 – Criação do arquivo XML de mapeamento do Hibernate

Na etapa seguinte o assistente exibirá o arquivo Categoria.hbm.xml que será criado.  Continuem no botão Next.

Figure 11 – Apresentação do arquivo XML de mapeamento do Hibernate que será criado

Figura 11 – Apresentação do arquivo XML de mapeamento do Hibernate que será criado

A última etapa apresentará o XML do mapeamento criado para o Hibernate, onde a base foi a classe Categoria. Confirmem a criação no botão Finish.

Figure 12 – Arquivo XML do mapeamento que será criado

Figura 12 – Arquivo XML do mapeamento que será criado

Com a finalização do assistente, temos o XML gerado aberto pelo editor do Hibernate Tools. Neste editor podemos mudar as características que desejamos no XML gerado, colocando mais informações em cada propriedade.

Figure 13 – Editor do XML gerado para Hibernate

Figura 13 – Editor do XML gerado para Hibernate

O resultado final será como o mostrado na Listagem 2 a seguir:

Listagem 2 – O arquivo Categoria.hbm.xml

O resultado final será como o mostrado na Listagem 2 a seguir:

Listagem 2 – O arquivo Categoria.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

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

<!-- Generated 24/06/2010 05:07:14 by Hibernate Tools 3.3.0.GA -->

<hibernate-mapping>

<class name="br.com.integrator.Categoria" table="categoria">

<id name="id" type="java.lang.Long">

<column name="id"/>

<generator class="increment"/>

</id>

<property generated="never" lazy="false" name="categoria" type="java.lang.String">

<column name="categoria" length="50"/>

</property>

<property generated="never" lazy="false" name="descricao" type="java.lang.String">

<column name="descricao"/>

</property>

</class>

</hibernate-mapping>

Configurando o Hibernate

Com o direito do mouse sobre src, na view Package Explorer, selecionem Hibernate Configuration File (cfg.xml).

Figure 14 – Criação do arquivo hibernate.cfg.xml

Figura 14 – Criação do arquivo hibernate.cfg.xml

Ao surgir o assistente, deixem o nome do arquivo como hibernate.cfg.xml e prossigam no botão Next.

Figure 15 – Assistente de criação do arquivo de configuração do Hibernate

Figura 15 – Assistente de criação do arquivo de configuração do Hibernate

Como vamos utilizar o banco de dados MySQL, preencham os campos como mostrado na Figura 16, alterando de acordo com as configurações que possuem em seu banco de dados.

Por fim, marquem a opção Create a console configuration.  Cliquem no botão Next.

Figure 16 – Configuração do banco de dados no hibernate.cfg.xml

Figura 16 – Configuração do banco de dados no hibernate.cfg.xml

Na última etapa, temos as configurações do console do Hibernate. Este console, quando configurado e funcional, nos permite  executar queries HQL ou trabalhar com Criteria.

Figure 17 – Configuração do console Hibernate

Figura 17 – Configuração do console Hibernate

Cliquem na aba Mappings e removam o caminho configurado automaticamente para o arquivo Categoria.hbm.xml. Este caminho não será preciso porque iremos configurá-lo diretamente no arquivo hibernate.cfg.xml, ao qual o console fará uso também. Confirmem o assistente clicando no botão Finish.

Figure 18 – A abra Mappings da configuração do console

Figura 18 – A abra Mappings da configuração do console

Na finalização do assistente, abrirá o editor do arquivo de configuração do Hibernate.

Figure 19 – O editor do arquivo de configuração do Hibernate

Figura 19 – O editor do arquivo de configuração do Hibernate

Como muitas das informações que desejávamos, foram colocadas no assistente, resta apenas adicionar o caminho para Categoria.hbm.xml. Para fazermos isso, basta ir no botão Add e digitar o caminho em Resource.

Figura 20 – Detalhe de Mappings com o arquivo Categoria.hbm.xml adicionado

Figura 20 – Detalhe de Mappings com o arquivo Categoria.hbm.xml adicionado

Para executarmos o exemplo, tornando possível a criação da tabela no banco de dados pelo Hibernate, assim como sua recriação a cada nova execução, expandindo Session Factory>Properties>Hibernate, em Hibernate Configuration 3.0 XML Editor, alterem Hbm2ddl Auto para create-drop.

Neste mesmo local, onde temos as propriedades, podemos alterar para true em Show SQL, Use SQL Comments e Format SQL.

Figura 21 – Adicionando novas propriedades ao arquivo hibernate.cfg.xml

Figura 21 – Adicionando novas propriedades ao arquivo hibernate.cfg.xml

O resultado final das configurações, no arquivo hibernate.cfg.xml, são mostrados na Listagem 3 a seguir:

Listagem 3 – O arquivo hibernate.cfg.xml

<?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.connection.driver_class">org.gjt.mm.mysql.Driver</property>

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

<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernatenapratica</property>

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

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

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

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

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

<property name="hibernate.hbm2ddl.auto">create-drop</property>

<mapping resource="br/com/integrator/Categoria.hbm.xml"/>

</session-factory>

</hibernate-configuration>

Algumas características do Hibernate Tools

Como Hibernate está devidamente configurado, podemos já utilizar algumas de suas características.

Figura 22 – A view Hibernate Configurations após as configurações do arquivo hibernate.cfg.xml

Figura 22 – A view Hibernate Configurations após as configurações do arquivo hibernate.cfg.xml

Na view Hibernate Configurations, cliquem com o direito do mouse e selecionem Mapping Diagram.

Figura 23 – Acessando Mapping Diagram no menu de contexto

Figura 23 – Acessando Mapping Diagram no menu de contexto

O Hibernate Tools possui uma ferramenta visual que nos permite visualizar as classes mapeadas em suas tabelas correspondentes encontradas no banco de dados.  Isto não significa que a tabela já exista no banco de dados. Trata-se da forma como a configuração “enxerga” a tabela em que irá trabalhar no banco de dados.

Figura 24 – Visualizando a classe Categoria mapeada para a tabela correspondente no banco de dados

Figura 24 – Visualizando a classe Categoria mapeada para a tabela correspondente no banco de dados

Colocando o Hibernate para trabalhar

Iremos criar duas pequenas classes que juntas irão gerar a tabela e seus  dados dela no banco de dados.

Com o direito do mouse sobre src, na view Package Explorer, selecionem o item New>Other.  Na caixa de dialogo New, selecionem Java>Class.

Coloquem o pacote br.com.integrator.util e deem o nome da classe de HIbernateUtil, confirmando o assistente, em seguida, no botão Finish.

Figura 25 – Criação da classe HibernateUtil

Figura 25 – Criação da classe HibernateUtil

O conteúdo da classe HibernateUtil será similar ao mostrado na Listagem 4 a seguir:

Listagem 4 – A classe HibernateUtil

package br.com.integrator.util;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class HibernateUtil {

private  static final SessionFactory sessionFactory;

static {

try {

sessionFactory = new Configuration().configure()

.buildSessionFactory();

} catch (Throwable ex) {

System.err.println("Initial SessionFactory creation failed." + ex);

throw new ExceptionInInitializerError(ex);

}

}

public static SessionFactory getSessionFactory() {

return sessionFactory;

}

}

A segunda classe que criaremos irá se chamar Main e será colocada no pacote br.com.integrator.

Figura 26 – Criação da classe Main

Figura 26 – Criação da classe Main

O conteúdo da classe Main é mostrado na Listagem 5 a seguir:

Listagem 5 – A classe Main

package br.com.integrator;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.Transaction;

import br.com.integrator.util.HibernateUtil;

public class Main {

public static void main(String[] args) {

Session session = HibernateUtil.getSessionFactory().openSession();

Transaction transaction = null;

try {

transaction = session.beginTransaction();

Categoria categoria1 = new Categoria();

categoria1.setCategoria("Informática");

categoria1.setDescricao("Produtos de Informática");

session.save(categoria1);

Categoria categoria2 = new Categoria();

categoria2.setCategoria("Eletrodomésticos");

categoria2.setDescricao("Eletrodomésticos em Geral");

session.save(categoria2);

Categoria categoria3 = new Categoria();

categoria3.setCategoria("Livraria");

categoria3.setDescricao("Livros para todos os gostos");

session.save(categoria3);

transaction.commit();

} catch (HibernateException e) {

transaction.rollback();

e.printStackTrace();

} finally {

session.close();

}

}

}

Executem a classe Main para que o Hibernate crie a tabela categoria e adicionem o conteúdo. Graças as configurações criadas no arquivo hibernate.cfg.xml, temos a saída na view Console como mostra a Figura 27.

Figura 27 – A saída no console criada na execução do exemplo

Figura 27 – A saída no console criada na execução do exemplo

O Editor HQL e Criteria

Para acessar o editor HQL do Hibernate Tools, cliquem com o direito do mouse em qualquer parte da view Hibernate Configurations e selecionem, no menu de contexto, o item HQL Editor.

Figura 28 – Chamando o editor HQL pelo menu de contexto na view Hibernate Configurations

Figura 28 – Chamando o editor HQL pelo menu de contexto na view Hibernate Configurations

No editor HQL, se digitarmos uma query HQL, veremos também na view Hibernate Dynamic SQL Preview a instrução SQL gerada automaticamente pelo Hibernate.

Figura 29 – Editor HQL em ação e a view Hibernate Dynamic SQL Preview exibindo a SQL gerada

Figura 29 – Editor HQL em ação e a view Hibernate Dynamic SQL Preview exibindo a SQL gerada

Ao mandarmos executar a query HQL, em Run HQL, vemos o resultado surgir na view Hibernate Query Result. Quando selecionamos este resultado, vemos os dados na view  Properties.

Figura 30 – Resultados encontrados na query HQL executada nas views Hibernate Query Result e Properties

Figura 30 – Resultados encontrados na query HQL executada nas views Hibernate Query Result e Properties

A parte de Criteria também é bem fácil de se criar. Cliquem com o direito do mouse sobre Session Factory>br.com.integrator.Categoria e selecionem, no menu de contexto, o item Hibernate Criteria Editor.

Figura 31 – Abrindo o editor de criteria

Figura 31 – Abrindo o editor de criteria

Ao surgir o editor de Criteria, basta completarmos a instrução que desejamos executar. Em seguida,  clicamos no botão Run criteria (o mesmo botão que no editor HQL se chama Run HQL).

Figura 32 – Criação do Hibernate Criteria no editor e seu resultado apos clicar em Run criteria

Figura 32 – Criação do Hibernate Criteria no editor e seu resultado apos clicar em Run criteria

Engenharia Reversa

A engenharia reversa no Hibernate Tools também é de fácil utilização.

Para trabalhar com a engenharia reversa, é necessário termos o arquivo de configuração do Hibernate, configurado para conectar-se ao banco de dados pré-existente.

A engenharia reversa está preparada para gerar as classes, os arquivos .hbm.xml ou então anotações. Também é possível termos anotações JPA, relacionamentos e outros.

Para criar a engenharia reversa em nosso exemplo, cliquem com o direito do mouse na view Package Explorer. No menu de contexto selecionem New>Hibernate Reverse Engineering File (reveng.xml).

Figura 33 – Opção Hibernate Reverse Engineering File (reveng.xml) do menu de contexto

Figura 33 – Opção Hibernate Reverse Engineering File (reveng.xml) do menu de contexto

Na caixa de diálogo, selecionem o diretório src e mantenham o nome do arquivo padrão solicitado. Cliquem no botão Next.

Figura 34 – Iniciando a criação do arquivo de configuração de engenharia reversa

Figura 34 – Iniciando a criação do arquivo de configuração de engenharia reversa

Na etapa seguinte, selecionem a configuração do console previamente criada em Console configuration. Cliquem no botão Refresh e selecionem no banco de dados a(s) tabela(s) que desejam trabalhar na engenharia reversa para utilizar com o Hibernate e confirmem no botão Include. Concluam o assistente no botão Finish.

Figura 35 – Seleção da tabela categoria para a engenharia reversa

Figura 35 – Seleção da tabela categoria para a engenharia reversa

O assistente irá gerar o arquivo de engenharia reversa. Agora iremos configurá-lo para que, na geração dos arquivos baseados na(s) tabela(s) do banco de dados, a conversão seja exatamente como desejamos.

Comecem indo na aba Type Mappings e cliquem no botão Refresh.

Figura 36 – Exibindo o banco de dados através do botão Refresh

Figura 36 – Exibindo o banco de dados através do botão Refresh

Na caixa de diálogo Select a console configuration, selecionem o console criado e confirmem no  botão OK.

Figura 37 – Seleção da configuração de console

Figura 37 – Seleção da configuração de console

Retornando para o editor, temos o banco de dados, tabela(s) e campo(s). Para que ocorra a engenharia reversa de forma correta, devemos Add cada um deles, editando o Hibernate Type, Length e também Not-Null.

Vejam  como é  mostrado na Figura 38.

Figura 38 – Configurando os tipos JDBC e  Hibernate da tabela para executar a engenharia reversa

Figura 38 – Configurando os tipos JDBC e Hibernate da tabela para executar a engenharia reversa

O resultado do arquivo configurado, visto na aba Source, em formato XML, é como o mostrado na Listagem 6.

Listagem 6 – O arquivo hibernate.revenge.xml

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

<!DOCTYPE hibernate-reverse-engineering PUBLIC "-//Hibernate/Hibernate Reverse Engineering DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-reverse-engineering-3.0.dtd" >

<hibernate-reverse-engineering>

<type-mapping>

<sql-type jdbc-type="BIGINT" hibernate-type="long"

not-null="true">

</sql-type>

<sql-type jdbc-type="VARCHAR" hibernate-type="string" length="50"

not-null="false">

</sql-type>

<sql-type jdbc-type="VARCHAR" hibernate-type="string"

not-null="false">

</sql-type>

</type-mapping>

<table-filter match-catalog="hibernatenapratica" match-name="categoria"/>

</hibernate-reverse-engineering>

Retornando a view Package Explorer, vamos configurar um console Hibernate para executar o arquivo de engenharia reversa criado. Cliquem com o direito do mouse sobre o arquivo hibernate.revenge.xml e selecionem, no menu de contexto, o item Hibernate Console Configuration.

Atenção: Esta etapa não é realmente necessária quando já existe um console configurado. Entretanto, na primeira vez que configuramos um, o acesso não havia sido feito desta maneira.
Figura 39 – Seleção do item Hibernate Console Configuration no menu de contexto

Figura 39 – Seleção do item Hibernate Console Configuration no menu de contexto

Na caixa de dialogo, alterem o campo Name para ProjUtilizandoHibernateToolsAnnotations. Verifiquem se Configuration file está corretamente apresentando o arquivo hibernate.cfg.xml.

Figura 40 – Diálogo de criação da configuração do console Hibernate para a engenharia reversa

Figura 40 – Diálogo de criação da configuração do console Hibernate para a engenharia reversa

Através do botão Run As , clicando no pequeno triângulo que aponta para baixo,  encontramos um menu onde temos o item Hibernate Code Generation Configurations.

Figura 41 – Menu Run As com a opção Hibernate Code Generation Configurations

Figura 41 – Menu Run As com a opção Hibernate Code Generation Configurations

Na caixa de diálogo Hibernate Code Generation Configurations, em Hibernate Code Generation, cliquem com o direito do mouse e selecionem, no menu de contexto, o item New.

Figura 42 – Acionando o menu de contexto em Hibernate Code Generation

Figura 42 – Acionando o menu de contexto em Hibernate Code Generation

Na lateral direita, tenham ProjUtilizandoHibernateToolsAnnotations em Console configuration selecionado. Em Output directory, cliquem em Browse e selecionem o local onde será(ão) gerada(s) a(s) classe(s), neste caso.

Digitem o pacote em Package e, em reveng.xml, cliquem em Setup.

Figura 43 – Configuração inicial da aba Main em Hibernate Code Generation Configurations

Figura 43 – Configuração inicial da aba Main em Hibernate Code Generation Configurations

Ao surgir o diálogo Setup reverse engineering, cliquem em Use existing.

Figura 44 – Selecionando o botão Use existing

Figura 44 – Selecionando o botão Use existing

Selecionem o item hibernate.reveng.xml e confirmem no botão OK.

Figura 45 – Seleção do arquivo hibernate.reveng.xml

Figura 45 – Seleção do arquivo hibernate.reveng.xml

Retornando ao diálogo Hibernate Code Generation Configurations, ainda na aba Main, temos todas as informações que desejamos preenchidas, como na Figura 46.

Figura 46 – Aba Main do diálogo Hibernate Code Generation Configurations preenchido

Figura 46 – Aba Main do diálogo Hibernate Code Generation Configurations preenchido

Agora iremos na aba Exporters, ao qual iremos marcar Generate EJB 3 annotations e Domain code (.java).

Figura 47 – Opções de exportação da caixa de diálogo Hibernate Code Generation Configurations

Figura 47 – Opções de exportação da caixa de diálogo Hibernate Code Generation Configurations

Por fim, vamos clicar no botão Run para executar a engenharia reversa.

Figura 48 – Executando a engenharia reversa através do botão Run

Figura 48 – Executando a engenharia reversa através do botão Run

Neste último exemplo, o resultado é a classe Categoria sendo criada com anotações.

Considerações finais

Como vocês puderam ver, o Hibernate Tools é uma ferramenta bem interessante para aqueles que trabalham com o framework Hibernate. Seja para criar suas configurações através dos assistentes, para executar as queries HQL ou Criteria em seus editores, vale a pena  instalar e conhecer este plugin do Eclipse IDE.

Até o próximo artigo pessoALL.

Tags: , , , ,


jun 04 2010

Ajax com JSF 2.0

Category: JSF 2.0Edson Gonçalves @ 8:28

Olá Pessoal, tudo bom? Como vão vocês?

Depois que fiz a publicação do artigo Ajax com JSF 1.2 utilizando JBoss RichFaces, alguns leitores me enviaram e-mail pedindo um exemplo com o JSF 2.0.

Então, atendendo aos pedidos, este artigo ensina como fazer o exemplo com JSF 1.2 utilizando o AJAX da biblioteca RichFaces, mas em JSF 2.0, sem adição de biblioteca AJAX.

Obtendo e instalando o Eclipse IDE

Para desenvolver este exemplo, utilizei a versão do Eclipse IDE 3.6, ainda em desenvolvimento, em um ambiente voltado para o trabalho com Java EE. Para obter o Eclipse IDE, já configurado com o ambiente Web, vá ao endereço http://www.eclipse.org/downloads/ e selecione a aba Developer Builds e clique em Eclipse IDE for Java EE Developers. Lembre-se de selecionar o seu sistema operacional.

Ao baixar, descompacte em um local desejado de sua máquina.

O Servidor Java

Para este artigo, vamos utilizar o Tomcat 7.0, ainda em desenvolvimento. Para baixar o binário do Tomcat 7, vá até o endereço  http://people.apache.org/~markt/dev/tomcat-7/v7.0.0-RC3/bin/. Antes de continuarmos, vale lembrá-los que este endereço pode mudar até a versão final e que, por ser uma versão de desenvolvimento, não deve ser utilizada em produção.

A versão que vamos baixar é a compactada. Por exemplo, se o seu Windows for de uma versão 64bits, baixe o arquivo apache-tomcat-7.0.0-RC3-windows-x64.zip.

Atenção: O Tomcat 7.0 roda somente na JDK 6 ou superior.

As bibliotecas

Para trabalhar com o JavaServer Faces 2.0, primeiramente será preciso configurar os arquivos e a estrutura necessária.

O contêiner Servlet Tomcat 7, por padrão, não possue suporte direto ao JavaServer Faces, ou seja, não contém as bibliotecas necessárias para o desenvolvimento com o mesmo.

Para baixar o JSF, faça download no endereço https://javaserverfaces.dev.java.net/. Ao baixar o arquivo, simplesmente descompacte em um diretório de sua escolha.

JavaServer Faces rodando em seu aplicativo Web

Para ter o JavaServer Faces 2.0 em sua aplicação, você possui dois arquivos do tipo JAR:

  1. jsf-api.jar
  2. jsf-impl.jar

As bibliotecas JSTL

Os arquivos JSTL estão no endereço  http://www.apache.org/dist/jakarta/taglibs/standard/binaries/, onde utilizaremos dois arquivos JARs:

  1. jstl.jar
  2. standard.jar

Criando o projeto

Clique no menu File>New>Dynamic Web Project. Na caixa de diálogo New Dynamic Web Project, digite ProjAjaxComJSF2 (ou o nome que desejar dar) em Project name. Clique no botão New Runtime e, na caixa de diálogo New Server Runtime Environment, expanda Apache e selecione Apache Tomcat v7.0. Clique no botão Next.

Figura 1 – Selecionando o Apache Tomcat 7

Figura 1 – Selecionando o Apache Tomcat 7

Na próxima etapa, selecione o diretório onde está localizado o seu Tomcat 7, clicando em Browse. Lembre-se da versão do JDK 6 para trabalhar com o Tomcat. Confirme no botão Finish.

Figura 2 – Definindo o local onde foi instalado o Tomcat 7

Figura 2 – Definindo o local onde foi instalado o Tomcat 7

Retornando a primeira etapa da criação do projeto, em Configuration, selecione JavaServer Faces v2.0 Project. Com suas definições completas, podemos prosseguir em Next.

Figura 3 – Definição inicial do projeto completa

Figura 3 – Definição inicial do projeto completa

Iremos executar o botão Next até a última etapa, ao qual definiremos as bibliotecas do projeto.

Na última etapa do assistente, deixe Type como User Library, caso não esteja.

Figura 4 – Definindo em biblioteca de usuário

Figura 4 – Definindo em biblioteca de usuário

Logo abaixo, na lateral direita, você encontra o ícone Manage libraries. Dê um clique nele.

Figura 5 – Seleção de Manage libraries

Figura 5 – Seleção de Manage libraries

Ao abrir a caixa de diálogo Preferences, verá que está filtrado direto no item User Libraries. Clique no botão New e, na caixa de diálogo New User Library digite JSF2 e confirme.

Figura 6 – Criando a biblioteca de usuário JSF2

Figura 6 – Criando a biblioteca de usuário JSF2

Retornando para Preferences, selecione JSF2 e clique no botão Add JARs. Selecione os JARs do JSF 2.0 que necessitamos para o projeto e confirme.

Faça o mesmo processo para criar uma nova biblioteca de usuário, mas a chame desta vez de JSTL. Adicione as bibliotecas JSTL a esta biblioteca de usuário. Confirme por fim a caixa de diálogo Preferences no botão OK.

Figura 7 – Bibliotecas de usuário JSF2 e JSTL criadas

Figura 7 – Bibliotecas de usuário JSF2 e JSTL criadas

Por fim, selecione as bibliotecas de usuário criadas, pois elas serão adicionadas ao projeto automaticamente. Confirme a criação do projeto no botão Finish.

Figura 8 – Finalizando a criação do projeto com a seleção das bibliotecas de usuário criadas

Figura 8 – Finalizando a criação do projeto com a seleção das bibliotecas de usuário criadas

Na finalização do projeto, o Eclipse lançará uma mensagem perguntando se desejamos mudar de perspectiva. Diga que sim, clicando em Yes. O Eclipse alterará de perspectiva, colocando na Java EE.

O  deployment descriptor

O assistente do projeto criou automaticamente o web.xml com suas respectivas configurações.

Criando o JavaBean Texto

Com o direito do mouse sobre o projeto, selecione New>Class no menu de contexto.

Na caixa de diálogo New Java Class, preencha o pacote (br.com.integrator) e o nome da classe, no caso Texto, em Name. Confirme no botão Finish.

Figura 9 – A classe Texto

Figura 9 – A classe Texto

Altere a classe Texto conforme mostrado na Listagem 1.

Listagem 1 – O JavaBean Texto

package br.com.integrator;

@ManagedBean(name="textoBean")

@RequestScoped

public class Texto {

private String texto;

public String getTexto() {

return texto;

}

public void setTexto(String texto) {

this.texto = texto;

}

}

Sem utilizar o arquivo faces-config.xml

Caso o leitor ainda não teve a oportunidade, recomendo ler o meu artigo JavaServer Faces 2.0 na Prática – Parte 2, que explica como funciona atualmente o JSF na versão 2.0.

Criando a página JSF com suporte ao AJAX

Com o direito do mouse sobre WebContent, vá no menu de contexto em New>HTML File. No diálogo New HTML File, dê o nome no arquivo de ajaxjsf.xhtml e prossiga no assistente clicando em Next

.

Figura 10 – Criando uma página JSF 2

Figura 10 – Criando uma página JSF 2

Na última etapa de criação da página, como não temos definido um Template que se encaixe na nossa necessidade de desenvolvimento da página, selecione o primeiro item da lista, no caso New Facelet Composition Page. Finalize no botão Finish.

Figura 11 – Seleção do template New Facelet Composition Page

Figura 11 – Seleção do template New Facelet Composition Page

Com a página ajaxjsf.xhtml criada e aberta no editor, altere-a deixando exatamente como mostrado na Listagem 2 a seguir: Listagem 2 – A página ajaxjsf.xhtml completa

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

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

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

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

<h:head><title>Ajax com JSF 2.0</title></h:head>

<h:body>

<h:form id="form1">

<h:outputScript name="jsf.js" library="javax.faces" target="head"/>

<h:inputText id="texto" value="#{textoBean.texto}">

<f:ajax event="keyup" execute="form1:texto" render="form1:resultado"/>

</h:inputText>

<br />

Resultado:

<strong>

<h:outputLabel id="resultado" value="#{textoBean.texto}" />

</strong>

</h:form>

</h:body>

</html>
Figura 12 – Página ajaxjsf.xhtml no editor visual Web Page Editor

Figura 12 – Página ajaxjsf.xhtml no editor visual Web Page Editor

Por fim, execute a página, já que o cursor e o foco estão nela, indo ao meu Run> Run As>Run on Server. Na caixa de diálogo, deixe o Tomcat como escolha para executar o projeto e clique no botão Next.

Figura 13 – Selecionando o servidor Java para executar o projeto

Figura 13 – Selecionando o servidor Java para executar o projeto

Adicione em Configured o projeto e clique no botão Finish. Neste momento o Apache Tomcat iniciará, executando a página JSF contendo o AJAX.

O aplicativo é de simples compreensão, como o criado no exemplo com JSF 1.2 e RichFaces. O texto digitado no campo de texto, é enviado ao servidor sem que seja submetido por um botão. Transportado ao Managed Bean textoBean, representado pela classe Texto, o valor enviado é retornado ao label abaixo, em Resultado. Como estamos usando AJAX, o texto vai sendo digitado e enviado a cada nova letra para o servidor e retornada à página sem um reload no browser.

Figura 14 – A página executada

Figura 14 – A página executada

Este envio ao servidor, sem reload na página, e o retorno é feito graças ao suporte ao AJAX do JSF 2.0, pela tag <f:ajax />:

<h:inputText id=“texto” value=“#{textoBean.texto}”>

<f:ajax event=“keyup” execute=“form1:texto” render=“form1:resultado”/>

</h:inputText>

Esta tag trabalha com o evento JavaScript onkeyup (que no caso deve ser keyup), que chama o servidor e renderiza o resultado onde o atributo render estiver apontando. Observe que esta tag está dentro da tag JSF <h:inputText/>, que é exatamente onde ela trabalhará para receber o evento e se comunicar com o servidor, transmitindo as informações nela contidas.

No próximo artigo

No próximo artigo veremos uma biblioteca AJAX compatível com JSF 2.0 e alguns recursos interessantes que ela pode nos oferecer.

Até o próximo artigo pessoALL.

Tags: , , , ,