// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Criando uma Aplicação Swing do Maven utilizando o Hibernate: Tutorial do NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Criando uma Aplicação Swing do Maven utilizando o Hibernate: Tutorial do NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Criando uma Aplicação Swing do Maven utilizando o Hibernate: Tutorial do NetBeans IDE

Neste tutorial, você utiliza o NetBeans IDE para criar uma aplicação Java Swing usando um arquétipo Maven. A aplicação usa o framework do Hibernate como camada de persistência para recuperar POJOs (objetos Java antigos e simples) de um banco de dados relacional. Este tutorial demonstra como os assistentes no IDE podem ajudar a criar os arquivos Hibernate necessários e adicionar dependências Hibernate no POM. Depois de criar objetos Java e configurar a aplicação usar o Hibernate, você cria uma interface GUI para a pesquisa e exibição dos dados.

O Suporte para Maven é totalmente integrado no Netbeans IDE; o Maven 3 está no mesmo pacote que o IDE. Você pode criar aplicações dos arquétipos Maven incorporados de arquétipos em repositórios remotos no assistente de Novo Projeto. O Browser de Repositório Maven permite explorar seus repositórios Maven locais e remotos, examinar artefatos e adicionar dependências de projeto ao POM do projeto.

Para construir esta aplicação utilizando o Ant, consulte link:hibernate-java-se.html[+Utilizando o Hibernate em um Aplicação Java Swing+].

Para construir uma aplicação Maven Java EE, consulte link:../javaee/maven-entapp.html[+Criando uma Aplicação Corporativa com o Maven+].


image::images/netbeans-stamp-80-74-73.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0"]


*Para seguir este tutorial, são necessários os recursos e o software a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|link:http://download.netbeans.org/[+NetBeans IDE+] |Pacote Java 7.2, 7.3, 7.4, 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 

|link:http://maven.apache.org/[+Maven+] |versão 2.09 ou posterior 

|link:http://www.mysql.com/[+Servidor de banco de dados MySQL+] |versão 5.x 

|Banco de Dados Sakila |plug-in disponível na central de atualização 
|===

Antes de começar este tutorial, talvez você queira se familiarizar com a documentação a seguir.

* Documentação do Hibernate em link:http://www.hibernate.org/[+hibernate.org+]
* Tutorial link:../ide/mysql.html[+Estabelecendo Conexão com um Banco de Dados MySQL+]

Você pode fazer download link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Maven.zip[+de um arquivo compactado zip do projeto finalizado+].


== Criando o Banco de Dados

Este tutorial usa um banco de dados MySQL chamado  ``sakila`` . O banco de dados de amostra não é incluído quando você instala o IDE, portanto você precisa criar o banco de dados primeiro para seguir este tutorial.

O banco de dados Sakila é um banco de dados MySQL de amostra disponível no site do MySQL. Para criar o banco de dados sakila, você pode fazer o download e instalar o plug-in Banco de Dados de Amostra do Sakila usando o Gerenciador de plug-ins. Depois de instalar o plug-in, você pode criar o banco de dados sakila da janela Serviços. O banco de dados sakila é adicionado à lista de bancos de dados na caixa de diálogo Criar banco de dados MySQL.

Para obter mais informações sobre a configuração do IDE para trabalhar com o MySQL, consulte o tutorial link:../ide/mysql.html[+Estabelecendo Conexão com um Banco de Dados MySQL+].

1. Abra o Gerenciador de plug-ins e instale o plug-in Banco de Dados de Amostra do Sakila.
2. Depois de instalar o plug-in, inicie o servidor do banco de dados MySQL ampliando o nó Banco de dados na janela Serviços, clicando com o botão direito do mouse no nó Servidor MySQL e escolhendo Iniciar.
3. Clique com o botão direito do mouse no nó Servidor MySQL e escolha Criar Banco de Dados.
4. Selecione o banco de dados Sakila na lista drop-down Novo Nome de Banco de Dados, na caixa de diálogo Criar Banco de Dados MySQL. Clique em OK.
image::images/create-sakila-mysql.png[title="Tela da caixa de diálogo Criar Banco de Dados MySQL"]

Quando você clica em OK, o IDE executa um script para criar o banco de dados Sakila e preencher as tabelas do banco de dados. Você pode ver o resultado da execução do script na janela de Saída. É adicionado também um nó para o banco de dados Sakila sob o nó do Servidor MySQL.

5. Clique com o botão direito do mouse no nó do Sakila e escolha Conectar.

Quando você clica em Conectar, um nó de conexão do banco de dados do banco de dados Sakila ( ``jdbc:mysql://localhost:3306/sakila [_nome de usuário_ em Default]`` ) será listado abaixo do nó Bancos de Dados. Quando uma conexão for aberta, você poderá exibir os dados no banco de dados ampliando o nó de conexão.


== Configurando o Maven

O Maven está integrado ao IDE e é instalado quando você instala o IDE. No entanto, se esse for seu primeiro projeto Maven, você precisará verificar as definições de configuração do Maven na janela Opções.

1. Abra a janela Opções no IDE (Ferramentas > Opções; NetBeans > Preferências no Mac).
2. Selecione a categoria Java na janela Opções e clique na guia Maven.
3. Confirme se um Início do Maven está especificado.

Você pode usar a versão do Maven incorporada no IDE ou especificar a localização de uma instalação local do Maven (requer versão 2.0.9 ou posterior).

4. Clique em OK para fechar a janela Opções.

*Observações.*

* O suporte a Maven será automaticamente ativado quando o Java estiver ativado no IDE. Você precisará ativar o plug-in Java EE, se não estiver ativado.
* Em netbeans IDE 7.1 e versões anteriores do IDE, a guia Maven na janela Opções está localizada na categoria Diversos.


=== Exibindo os Repositórios Maven

Os artefatos que são utilizados pelo Maven para construir todos os projetos são armazenados em seu repositório local Maven. Quando um artefato é declarado como uma dependência do projeto, o artefato é submetido a download para seu repositório local usando um dos repositórios remotos registrados.

Por default, diversos repositórios Maven indexados bem conhecidos são registrados e listados no browser do repositório. Os repositórios registrados contêm a maioria dos artefatos públicos necessários para que você construa seu projeto. Na maioria dos casos, não é necessário registrar nenhum repositório adicional, a não ser que seu projeto necessite de artefatos encontrados somente em um repositório privado.

Você pode explorar seus repositórios Maven locais e remotos e executar uma verificação imediata para atualizações na janela Serviços. Qualquer artefato que esteja em seus repositórios locais ou remotos podem ser adicionados como uma dependência do projeto. Você pode expandir o nó do repositório Local na janela Serviços para ver os artefatos que estão presentes localmente. Os artefatos listados abaixo dos nós do repositório remoto podem ser adicionados como dependências do projeto, mas nem todos eles estão localmente presentes. Eles são adicionados ao repositório Local somente quando são declarados como dependências do projeto.

Para procurar e atualizar os repositórios Maven execute as etapas a seguir.

1. Escolha Janela > Serviços para abrir a janela Serviços.
2. Expandir o nó Repositórios Maven na janela Serviços para exibir os repositórios.
3. Expanda um nó de repositório para exibir os artefatos.
4. Clique com o botão direito em um nó do repositório e escolha Atualizar Índice no menu pop-up para atualizar o repositório.
image::images/maven-repositories.png[title="Repositórios Maven na janela Serviços"]

Quando seu cursor está sobre um artefato, o IDE exibe uma dica de ferramenta com as coordenadas do artefato. Você pode clicar duas vezes em um arquivo JAR do artefato para exibir os detalhes adicionais sobre o artefato.

Você pode procurar um artefato clicando com o botão direito no nó Repositórios Maven na janela Serviços e escolhendo Localizar.

Para saber mais sobre como gerenciar as dependências de classpath Maven e sobre como trabalhar com repositórios Maven no IDE, consulte a seção link:http://wiki.netbeans.org/MavenBestPractices#section-MavenBestPractices-DependencyManagement[+Gerenciamento de Dependência+] em link:http://wiki.netbeans.org/MavenBestPractices[+Práticas Recomendadas para o Apache Maven no NetBeans IDE+].

*Observações para NetBeans IDE 7.1 e versões anteriores do IDE.*

* Escolha Janela > Outros > Browser dos Repositórios Maven para exibir repositórios Maven.
* Você pode usar os botões na barra de ferramentas do Browser dos Repositórios do Maven para atualizar os índices e procurar artefatos.


== Criando a Aplicação Maven

Neste tutorial você cria um projeto da aplicação Java Swing simples chamado DVDStoreAdmin. O projeto será criado de um dos arquétipos Maven incorporados e, em seguida, as definições default do projeto serão modificadas.


=== Escolhendo um Arquétipo

O assistente Novo Projeto permite que você crie um projeto Maven de um arquétipo Maven. O IDE inclui diversos arquétipos para projetos NetBeans comuns, mas também é possível localizar e escolher arquétipos em repositórios remotos no assistente.

1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal para abrir o assistente Novo Projeto.
2. Selecione Aplicação Java na categoria Maven. Clique em Próximo. 
image::images/maven-project-wizard.png[title="Arquétipos do Maven no assistente Novo Projeto"]
3. Insira *DVDStoreAdmin* como nome do projeto e defina a sua localização.
4. Modifique o ID de Grupo default e a Versão (opcional).

O ID de Grupo e a Versão serão utilizadas como as coordenadas para o artefato em seu repositório local quando o projeto for construído.

5. Clique em Finalizar.

Quando você clicar em Finalizar, o IDE criará o projeto Maven e abrirá o projeto na janela Projetos. O IDE cria automaticamente a classe  ``App.java``  no pacote  ``com.mycompany.dvdstoreadmin`` . É possível deletar o  ``App.java``  porque ele não é necessário para a aplicação.

*Observação.* Se esta for a primeira vez que você está criando um projeto Maven, o Maven precisará fazer download de alguns plug-ins e artefatos necessários para o repositório local. Isso pode levar algum tempo.


=== Modificando as Propriedades do Projeto

Quando você cria um projeto Maven utilizando o assistente, as propriedades default do projeto têm base no arquétipo. Em alguns casos, poderá ser necessário modificar as propriedades default de acordo com os requisitos de seu sistema e do projeto. Por exemplo, para este projeto, você deseja garantir que o nível do código-fonte seja definido como 1.5 ou uma versão mais recente porque o projeto utiliza anotações.

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.
2. Selecione a categoria Códigos-fonte na janela Propriedades.
3. Confirmar que o Formato de Código-fonte/Binário é selecionado na lista drop-down é 1.5 ou uma versão mais recente.
4. Selecione UTF-8 na lista drop-down para a propriedade Codificação. Clique em OK.


== Adicionando Arquivos e Dependências Hibernate

Para adicionar o suporte para Hibernate, é necessário tornar disponíveis as bibliotecas do Hibernate ao declarar os artefatos necessários como dependências no POM. O IDE inclui assistentes para ajudá-lo a criar os arquivos Hibernate necessários em seu projeto. É possível usar os assistentes no IDE para criar um arquivo de configuração Hibernate e uma classe de ajuda do utilitário. Se criar o arquivo de configuração Hibernate utilizando um assistente, o IDE atualiza automaticamente o POM e as dependências Hibernate para o projeto.

É possível adicionar dependências ao projeto na janela Propriedades ou ao editar diretamente o  ``pom.xml`` . Para adicionar uma dependência na janela Projetos, clique com o botão direito do mouse no nó Dependências na janela Projetos e escolha Adicionar Dependência no menu pop-up para abrir a caixa de diálogo Adicionar Dependência. Quando uma dependência é adicionada, o IDE atualiza o POM e faz download de quaisquer artefatos necessários para o repositório local, que ainda não estão localmente presentes.

Para editar diretamente o  ``pom.xml`` , abra o arquivo ao expandir o nó Arquivos do Projeto na janela Projetos e clique duas vezes em  ``pom.xml`` .


=== Criando o Arquivo de Configuração do Hibernate

O arquivo de configuração Hibernate ( ``hibernate.cfg.xml`` ) contém informações sobre a conexão do banco de dados, os mapeamentos de recursos e outras propriedades da conexão. Ao criar um arquivo de configuração Hibernate usando um assistente, você especifica a conexão do banco de dados de uma lista de conexões de bancos de dados registradas no IDE. Durante a geração do arquivo de configuração, o IDE adiciona automaticamente os detalhes da conexão e as informações de dialeto com base na conexão de banco de dados selecionada. O IDE também modifica automaticamente o POM para adicionar as dependências Hibernate necessárias. Depois de criar o arquivo de configuração, você pode editar o arquivo usando o editor de múltipla exibição, ou editar o XML diretamente no editor XML.

1. Clique com o botão direito do mouse na conexão ao banco de dados Sakila na janela Serviços e escolha Conectar.
2. Clique com o botão direito do mouse no nó Pacotes de Código-fonte na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo Arquivo.
3. Selecione o Assistente Configuração do Hibernate a partir da categoria Hibernate. Clique em Próximo.
4. Mantenha o nome default do arquivo ( ``hibernate.cfg`` ).
5. Clique em Procurar e especifique o diretório  ``src/main/resources``  como a Localização (se ainda não estiver especificada). Clique em Próximo.
6. Selecione a conexão sakila na lista drop-down Conexão do Banco de Dados. Clique em Finalizar.
image::images/hib-config.png[title="Caixa de diálogo para selecionar conexão de banco de dados"]

Quando você clicar em Finalizar o IDE abre  ``hibernate.cfg.xml``  no editor. O arquivo de configuração contém informações sobre um único banco de dados.

Se você expandir o nó Dependências na janela Projetos, é possível ver que o IDE adicionou os artefatos Hibernate necessários. O IDE lista todas as dependências diretas e transitivas necessárias para compilar o projeto no nó Dependências. Os artefatos que são dependências diretas (dependências que são especificadas no POM do projeto) são indicadas por ícones JAR coloridos. Um artefato é acinzentado se ele for uma dependência transitiva (um artefato que é uma dependência de uma ou mais dependências diretas).

image::images/maven-project-libs.png[title="Dependências no nó Bibliotecas na janela Projetos"]

É possível exibir os detalhes do artefato ao clicar com o botão direito do mouse em um JAR e ao escolher Exibir Detalhes do Artefato. O Visualizador de Artefato contém guias que fornecem detalhes sobre o artefato selecionado. Por exemplo, a guia Básico fornece detalhes sobre as coordenadas do artefato e as versões disponíveis. A guia Gráfico fornece uma representação visual das dependências do artefato selecionado.

image::images/maven-artifacts-viewer.png[title="A guia Gráficos ou o Visualizador do Artefato mostrando as dependências"]

Também é possível utilizar a guia Gráficos para descobrir e solucionar conflitos de versão entre dependências.


=== Modificando o Arquivo de Configuração do Hibernate

Neste exercício, você editará as propriedades default especificadas em  ``hibernate.cfg.xml``  para ativar o log de depuração para instruções SQL. Este exercício é opcional.

1. Abra  ``hibernate.cfg.xml``  na guia Desenho. Você pode abrir o arquivo expandindo o nó Arquivos de Configuração na janela Projetos e clicando duas vezes em  ``hibernate.cfg.xml`` .
2. Expanda o nó Propriedades da Configuração em Propriedades Opcionais.
3. Clique em Adicionar para abrir a caixa de diálogo Adicionar Propriedade do Hibernate.
4. Na caixa de diálogo, selecione a propriedade  ``hibernate.show_sql``  e defina o valor para  ``true`` . Clique em OK. Isso ativa o log de depuração das instruções SQL.
image::images/add-property-showsql.png[title="Caixa de diálogo Adicionar Propriedade Hibernate que mostra o valor de definição de hibernate.show_sql"]
5. Clique em Adicionar no nó Propriedades Diversas e selecione  ``hibernate.query.factory_class``  na lista drop-down Nome da Propriedade.
6. Digite *org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory* no campo de texto. Clique em OK.

*Observação.* Não selecione o valor na lista drop-down.

image::images/add-property-factoryclass-4.png[title="Caixa de diálogo Adicionar Propriedade Hibernate que mostra o valor de definição de hibernate.query.factory_class"]

Se clicar na guia XML no editor, você pode ver o arquivo na view XML. O arquivo deve ter uma aparência semelhante a esta:


[source,xml]
----

<hibernate-configuration>
    <session-factory name="session1">
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/sakila</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">######</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.query.factory_class">org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory</property>
    </session-factory>
</hibernate-configuration>
----
7. Salve as alterações feitas no arquivo.

Quando você executar seu projeto, poderá visualizar a consulta SQL impressa na janela de Saída do IDE.


=== Criando o Arquivo de Ajuda  ``HibernateUtil.java`` 

Para usar o Hibernate, é necessário criar uma classe de ajuda que lide com a inicialização e que acesse o  ``SessionFactory``  do Hibernate para obter um objeto de Sessão. A classe chama o método  ``configure()``  do Hibernate, carrega o arquivo de configuração  ``hibernate.cfg.xml``  e, em seguida, constrói o  ``SessionFactory``  para obter o objeto de Sessão.

Nesta seção, você usa o assistente para Novo Arquivo a fim de criar a classe helper  ``HibernateUtil.java`` .

1. Clique com o botão direito do mouse no nó dos Pacote de Códigos-fonte e selecione Novo > Outro para abrir o assistente para Novo Arquivo.
2. Selecione Hibernate na lista Categorias e HibernateUtil.java na lista Tipos de Arquivo. Clique em Próximo.
3. Insira *HibernateUtil* como nome da classe e *sakila.util* como nome do pacote. Clique em Finalizar.
image::images/maven-hibutil-wizard.png[title="Assistente Util. Hibernate"]

Quando você clicar em Finalizar, o  ``HibernateUtil.java``  será aberto no editor. Você pode fechar o arquivo porque não precisa editá-lo.


== Gerando Arquivos de Mapeamento Hibernate e Classes Java

Neste tutorial você usa um POJO (objeto Java antigo e simples), o  ``Actor.java`` , para representar os dados na tabela ACTOR do banco de dados. A classe especifica os campos para as colunas nas tabelas e usa setters e getters simples para recuperar e gravar dados. Para mapear o  ``Actor.java``  para a tabela ACTOR, você pode usar um arquivo de mapeamento do Hibernate ou usar anotações na classe.

Você pode usar o assistente Engenharia Reversa e os Arquivos de Mapeamento do Hibernate e POJOs obtidos de um assistente de banco de dados para criar múltiplos POJOs e arquivos de mapeamento com base nas tabelas selecionadas do banco de dados. Como alternativa, você pode usar assistentes no IDE para ajudar a criar POJOs individuais e arquivos de mapeamento a partir do rascunho.

*Observação.* Ao criar arquivos para múltiplas tabelas, você provavelmente desejará usar os assistentes. Neste tutorial, você só precisa criar um POJO e um arquivo de mapeamento, portanto, é muito mais fácil criar os arquivos individualmente. Você pode consultar as etapas para a <<10,criação dos POJOs e arquivos de mapeamento individualmente>> no final deste tutorial.


=== Criar Arquivo de Engenharia Reversa

Para utilizar os POJOs e os Arquivos de Mapeamento do Assistente do Banco de Dados, primeiro é preciso criar o arquivo de engenharia reversa  ``reveng.xml``  no diretório  ``src/main/resources`` , onde foi criado o  ``hibernate.cfg.xml`` .

1. Clique com o botão direito do mouse no nó dos Pacote de Códigos-fonte e selecione Novo > Outro para abrir o assistente para Novo Arquivo.
2. Selecione Hibernate na lista Categorias e o assistente Engenharia Reversa do Hibernate a partir da lista Tipos de Arquivos. Clique em Próximo.
3. Digite *hibernate.reveng* como o nome do arquivo.
4. Especifique * ``src/main/resources`` * como a Localização. Clique em Próximo.
5. Selecione *actor* no painel Tabelas Disponíveis e clique em Adicionar. Clique em Finalizar.

O assistente gera um arquivo de engenharia reversa  ``hibernate.reveng.xml`` . Você pode fechar o arquivo de engenharia reversa porque não precisará editar o arquivo.

*Observação.* Este projeto requer uma biblioteca jar do conector MySQL ( ``mysql-connector-jar-5.1.13.jar`` , por exemplo). Se um JAR adequado não estiver listado como dependência do projeto no nó Dependências, é possível adicionar a dependência clicando com o botão direito do mouse no nó Dependências e escolhendo Adicionar Dependência.


=== Criando Arquivos de Mapeamento Hibernate e POJOs de um Banco de Dados

Os Arquivos de Mapeamento do Hibernate e os POJOs obtidos de um Assistente de Banco de Dados geram arquivos com base em tabelas em um banco de dados. Quando você usa o assistente, o IDE gera POJOs e os arquivos de mapeamento com base nas tabelas do banco de dados especificadas em  ``hibernate.reveng.xml``  e, a seguir, adiciona as entradas do mapeamento no  ``hibernate.cfg.xml`` . Quando usa o assistente, você pode escolher os arquivos que deseja que o IDE gere (somente os POJOs, por exemplo) e selecionar as opções de geração de código (gerar código que use anotações EJB 3, por exemplo).

1. Clique com o botão direito do mouse no nó Pacotes de Código-fonte na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo Arquivo.
2. Selecione Arquivos de Mapeamento do Hibernate e POJOs provenientes de um Banco de Dados na categoria Hibernate. Clique em Próximo.
3. Selecione  ``hibernate.cfg.xml``  na lista drop-down Arquivo de Configuração Hibernate, caso não esteja selecionado.
4. Selecione  ``hibernate.reveng.xml``  na lista drop-down Arquivo de Engenharia Reversa Hibernate, caso não esteja selecionado.
5. Certifique-se de que as opções *Código do Domínio* e *Mapeamentos XML do Hibernate* estejam selecionadas.
6. Insira *sakila.entity* para o nome do Pacote. Clique em Finalizar.
image::images/mapping-pojos-wizard.png[title="Gerar assistente Arquivos de Mapeamento Hibernar e POJOs"]

Quando você clica em Finalizar, o IDE gera o POJO  ``Actor.java``  com todos os campos necessários no diretório  ``src/main/java/sakila/entity`` . O IDE também gera o arquivo de mapeamento do Hibernate no diretório  ``src/main/resources/sakila/entity``  e, em seguida, adiciona a entrada do mapeamento em  ``hibernate.cfg.xml`` .

Agora que você tem o POJO e os arquivos necessários relacionados ao Hibernate, poderá criar um front-end simples de GUI Java para a aplicação. Você também poderá criar e adicionar uma consulta HQL que pesquise o banco de dados para recuperar os dados. Nesse processo, também usamos o editor HQL para construir e testar a consulta.


== Criando a GUI da Aplicação

Neste exercício, você criará um form JFrame simples com alguns campos para a entrada e exibição de dados. Você também adicionará um botão que irá disparar uma consulta do banco de dados para recuperar os dados.

Se você não estiver familiarizado com o uso do GUI Builder para criar forms, talvez queira examinar o tutorial link:gui-functionality.html[+Introdução à Construção de GUIs+].


=== Criando o Form JFrame

1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo Arquivo.
2. Selecione Form JFrame na categoria Forms de GUI Swing. Clique em Próximo.
3. Digite *DVDStoreAdmin* como Nome da Classe e insira *sakila.ui* como Pacote. Clique em Finalizar.

Quando você clica em Finalizar, o IDE cria a classe e abre o form JFrame na view Design do editor.


=== Adicionando Elementos ao Form

Agora você precisa adicionar os elementos de UI ao form. Quando o form estiver aberto na view Design do editor, a paleta será mostrada no lado direito do IDE. Para adicionar um elemento ao form, arraste o elemento da Paleta para a área do form. Depois de adicionar um elemento ao form, será necessário modificar o valor default da propriedade Nome da variável desse elemento.

1. Arraste um elemento Label da Paleta e altere o texto para *ActorProfile*.
2. Arraste um elemento Label da Paleta e altere o texto para *First Name*.
3. Arraste um elemento Campo de Texto perto do label Nome e delete o texto default.

Quando o texto default for deletado, o campo de texto é será contraído. É possível redimensionar o campo de texto em outro momento ao ajustar o alinhamento dos elementos do form.

4. Arraste um elemento Label da Paleta e altere o texto para *Sobrenome*.
5. Arraste um elemento Campo de texto para perto do label Sobrenome e delete o texto default.
6. Arraste um elemento de Botão da Paleta e altere o texto para *Consulta*.
7. Arraste um elemento Tabela da Paleta para dentro do form.
8. Modifique os valores do Nome da Variável dos seguintes elementos da UI de acordo com os valores na tabela a seguir.

Você pode modificar o valor do Nome da Variável de um elemento clicando com o botão direito do mouse no elemento na view Design e, em seguida, escolhendo Alterar Nome da Variável. De modo alternativo, você pode alterar o Nome da Variável diretamente na janela Inspetor.

Você não precisa designar os valores do Nome da Variável aos elementos do Label.

|===
|Elemento |Nome da Variável 

|Campo de texto Nome | ``firstNameTextField``  

|campo de texto Sobrenome | ``lastNameTextField``  

|Botão Consulta | ``queryButton``  

|Tabela | ``resultTable``  
|===
9. Redimensione os campos de texto e alinhe os elementos do form.

É possível ativar a propriedade Redimensionável na Horizontal dos campos de texto para garantir que os campos de texto sejam redimensionados com a janela e que o espaçamento entre os elementos permaneçam constantes.

10. Salve as alterações.

Na view Design, seu form deve parecer com a imagem a seguir.

image::images/hib-jframe-form.png[title="Form GUI na View Design do editor"]

Agora que você tem um form, precisa criar o código para designar eventos aos elementos do form. No próximo exercício, você construirá consultas com base na Linguagem de Consulta Hibernate para recuperar dados. Depois de construir as consultas, você adicionará métodos ao form para chamar a consulta apropriada quando o botão Consulta for pressionado.


== Criando a consulta no Editor de Consultas HQL

No IDE, você pode construir e testar consultas com base no Idioma de consulta do Hibernate (HQL) usando o Editor de Consultas HQL. À medida que você insere a consulta, o editor mostra a consulta SQL equivalente (traduzida). Quando você clicar no botão "Executar Consulta HQL" na barra de ferramentas, o IDE executará a consulta e mostrará os resultados na parte inferior do editor.

Neste exercício, o Editor HQL é utilizado para construir consultas HQL simples que recuperam uma lista de detalhes de atores com base na correspondência do nome ou sobrenome. Antes de adicionar a consulta à classe, você utilizará o Editor de Consulta HQL para testar se a conexão está funcionando corretamente e se a consulta produz os resultados desejados. Antes de executar a pesquisa, é preciso compilar a aplicação.

1. Clique com o botão direito do mouse no nó do projeto e escolha Construir.

Quando você clica em Compilar, o IDE submete a download os artefatos necessários para seu repositório Maven local.

2. Expanda o nó do pacote de código-fonte  ``<pacote default>``  sob o nó Outros Códigos-fonte na janela Projetos.
3. Clique com o botão direito do mouse em  ``hibernate.cfg.xml``  e escolha Executar Consulta HQL para abrir o Editor HQL.
4. Teste a conexão inserindo  ``from Actor``  no Editor de Consultas HQL. Clique no botão Executar Consulta HQL ( image::images/run_hql_query_16.png[title="Botão Executar Consulta HQL"] ) na barra de ferramentas.

Quando você clicar em Executar Consulta HQL, deverá visualizar os resultados da consulta no painel inferior do Editor de Consultas HQL.

image::images/hib-query-hqlresults.png[title="Hql Editor de Consulta mostrando resultados da consulta HQL"]
5. Digite a consulta a seguir no Editor de Consultas HQL e clique em Executar consulta HQL para verificar os resultados da consulta quando a string de pesquisa for "PE".

[source,java]
----

from Actor a where a.firstName like 'PE%'
----

A consulta retorna uma lista de detalhes de atores para aos atores cujos nomes começam com "PE".

Ao clicar no botão SQL acima dos resultados, você deverá ver a seguinte consulta SQL equivalente.


[source,java]
----

select actor0_.actor_id as col_0_0_ from sakila.actor actor0_ where (actor0_.first_name like 'PE%' )
----
6. Abra uma nova guia do Editor de Consulta HQL e insira a consulta a seguir no painel do editor. Clique em Executar Consulta HQL.

[source,java]
----

from Actor a where a.lastName like 'MO%'
----

A consulta retorna uma lista de detalhes de atores para os atores cujos sobrenomes começam com "MO".

Testar as consultas mostra que as elas retornam os resultados desejados. A próxima etapa é implementar as consultas na aplicação de modo que a consulta apropriada seja chamada clicando-se no botão Consulta no form.


== Adicionando a Consulta ao Form

Agora você precisa modificar o  ``DVDStoreAdmin.java``  para adicionar as strings de consulta e criar os métodos para construir e chamar uma consulta que incorpore as variáveis de entrada. Você também precisa modificar o handler de eventos do botão para chamar a consulta correta e adicionar um método para exibir os resultados da consulta na tabela.

1. Abra  ``DVDStoreAdmin.java``  e clique na guia Código-fonte.
2. Adicione as seguintes strings de consulta (em negrito) à classe.

[source,java]
----

public DVDStoreAdmin() {
    initComponents();
}

*private static String QUERY_BASED_ON_FIRST_NAME="from Actor a where a.firstName like '";
private static String QUERY_BASED_ON_LAST_NAME="from Actor a where a.lastName like '";*
----

É possível copiar as consultas das guias do Editor de Consulta HQL para o campo e, em seguida, modificar o código.

3. Adicione os métodos a seguir para criar a consulta com base na string de entrada do usuário.

[source,java]
----

private void runQueryBasedOnFirstName() {
    executeHQLQuery(QUERY_BASED_ON_FIRST_NAME + firstNameTextField.getText() + "%'");
}
    
private void runQueryBasedOnLastName() {
    executeHQLQuery(QUERY_BASED_ON_LAST_NAME + lastNameTextField.getText() + "%'");
}
----

Esses métodos chamam o método  ``executeHQLQuery()``  e cria a consulta combinando a string de consulta com o usuário que inseriu a string de pesquisa.

4. Adicione o método  ``executeHQLQuery()`` .

[source,java]
----

private void executeHQLQuery(String hql) {
    try {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        Query q = session.createQuery(hql);
        List resultList = q.list();
        displayResult(resultList);
        session.getTransaction().commit();
    } catch (HibernateException he) {
        he.printStackTrace();
    }
}
----

O método  ``executeHQLQuery()``  chama o Hibernate para executar a consulta selecionada. Esse método usa a classe de utilitário  ``HibernateUtil.java``  para obter a Sessão Hibernate.

5. Corrija suas importações e adicione instruções para as bibliotecas Hibernate ( ``org.hibernate.Query`` ,  ``org.hibernate.Session`` ) e  ``java.util.List`` .
6. Crie um handler de eventos do botão Consulta alternando para a view Design e clicando duas vezes no botão Consulta.

O IDE cria o método  ``queryButtonActionPerformed``  e exibe o método na view Código-fonte.

7. Modifique o método  ``queryButtonActionPerformed``  na view Código-fonte adicionando o código a seguir de modo que uma consulta seja executada quando o usuário clicar no botão.

[source,java]
----

private void queryButtonActionPerformed(java.awt.event.ActionEvent evt) {
    *if(!firstNameTextField.getText().trim().equals("")) {
        runQueryBasedOnFirstName();
    } else if(!lastNameTextField.getText().trim().equals("")) {
        runQueryBasedOnLastName();
    }*
}
----
8. Adicione o método a seguir para exibir os resultados na JTable.

[source,java]
----

private void displayResult(List resultList) {
    Vector<String> tableHeaders = new Vector<String>();
    Vector tableData = new Vector();
    tableHeaders.add("ActorId"); 
    tableHeaders.add("FirstName");
    tableHeaders.add("LastName");
    tableHeaders.add("LastUpdated");

    for(Object o : resultList) {
        Actor actor = (Actor)o;
        Vector<Object> oneRow = new Vector<Object>();
        oneRow.add(actor.getActorId());
        oneRow.add(actor.getFirstName());
        oneRow.add(actor.getLastName());
        oneRow.add(actor.getLastUpdate());
        tableData.add(oneRow);
    }
    resultTable.setModel(new DefaultTableModel(tableData, tableHeaders));
}
----
9. Corrija as importações (Ctrl+Shift+I) para adicionar o  ``java.util.Vector``  e salve as alterações.

Depois de salvar o form, você pode executar o projeto.


== Executando um Projeto Maven

Agora que a codificação foi finalizada, é possível construir o projeto e iniciar a aplicação. Quando um projeto Maven é construído no IDE, o Maven lê o POM do projeto para identificar as dependências do projeto. Todos os artefatos especificados como dependências precisam estar em seu repositório local do Maven para que o projeto possa ser construído. Se um artefato necessário não estiver no repositório local, o Maven fará check-out do artefato do repositório remoto antes de tentar construir e executar o projeto. Após construir o projeto, o Maven instalará o binário resultante como um artefato em seu repositório local.

*Observações.*

* Construir e executar um projeto pela primeira vez pode levar algum tempo se o IDE precisar fazer check-out de dependências do projeto. As construções subsequentes serão muito mais rápidas.
* Para executar esta aplicação, primeiro é preciso especificar a Classe Principal.

Para compilar e iniciar esta aplicação, execute as tarefas a seguir.

1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades.
2. Selecione a categoria Executar, na caixa de diálogo Propriedades do Projeto.
3. Insira *sakila.ui.DVDStoreAdmin* como a Classe Principal. Clique em OK.

De modo alternativo, você pode clicar no botão Procurar e escolher a classe principal na caixa de diálogo.

image::images/browse-main-class.png[title="Definindo a Classe Principal na caixa de diálogo Procurar Classes Principais"]
4. Clique em Executar Projeto principal na barra de ferramentas principal para iniciar a aplicação.

Quando a ação Executar é chamada em um projeto Maven no IDE, o IDE executa os objetivos Maven associados com a ação Executar. O IDE possui objetivos default vinculados às ações do IDE de acordo com o pacote do projeto. É possível exibir os objetivos vinculados à ação Executar no painel Ações da janela Propriedades do projeto

image::images/maven-projectproperties.png[title="Painel ações da janela propriedades do projeto DVDStoreAdmin"]

É possível personalizar a vinculação de objetivos às ações no painel Ações da janela Propriedades do projeto.

O form GUI é aberto quando você inicia a aplicação. Insira uma string de pesquisa no campo de texto Nome ou Sobrenome e clique em Consulta para pesquisar um ator e exibir os detalhes.

image::images/application-run.png[title="Aplicação Dvdstoreadmin mostrando os resultados"]

Se você observar a janela de Saída do IDE, poderá visualizar a consulta SQL que recuperou os resultados exibidos.


=== Fazendo Download do Projeto da Solução

Você pode fazer o download da solução para este projeto como um projeto das seguintes formas.

* Faça download link:https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Maven.zip[+de um arquivo compactado zip do projeto finalizado+].
* Faça o check-out do código-fonte do projeto das Amostras do NetBeans ao executar as etapas a seguir:
1. Escolha Equipe > Subversion > Efetuar check-out no menu principal.
2. Na caixa de diálogo Efetuar Check-out, insira o Repositório URL a seguir:
 ``https://svn.netbeans.org/svn/samples~samples-source-code`` 
Clique em Próximo.
3. Clique em Procurar para abrir a caixa de diálogo Procurar nas Pastas do Repositório:
4. Expanda o nó-raiz e selecione *samples/java/DVDStoreAdmin-Maven*. Clique em OK.
5. Especifique a Pasta Local para o códigos-fonte (a pasta local precisa estar vazia).
6. Clique em Finalizar.

Quando você clica em Finalizar, o IDE inicializa a pasta local como um repositório Subversion e verifica os códigos-fonte do projeto.

7. Clique em Abrir Projeto na caixa de diálogo exibida quando o check-out for concluído.

*Observações.*

* As etapas de check-out de códigos-fonte a partir do Kenai se aplicam somente ao NetBeans IDE 6.7 e 6.8.
* É necessário um cliente Subversion para fazer check-out dos códigos-fonte a partir do Kenai. Para saber mais sobre a instalação do Subversion, consulte a seção link:../ide/subversion.html#settingUp[+Configurando o Subversion+] no link:../ide/subversion.html[+Guia do Subversion no NetBeans IDE+].


== Criando POJOs e Arquivos de Mapeamento Individualmente

Como um POJO é uma classe Java simples, você pode usar o assistente Nova Classe Java para criar a classe e, em seguida, editar a classe no editor de código-fonte para adicionar os campos, getters e setters necessários. Depois de criar o POJO, use um assistente para criar um arquivo de mapeamento do Hibernate para associar a classe à tabela e adicionar informações de mapeamento ao  ``hibernate.cfg.xml`` . Quando você cria um arquivo de mapeamento a partir do rascunho, é necessário mapear os campos às colunas no editor XML.

*Observação.* Esse exercício é opcional e descreve como criar o arquivo de mapeamento e POJO que você criou com o assistente Hibernar Arquivos de Mapeamento e POJOs do Banco de Dados.

1. Clique com o botão direito do mouse no nó Pacotes de Códigos-fonte na janela Projetos e escolha Novo > Classe Java para abrir o assistente Nova Classe Java.
2. No assistente, insira *Ator* para o nome da classe e *sakila.entity* para o pacote. Clique em Finalizar.
3. Faça as seguintes alterações (exibidas em negrito) nas classes para implementar a interface serializável e adicionar campos nas colunas da tabela.

[source,java]
----

public class Actor *implements Serializable* {
    *private Short actorId;
    private String firstName;
    private String lastName;
    private Date lastUpdate;*
}
----
4. Gere os getters e setters para os campos colocando o cursor de inserção no editor de código-fonte, digitando Alt-Insert e, em seguida, selecionando Getter e Setter.
5. Na caixa de diálogo Gerar Getters e Setters, selecione todos os campos e clique em Gerar.
image::images/getters-setters.png[title="Caixa de diálogo Gerar Getters e Setters"]

Na caixa de diálogo Gerar Getters e Setters, você pode usar a seta para cima no teclado para mover o item selecionado para o nó Ator e pressionar a barra de espaços para selecionar todos os campos em Ator.

6. Corrija as importações e salve as alterações.

Depois de criar o POJO para a tabela, você desejará criar um arquivo de mapeamento do Hibernate para  ``Actor.java`` .

1. Clique com o botão direito do mouse no nó de pacotes de código-fonte  ``sakila.entity`` , na janela Projetos, e escolha Novo > Outro para abrir o assistente Novo Arquivo.
2. Selecione o assistente Mapeamento do Hibernate na categoria Hibernate. Clique em Próximo.
3. Digite *Actor.hbm* como o Nome do Arquivo e defina a pasta como *src/main/resources/sakila/entity*. Clique em Próximo.
4. Digite *sakila.entity.Actor* para a Classe a ser Mapeada.
5. Selecione *actor* na lista drop-down Tabela do Banco de Dados, se não estiver selecionado. Clique em Finalizar.
image::images/mapping-wizard.png[title="Assistente Gerar Arquivos de Mapeamento de Hibernação"]

Quando você clicar em Finalizar, o arquivo de mapeamento do Hibernate  ``Actor.hbm.xml``  será aberto no editor de código-fonte. O IDE também adiciona automaticamente uma entrada para o recurso de mapeamento para  ``hibernate.cfg.xml`` . Você pode exibir os detalhes da entrada ampliando o nó Mapeamento, na view Design do  ``hibernate.cfg.xml``  ou na view XML. A entrada  ``mapeamento``  na view XML será semelhante a:


[source,xml]
----

        <mapping resource="sakila/entity/Actor.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
----
6. Associe os campos  ``Actor.java``  às colunas na tabela ACTOR fazendo as seguintes alterações (em negrito) no  ``Actor.hbm.xml`` .

[source,xml]
----

<hibernate-mapping>
  <class name="sakila.entity.Actor" *table="actor">
    <id name="actorId" type="java.lang.Short">
      <column name="actor_id"/>
      <generator class="identity"/>
    </id>
    <property name="firstName" type="string">
      <column length="45" name="first_name" not-null="true"/>
    </property>
    <property name="lastName" type="string">
      <column length="45" name="last_name" not-null="true"/>
    </property>
    <property name="lastUpdate" type="timestamp">
      <column length="19" name="last_update" not-null="true"/>
    </property>
  </class>*
</hibernate-mapping>
----

Você pode usar a funcionalidade autocompletar código no editor para completar os valores ao modificar o arquivo de mapeamento.

*Observação: *Por default, o elemento  ``class``  gerado tem uma tag de fechamento. Como você precisa adicionar elementos de propriedade entre as tags de abertura e fechamento do elemento  ``class`` , é necessário fazer as alterações a seguir (exibidas em negrito). Depois de fazer as alterações, você poderá usar a funcionalidade autocompletar código entre as tags  ``class`` .


[source,xml]
----

<hibernate-mapping>
  <class name="sakila.entity.Actor" *table="actor">
  </class>*
</hibernate-mapping>
----
7. Clique no botão Validar XML na barra de ferramentas e salve as alterações.

A criação de POJOs individuais e arquivos de mapeamento do Hibernate pode ser um modo conveniente de personalizar ainda mais sua aplicação.

link:/about/contact_form.html?to=3&subject=Feedback:%20Creating%20a%20Maven%20Project[+Enviar Feedback neste Tutorial+]


== Consulte Também

Para obter informações adicionais sobre a criação de aplicações GUI do Swing, consulte os tutoriais a seguir.

* link:quickstart-gui.html[+Projetando uma GUI Swing no NetBeans IDE+]
* link:gui-functionality.html[+Introdução à Construção de GUIs+]
* link:../../trails/matisse.html[+Trilha de Aprendizado das Aplicações de GUI do Java+]