// 
//     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.
//

= Gerando uma Aplicação CRUD JavaServer Faces 2.x Usando um Banco de Dados
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Gerando uma Aplicação CRUD JavaServer Faces 2.x Usando um Banco de Dados - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Gerando uma Aplicação CRUD JavaServer Faces 2.x Usando um Banco de Dados

Neste tutorial, você utilizará o NetBeans IDE para criar uma aplicação Web que interaja com um banco de dados de backend. A aplicação oferece a capacidade de exibir e modificar os dados contidos no banco de dados, conhecida como recurso _CRUD_ (Create, Read, Update, Delete). A aplicação que você desenvolverá contará com as seguintes tecnologias.

* *JavaServer Faces (JSF) 2.x* para páginas Web de frontend, manipulação de validação e gerenciamento do ciclo de solicitação-resposta.
* *Java Persistence API (JPA) 2.0* utilizando EclipseLink para gerar classes de entidade a partir do banco de dados e gerenciar transações. (EclipseLink é a implementação de referência para JPA e é o provedor de persistência default para o GlassFish Server.)
* *Enterprise JavaBeans (EJB) 3.1*, que oferece EJBs sem estado que acessam as classes de entidade e contém a lógica de negócios da aplicação.

O IDE oferece dois assistentes que geram todos os códigos da aplicação. O primeiro é o <<generateEntity,assistente para Classes de Entidade do Banco de Dados>> que permite gerar as classes de entidade a partir do banco de dados fornecido. Após criar as classes de entidade, você utiliza o <<jsfPagesEntityClasses,assistente de Páginas JSF de Classes de Entidade>> para criar EJBs e beans gerenciados pelo JSF para as classes de entidade, bem como um conjunto de páginas de Facelets para manipular as views dos dados da classe de entidade. A seção final do tutorial, <<explore,Explorando a Aplicação>>, é opcional e oferece vários exercícios para ajudá-lo a entender melhor a aplicação e a se familiarizar mais com o IDE.

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 concluir este tutorial, você precisa dos seguintes recursos e softwares.

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

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Pacote Java EE 7.2, 7.3, 7.4, 8.0 

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

|link:http://glassfish.dev.java.net/[+GlassFish Server Open Source Edition+] |3.x, 4.x 

|link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fmysql-consult.zip[+mysql-consult.zip+] (MySQL) 
_ou_
link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fjavadb-consult.zip[+javadb-consult.zip+] (JavaDB) |n/d 
|===

*Observações:*

* O pacote Java EE do NetBeans IDE também inclui o GlassFish Server, um servidor compatível com Java EE necessário para este tutorial.
* Para o projeto de solução deste tutorial, faça o download de link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252FConsultingAgencyJSF20.zip[+ConsultingAgencyJSF20.zip+].


[[createDB]]
== Criando o Banco de Dados

Este tutorial utiliza um banco de dados de agência de consultoria chamado `consult`. O banco de dados não é incluído quando você instala o IDE, portanto, é necessário criar primeiro o banco de dados para seguir este tutorial.

O banco de dados `consult` foi projetado para demonstrar o escopo do suporte do IDE para manipular uma variedade de estruturas de banco de dados. Portanto, o banco de dados não é um exemplo de melhores práticas ou design de banco de dados recomendado. Em vez disso, ele tenta incorporar muitas funcionalidades relevantes encontradas em um design de banco de dados. Por exemplo, o banco de dados `consult` contém todos os tipos de relacionamento possíveis, chaves primárias compostas e muitos tipos de dados diferentes. Consulte as tabelas abaixo para obter uma visão geral mais detalhada da estrutura do banco de dados.

*Observações:*

* Este tutorial utiliza o servidor de banco de dados MySQL, mas também é possível concluí-lo utilizando o servidor do banco de dados JavaDB. Para criar o banco de dados no JavaDB, faça download e extraia o arquivo compactado link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fjavadb-consult.zip[+javadb-consult.zip+]. O arquivo compactado contém scripts SQL para criar, eliminar e preencher o banco de dados de `consult`.
* 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+].
* Para obter mais informações sobre como configurar o IDE para trabalhar com JavaDB, consulte o tutorial link:../ide/java-db.html[+Trabalhando com o Banco de Dados Java DB (Derby)+].

*Combinação MySQL com GlassFish:*

Se você estiver usando o MySQL, e estiver usando o GlassFish v3 ou Open Source Edition 3.0.1, será preciso garantir que seu banco de dados esteja protegido por senha. (Para obter mais informações, consulte GlassFish link:https://java.net/jira/browse/GLASSFISH-12221[+Edição 12221+].) Se você estiver utilizando a conta MySQL `root` sem senha, você poderá definir a senha usando um prompt de linha de comandos. 

Por exemplo, para definir a senha para `_nbuser_`, digite os comandos a seguir no prompt de linha de comandos.


[source,java]
----

shell> mysql -u root
mysql> UPDATE mysql.user SET Password = PASSWORD('_nbuser_') WHERE User = 'root';
mysql> FLUSH PRIVILEGES;
----

Se você receber um erro '`mysql: command not found`', será porque o comando `mysql` não foi adicionado à sua variável de ambiente `PATH`. É possível chamar o comando inserindo o caminho completo para o diretório `bin` da instalação do MySQL. Por exemplo, se o comando `mysql` estiver localizado no seu computador em `/usr/local/mysql/bin`, digite o seguinte:


[source,java]
----

shell> /usr/local/mysql/bin/mysql -u root
----

Para obter mais informações, consulte o Manual de Referência oficial do MySQL:

* link:http://dev.mysql.com/doc/refman/5.1/en/default-privileges.html[+Proteção das Contas MySQL Iniciais+]
* link:http://dev.mysql.com/doc/refman/5.1/en/invoking-programs.html[+4.2.1. Chamando Programas MySQL+]
* link:http://dev.mysql.com/doc/refman/5.1/en/setting-environment-variables.html[+4.2.4. Configurando Variáveis de Ambiente+]


Execute as etapas a seguir para criar um banco de dados e conecte-o a partir do IDE.

1. Faça download de link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJavaEE%252Fmysql-consult.zip[+mysql-consult.zip+] e o extraia o arquivo compactado no seu sistema local. Quando você extrair o arquivo compactado, você verá os scripts SQL para criação e preenchimento do banco de dados. O arquivo compactado também tem scripts para eliminação de tabelas.
2. Na janela Serviços, expanda o nó Bancos de Dados, clique com o botão direito do mouse no nó MySQL e selecione Iniciar Servidor.
3. Clique com o botão direito do mouse no nó Servidor MySQL e escolha Criar Banco de Dados.
4. Digite *consult* como o Nome do Banco de Dados na caixa de diálogo Criar Banco de Dados MySQL. Clique em OK. Um novo nó aparecerá sob o nó Bancos de Dados (`jdbc:mysql://localhost:3306/consult [raiz no esquema Default]`).
5. Clique com o botão direito do mouse no novo nó e selecione Conectar.
6. Selecione Arquivo > Abrir Arquivo, no menu principal e vá até o arquivo extraído `mysql_create_consult.sql`. Clique em Abrir. O arquivo abre automaticamente no editor SQL.
image::images/run-sql-script.png[title="Abrir arquivos SQL no editor do IDE"]
7. Certifique-se de que o banco de dados `consult` esteja selecionado na lista drop-down Conexão da barra de ferramentas do editor SQL. Em seguida, clique no botão ( image::images/run-sql-btn.png[] ) Executar SQL.

Quando você clica em Executar SQL, a saída a seguir é exibida na janela de Saída.

image::images/run-sql-output.png[title="A janela de Saída oferece informações sobre a execução SQL"]


[[examineDB]]
== Examinando a Estrutura do Banco de Dados

Para confirmar se as tabelas foram criadas corretamente, expanda o nó Tabelas sob o nó da conexão do banco de dados. Você pode expandir um nó da tabela para ver suas colunas, índices e chaves estrangeiras. É possível clicar com o botão direito do mouse em uma coluna e selecionar Propriedades para exibir informações adicionais sobre a coluna.

image::images/services-window-tables.png[title="A janela Serviços exibe conexões de bancos de dados, tabelas, colunas de tabelas, índices e chaves estrangeiras"]

*Observação:* Se você não vir nenhuma tabela sob o nó Tabelas, clique com o botão direito do mouse no nó Tabelas e selecione Atualizar.

Ao observar a estrutura do banco de dados `consult`, você pode ver que o banco de dados contém tabelas que possuem uma variedade de relacionamentos e vários tipos de campo. Quando você cria classes de entidade de um banco de dados, o IDE gera automaticamente o código apropriado para os vários tipos de campo.

image::images/diagram_consult.png[title="Diagrama de relacionamento com entidades do banco de dados consult"]

A tabela a seguir descreve as tabelas encontradas no banco de dados `consult`.

|===
|Tabela de Banco de Dados |Descrição |Funcionalidades de Design 

|CLIENT |Um cliente da agência de consultoria |Chave primária composta, não gerada (cujos campos não constituem uma chave estrangeira) 

|CONSULTANT |Um funcionário da agência de consultoria que os clientes podem contratar |Inclui um campo de retomada do tipo LONG VARCHAR 

|CONSULTANT_STATUS |O status de um consultor na agência de consultoria (por exemplo, Ativo e Inativo são status possíveis) |Chave primária não gerada do tipo CHAR 

|RECRUITER |Um funcionário da agência de consultoria responsável por conectar clientes e consultores |  

|PROJECT |Um projeto cuja equipe é formada pelos consultores da agência de consultoria |Chave primária composta, não gerada que inclui dois campos que constituem uma chave estrangeira para a tabela CLIENT 

|BILLABLE |Um conjunto de horas trabalhadas por um consultor em um projeto, o qual a agência de consultoria cobra do cliente relevante |Inclui um campo de artefato do tipo CLOB 

|ADDRESS |O endereço de cobrança de um cliente |  

|PROJECT_CONSULTANT |Tabela com junção indicando a quais projetos os consultores estão designados no momento |Faz referência cruzada entre PROJECT e CONSULTANT, a primeira possui uma chave primária composta 
|===


O banco de dados `consult` inclui uma variedade de relacionamentos. Quando você cria classes de entidade de um banco de dados, o IDE gera automaticamente as propriedades do tipo Java apropriado com base no tipo SQL das colunas. A tabela a seguir descreve os relacionamentos de entidade do banco de dados `consult`. (os relacionamentos inversos não são mostrados.)

|===
|Entidade |Entidade Relacionada |Informações sobre Relacionamento |Descrição 

|CLIENT |RECRUITER |pode ser nulo, um para um com edição manual; pode ser nulo, um para muitos, caso não seja editado |CLIENT possui muitos RECRUITERs e RECRUITER não possui nenhum ou um CLIENT (se não for manualmente editado) 

|CLIENT |ADDRESS |não pode ser nulo, um para um |CLIENT possui um ADDRESS e ADDRESS não possui nenhum ou um CLIENT 

|CLIENT |PROJECT |não pode ser nulo, um para muitos; em uma entidade de Projeto, o valor do campo do cliente faz parte da chave primária do Projeto |CLIENT tem muitos PROJECTS e PROJECT tem um CLIENT 

|CONSULTANT |PROJECT |muitos para muitos |CONSULTANT tem muitos PROJECTs e PROJECT tem muitos CONSULTANTs 

|CONSULTANT |BILLABLE |não pode ser nulo, um para muitos |CONSULTANT possui muitos BILLABLEs e BILLABLE possui um CONSULTANT 

|CONSULTANT_STATUS |CONSULTANT |não pode ser nulo, um para muitos |CONSULTANT_STATUS possui muitos CONSULTANTs e CONSULTANT possui um CONSULTANT_STATUS 

|CONSULTANT |RECRUITER |pode ser nulo, um para muitos |CONSULTANT não possui nenhum ou um RECRUITER e RECRUITER possui muitos CONSULTANTs 

|BILLABLE |PROJECT |não pode ser nulo, um para muitos |BILLABLE possui um PROJECT e PROJECT possui muitos BILLABLES 
|===

Agora que o banco de dados está criado, você pode criar a aplicação Web e utilizar o assistente de Classes de Entidade do Banco de Dados para gerar bancos de dados com base nas tabelas do banco de dados.


[[createProject]]
== Criando o Projeto de Aplicação Web

Neste exercício, você criará um projeto Web e adicionará o framework JavaServer Faces ao projeto. Ao criar o projeto, você irá selecionar JavaServer Faces no painel Frameworks do assistente de Novo Projeto.

1. Escolha Arquivo > Novo Projeto (Ctrl-Shift-N; &amp;#8984-Shift-N no Mac) no menu principal.
2. Na categoria Java Web, selecione Aplicação Web. Clique em Próximo.
3. Digite `ConsultingAgency ` para o nome do projeto e defina a localização do projeto. Clique em Próximo.
4. Defina o servidor como GlassFish Server e defina a versão do Java EE para Java EE 6 Web ou Java EE 7 Web. Clique em Próximo.
5. No painel Frameworks, selecione a opção JavaServer Faces. Clique em Finalizar.

Quando você clicar em Finalizar, o IDE irá gerar o projeto de aplicação Web e abrir `index.xhtml` no editor.


[[generateEntity]]
== Gerando as Classes de Entidade do Banco de Dados

Depois de se conectar a um banco de dados do IDE, você pode utilizar o assistente de Classes de Entidade do Banco de Dados para gerar rapidamente classes de entidade com base nas tabelas do banco de dados. O IDE pode gerar classes de entidade para cada tabela selecionada, e também pode gerar classes de entidade necessárias para tabelas relacionadas.

1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto ` ConsultingAgency` e selecione Novo > Classes de Entidade do Banco de Dados. (Se esta opção não estiver na lista, escolha Outros. Em seguida, no assistente de Arquivo, selecione a categoria Persistência e, depois, Classes de Entidade do Banco de Dados.)
2. Selecione Nova Fonte de Dados na lista drop-down Fonte de Dados para abrir a caixa de diálogo Criar Fonte de Dados.
3. Digite `jdbc/consult` como o Nome da JNDI e selecione a conexão `jdbc:mysql://localhost:3306/consult` como a Conexão do Banco de Dados. 
image::images/create-datasource.png[title="Especificar um nome e uma conexão de banco de dados JNDI para criar uma fonte de dados"]
4. Clique em OK para fechar a caixa de diálogo e retornar ao assistente. As tabelas no banco de dados `consult` serão exibidas na lista de conteúdo Tabelas Disponíveis.
5. Clique no botão Adicionar Tudo para selecionar todas as tabelas contidas no banco de dados. Clique em Próximo. 
image::images/new-entities-wizard.png[]
6. Digite `jpa.entities` como o nome do Pacote.
7. Verifique se as caixas de seleção para gerar as consultas nomeadas e criar uma unidade persistente estão marcadas. Clique em Finalizar.

Quando você clicar em Finalizar, o IDE gerará as classes de entidade no pacote `jpa.entities` do projeto.

Quando você utiliza o assistente para criar classes de entidade de um banco de dados, o IDE examina os relacionamentos entre as tabelas do banco de dados. Na janela Projetos, se você expandir o nó do pacote `jpa.entities`, você verá que o IDE gerou uma classe de entidade para cada tabela, exceto para a tabela `PROJECT_CONSULTANT`. O IDE não criou uma classe de entidade para `PROJECT_CONSULTANT` porque a tabela é uma tabela com junção.

image::images/projects-window-entities.png[title="Tela da janela Projetos mostrando as classes de entidades geradas"]

O IDE também gerou duas classes adicionais para as tabelas com chaves primárias compostas: `CLIENT` e `PROJECT`. As classes de chave primária dessas tabelas (`ClientPK.java` e `ProjectPK.java`) têm as letras `PK` acrescentadas ao nome.

Se você observar o código gerado para as classes de entidade, você verá que o assistente adicionou anotações `@GeneratedValue` aos campos ID gerados automaticamente e anotações `@Basic(optional = "false")` a alguns dos campos das classes de entidade. Com base nas anotações `@Basic(optional = "false")`, o assistente de Páginas JSF de Classes de Entidade pode gerar o código que inclui verificações para evitar violações de coluna que não podem ser nulas para esses campos.


[[jsfPagesEntityClasses]]
== Gerando Páginas JSF de Classes de Entidade

Agora que as classes de entidade estão criadas, você pode criar a interface Web para exibir e modificar os dados. Você utilizará o assistente de Páginas JSF de Classes de Entidade para gerar páginas JavaServer Faces. O código gerado pelo assistente baseia-se nas anotações de persistência contidas nas classes de entidade.

Para cada classe de entidade o assistente gera os seguintes arquivos:

* um bean de sessão sem estado que estende  ``AbstractFacade.java`` 
* um bean gerenciado com escopo de sessão JSF
* um diretório contendo quatro arquivos de Facelets para os recursos CRUD (`Create.xhtml`, `Edit.xhtml`, `List.xhtml` e `View.xhtml`)

O assistente também gera os seguintes arquivos.

* a classe  ``AbstractFacade.java``  que contém a lógica de negócio para criação, recuperação, modificação e remoção das instâncias da entidade
* classes de utilitário utilizadas pelos beans gerenciados pelo JSF (`JsfUtil`, `PaginationHelper`)
* um conjunto de propriedades para mensagens localizadas e uma entrada correspondente no arquivo de configuração Faces do projeto (será criado um arquivo `faces-config.xml`, caso já não exista um).
* arquivos web auxiliares, incluindo uma folha de estilo default para componentes renderizados e um arquivo de modelo de Facelets

Para gerar as páginas JSF:

1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Novo > Páginas JSF de Classes de Entidade para abrir o assistente. (Se esta opção não estiver na lista, escolha Outros. Em seguida, no assistente de Arquivo, selecione a categoria JavaServer Faces e, depois, Páginas JSF de Classes de Entidade.)

A caixa Classes de Entidade Disponíveis lista as sete classes de entidade contidas no projeto. A caixa não lista as classes incorporadas (`ClientPK.java` e `ProjectPK.java`).

2. Clique em Adicionar Tudo para mover todas as classes para a caixa Classes de Entidade Selecionadas. 
image::images/newjsf-wizard.png[title="O assistente de Novas Páginas JSF de Classes de Entidade exibe todas as classes de entidade contidas no projeto"] 
Clique em Próximo.
3. Na etapa 3 do assistente, Gerar Classes e Páginas JSF, digite `jpa.session` no Pacote de Bean de Sessão JPA.
4. Digite `jsf` para o Pacote de Classes JSF.
5. Digite '`/resources/Bundle`' no campo Nome do Pacote de Localização. Isso gerará um pacote com o nome `resources` no qual o arquivo `Bundle.properties` residirá. (Se deixá-lo em branco, o conjunto de propriedades será criado no pacote default do projeto.)
image::images/newjsf-wizard2.png[title="Especificar pacote e nomes de pastas para os arquivos gerados"]

Para que o IDE se ajuste melhor às convenções do projeto, você pode personalizar os arquivos gerados pelo assistente. Clique no link Personalizar Modelo para modificar os modelos de arquivo utilizados pelo assistente. 
image::images/customize-template.png[title="Personalizar modelos de arquivos gerados pelo assistente"] 
Em geral, você pode acessar e fazer alterações em todos os modelos mantidos pelo IDE utilizando o Gerenciador de Modelos (Ferramentas > Modelos).

6. Clique em Finalizar. O IDE gera os beans de sessão sem estado no pacote `jpa.session`, e o escopo de sessão e beans gerenciados com JSF no pacote `jsf`. Cada bean de sessão sem estado manipula as operações da classe de entidade correspondente, incluindo a criação, edição e destruição de instâncias da classe de entidade por meio da API de Persistência Java. Cada Bean gerenciado pelo JSF implementa a interface `javax.faces.convert.Converter` e realiza as tarefas de conversão das instâncias da classe de entidade correspondente para objetos `String` e vice-versa.

Se você expandir o nó Páginas Web, você poderá ver que o IDE gerou uma pasta para cada uma das classes de entidade. Cada pasta contém os arquivos `Create.xhtml`, `Edit.xhtml`, `List.xhtml` e `View.xhtml`. O IDE também modificou o arquivo `index.xhtml` inserindo links em cada uma das páginas `List.xhtml`.

image::images/projects-jsfpages.png[title="Páginas de Facelets para cada classe de entidade são geradas pelo assistente"]

Cada Bean gerenciado pelo JSF é específico dos quatro arquivos de Facelets correspondentes e inclui o código que chama os métodos no Bean de sessão apropriado.

Expanda o nó da pasta `resources` para localizar a folha de estilo `jsfcrud.css` default gerada pelo assistente. Se você abrir a página de boas-vindas da aplicação (`index.xhtml`) ou o arquivo de modelo de Facelets (`template.xhtml`) no editor, verá que eles contêm uma referência à folha de estilo.


[source,java]
----

<h:outputStylesheet name="css/jsfcrud.css"/>
----

O arquivo de modelo de Facelets é utilizado por cada um dos quatro arquivos de Facelets para cada classe de entidade.

Se você expandir o nó Pacotes de Código-Fonte, você verá os Beans de sessão, os Beans gerenciados pelo JSF, as classes de utilitário e o conjunto de propriedades gerados pelo assistente.

image::images/projects-generated-classes70.png[title="Tela do diretório de Pacotes de Código-Fonte na janela Projetos mostrando as classes geradas pelo assistente"]

O assistente também gerou o arquivo de Configuração do Faces (`faces-config.xml`) a fim de registrar a localização do conjunto de propriedades. Se expandir o nó Arquivos de Configuração e abrir `faces-config.xml` no editor XML, você verá que a entrada a seguir está incluída.


[source,xml]
----

<application>
    <resource-bundle>
        <base-name>/resources/Bundle</base-name>
        <var>bundle</var>
    </resource-bundle>
</application>
----

Além disso, se expandir o novo pacote `resources`, você encontrará o arquivo `Bundle.properties` que contém mensagens no idioma default do cliente. As mensagens são obtidas das propriedades da classe de entidade.

Para adicionar um novo conjunto de propriedades, clique com o botão direito do mouse no arquivo `Bundle.properties` e selecione Personalizar. A caixa de diálogo Personalizador permite adicionar novas configurações regionais à aplicação.


[[explore]]
== Explorando a Aplicação

Agora que seu projeto contém classes de entidade, Beans de sessão EJB para controlar as classes de entidade e um frontend desenvolvido para JSF para exibir e modificar bancos de dados, tente executar o projeto para ver os resultados.

A seguir, encontra-se uma série opcional de exercícios rápidos que ajudará você a se familiarizar com a aplicação, bem como com os recursos e as funcionalidades que o IDE oferece.

* <<completedProject,Examinando o Projeto Concluído>>
* <<populateDB,Preenchendo o Banco de Dados com um Script SQL>>
* <<editorSupport,Explorando o Suporte do Editor em Páginas de Facelets>>
* <<dbIntegrity,Explorando a Integridade do Banco de Dados com Validação de Campo>>
* <<editEntity,Editando as Classes de Entidade>>


[[completedProject]]
=== Examinando o Projeto Concluído

1. Para executar o projeto, clique com o botão direito do mouse no nó do projeto, na janela Projetos, e selecione Executar ou clique no botão ( image::images/run-project-btn.png[] ) Executar Projeto na barra de ferramentas principal.

Quando a página de boas-vindas da aplicação é exibida, aparece uma lista de links que permite exibir as entradas contidas em cada uma das tabelas do banco de dados.

image::images/welcome-page-links.png[title="Links para exibição do conteúdo do banco de dados para cada tabela"]

Os links foram adicionados à página de boas-vindas (`index.xhtml`) ao concluir o assistente de Páginas JSF de Classes de Entidade. Esses links são fornecidos como pontos de entrada nas páginas de Facelets que oferecem a funcionalidade CRUD no banco de dados da Agência de Consultoria.


[source,xml]
----

<h:body>
    Hello from Facelets
    <h:form>
        <h:commandLink action="/address/List" value="Show All Address Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/billable/List" value="Show All Billable Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/client/List" value="Show All Client Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/consultant/List" value="Show All Consultant Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/consultantStatus/List" value="Show All ConsultantStatus Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/project/List" value="Show All Project Items"/>
    </h:form>
    <h:form>
        <h:commandLink action="/recruiter/List" value="Show All Recruiter Items"/>
    </h:form>
</h:body>
----
2. Clique no link '`Mostrar todos os Itens do Consultor`'. Ao observar o código acima, você pode ver que a página de destino é `/consultant/List.xhtml`. (No JSF 2.x, a extensão do arquivo é deduzida devido à navegação implícita.) 
image::images/empty-consultants-list.png[title="A tabela Consultores está vazia no momento"] 
Atualmente, o banco de dados não contém dados de amostra. É possível adicionar dados manualmente clicando no link '`Criar Novo Consultor`' e utilizando o Web form fornecido. A página `/consultant/Create.xhtml` é carregada para que seja exibida. Você também pode executar um script SQL no IDE para preencher as tabelas com os dados de amostra. As subseções a seguir exploram ambas as opções.

Você pode clicar no link do índice para voltar à lista de links da página de boas-vindas. Os links oferecem uma view dos dados contidos em cada tabela do banco de dados e carrega o arquivo `List.xhtml` de cada pasta de entidade para que seja exibido. Conforme será demonstrado posteriormente, após adicionar os dados às tabelas, outros links serão exibidos em cada entrada permitindo que você exiba (`View.xhtml`), edite (`Edit.xhmtl`) e destrua os dados de um único registro da tabela.

*Observação.* Se a implantação da aplicação falhar, consulte a <<troubleshooting,seção de solução de problemas>> a seguir. (Consulte também a seção de solução de problemas de link:mysql-webapp.html#troubleshoot[+Criando uma Aplicação Web Simples Usando um Banco de Dados MySQL+].)


[[populateDB]]
=== Preenchendo o Banco de Dados com um Script SQL

Execute o script fornecido, que gera dados de amostra para as tabelas do banco de dados. O script (`mysql_insert_data_consult.sql`) está incluído no arquivo ZIP Consultando o Banco de Dados da Agência que pode ser obtido por download da <<requiredSoftware,tabela de software exigido>>.

Dependendo do servidor de banco de dados com que estiver trabalhando (MySQL ou JavaDB), você poderá executar o script fornecido, que irá gerar dados de amostra para as tabelas de banco de dados. Para o MySQL, esse é o script `mysql_insert_data_consult.sql`. Para o JavaDB, esse é o script `javadb_insert_data_consult.sql`. Ambos os scripts são incluídos nos respectivos arquivos compactados, que podem ser obtidos por download na <<requiredSoftware,tabela de software exigido>>.

1. Selecione Arquivo > Abrir Arquivo no menu principal e, em seguida, vá até o local do script no seu computador. Clique em Abrir. O arquivo é aberto automaticamente no editor SQL do IDE.
2. Certifique-se de que o banco de dados `consult` esteja selecionado na lista drop-down Conexão da barra de ferramentas do editor SQL.
image::images/run-sql-insert.png[title="Abrir o script no editor SQL do IDE"]

Clique com o botão direito do mouse no editor e selecione Executar Instrução ou clique no botão ( image::images/run-sql-btn.png[] ) Executar SQL. É possível ver o resultado da execução do script na janela de Saída.

3. Reinicie o GlassFish Server. Essa é uma etapa necessária para ativar o servidor e recarregar e armazenar no cache os novos dados contidos no banco de dados `consult`. Para isso, clique na guia do GlassFish Server na janela de Saída (A guia do GlassFish Server exibirá o log do servidor.), em seguida, clique no botão ( image::images/glassfish-restart.png[] ) Reiniciar Servidor na margem esquerda. O servidor para e, em seguida, reinicia.
4. Execute o projeto novamente e clique no link '`Mostrar Todos os Itens do Consultor`'. Você verá que a lista não está mais vazia.
[.feature]
--
image:images/consultants-list-small.png[role="left", link="images/consultants-list.png"]
--


=== Suporte ao Banco de Dados NetBeans

É possível utilizar o visualizador de tabelas do banco de dados do IDE para exibir e modificar os dados da tabela mantidos diretamente no banco de dados. Por exemplo, clique com o botão direito do mouse na tabela `consultant` na janela Serviços e selecione Exibir Dados.

image::images/view-data.png[title="Selecione Exibir Dados no menu contextual das tabelas de banco de dados"]

A consulta SQL utilizada para executar a ação é exibida na parte superior do editor e uma exibição gráfica da tabela é exibida abaixo.

[.feature]
--
image::images/view-data-table-small.png[role="left", link="images/view-data-table.png"]
--

Clique duas vezes nas células da tabela para efetuar modificações diretamente nos dados. Clique no ícone ( image::images/commit-records-icon.png[] ) Confirmar Registros para confirmar as alterações feitas no banco de dados.

A view gráfica oferece mais funcionalidade. Consulte link:../../docs/ide/database-improvements-screencast.html[+Suporte ao Banco de Dados no NetBeans IDE+] para obter mais informações.


[[editorSupport]]
=== Explorando o Suporte do Editor em Páginas de Facelets

1. Abra a página `/consultant/List.xhtml` no editor. A linha 8 indica que a página depende do arquivo de Facelets `template.xhtml` para que ser renderizada.

[source,java]
----

<ui:composition template="/template.xhtml">
----

Para exibir os números das linhas, clique com o botão direito do mouse na margem esquerda do editor e selecione Mostrar Números de Linhas.

2. Utilize a caixa de diálogo Ir para Arquivo do IDE para abrir o arquivo `template.xhtml`. Pressione Alt-Shift-O (Ctrl-Shift-O no Mac) e, em seguida, digite `modelo`.
image::images/go-to-file.png[title="Utilizar a caixa de diálogo Ir para Arquivo para abrir rapidamente arquivos do projeto"]

Clique em OK (ou pressione Enter).

3. O modelo aplica as tags `<ui:insert>` para inserir o conteúdo de outros arquivos no título e corpo. Coloque o cursor na tag `<ui:insert>` e pressione Ctrl-Espaço para chamar uma janela pop-up de documentação.
image::images/doc-popup.png[title="Pressione Ctrl-Espaço para chamar um pop-up de documentação nas tags de Facelets"]

É possível pressionar Ctrl-Espaço nas tags JSF e seus atributos para chamar o pop-up da documentação. A documentação exibida é obtida das descrições fornecidas na link:http://javaserverfaces.java.net/nonav/docs/2.1/vdldocs/facelets/index.html[+Documentação da Biblioteca de Tags JSF+] Oficial.

4. Volte para o arquivo `List.xhtml` (pressione Ctrl-Tab). As tags `<ui:define>` são utilizadas para definir o conteúdo que será aplicado ao título e ao corpo do modelo. Esse padrão é utilizado nos quatro arquivos de Facelets (`Create.xhtml`, `Edit.xhtml`, `List.xhtml` e `View.xhtml`) gerados para cada classe de entidade.
5. Coloque seu cursor em qualquer uma das expressões EL utilizadas nas mensagens localizadas contidas no arquivo `Bundle.properties`. Pressione Ctrl-Espaço para exibir a mensagem localizada. 
[.feature]
--
image:images/localized-messages-small.png[role="left", link="images/localized-messages.png"]
--

Na imagem acima, você pode ver que a expressão EL é determinada como '`List`', que é aplicada ao título do modelo e pode ser verificada na página renderizada no browser.

6. Navegue até a parte inferior do arquivo e localize o código do link `Criar novo consultor` (Linha 92). Trata-se do seguinte:

[source,java]
----

<h:commandLink action="#{consultantController.prepareCreate}" value="#{bundle.ListConsultantCreateLink}"/>
----
7. Pressione Ctrl-Espaço no atributo `action` do `commandLink` para chamar a janela pop-up da documentação. 

O atributo `ação` indica o método que manipula a solicitação quando o link é clicado no browser. A documentação a seguir será fornecida: 

_MethodExpression, que representa a ação da aplicação a qual será chamada quando este componente for ativado pelo usuário. A expressão deve ser interpretada como um método público que não toma nenhum parâmetro e retorna um Object (o toString() do qual é chamado para gerar o resultado lógico) que será passado para o NavigationHandler desta aplicação._
Em outras palavras, o valor de `action` se refere normalmente a um método em um bean gerenciado pelo JSF que é avaliado como uma `String`. Então, a string é utilizada pelo `NavigationHandler` do JSF para encaminhar a solicitação para a view apropriada. É possível verificar isso nas etapas a seguir.
8. Coloque o cursor no `consultantController` e pressione Ctrl-Espaço. A funcionalidade autocompletar código do editor indica que `consultantController` é um Bean gerenciado pelo JSF.
image::images/code-completion-managed-bean.png[title="A funcionalidade autocompletar código é fornecida para Beans gerenciados pelo JSF"]
9. Mova o cursor para `prepareCreate` e pressione Ctrl-Espaço. A funcionalidade autocompletar código lista os métodos contidos no Bean gerenciado `ConsultantController`.
image::images/code-completion-properties.png[title="A funcionalidade autocompletar código é fornecida para métodos de classe"]
10. Pressione Ctrl (&amp;#8984 no Mac) e, em seguida mova o mouse sobre `prepareCreate`. É formado um link, que permite ir diretamente para o método `prepareCreate()` no Bean gerenciado `ConsultantController`.
image::images/editor-navigation.png[title="Utilizar a navegação do editor para ir rapidamente até o código-fonte"]
11. Clique no link e exiba o método `prepareCreate()` (exibido a seguir).

[source,java]
----

public String prepareCreate() {
    current = new Consultant();
    selectedItemIndex = -1;
    return "Create";
}
----
O método retornará `Create`. O `NavigationHandler` coleta informações em segundo plano e aplica a string `Create` ao caminho que indica a view enviada em resposta à solicitação: `/consultant/*Create*.xhtml`. (No JSF 2.x, a extensão do arquivo é deduzida devido à navegação implícita.)


[[dbIntegrity]]
=== Explorando a Integridade do Banco de Dados com Validação de Campo

1. Na <<consultantsList,página Lista de Consultores>> do browser, clique no link '`Criar Novo Consultor`'. Conforme demonstrado na subseção anterior, isso carrega a página `/consultant/Create.xhtml` para que seja renderizada.
2. Informe os detalhes a seguir no form: Temporariamente, deixe os campos `RecruiterId` e `StatusId` em branco.

|===
|Campo |Valor 

|ConsultantId |2 

|Email |jack.smart@jsfcrudconsultants.com 

|Password |jack.smart 

|HourlyRate |75 

|BillableHourlyRate |110 

|HireDate |22/07/2008 

|Retomar |Sou um ótimo consultor. Contrate-me - Você não vai se arrepender! 

|RecruiterId |--- 

|StatusId |--- 
|===
3. Clique em Salvar. Quando você fizer isso, um erro de validação será sinalizado no campo `StatusId`. 
image::images/create-new-consultant.png[title="Informar os dados de amostra no form"] 
Por que aconteceu isso? Examine novamente o <<er-diagram,diagrama de relacionamento com entidades do banco de dados da Agência de Consultoria>>. Conforme apresentado na <<relationships,tabela de relacionamentos>> acima, as tabelas `CONSULTANT` e `CONSULTANT_STATUS` compartilham um relacionamento que não pode ser nulo, um para muitos. Portanto, cada entrada da tabela `CONSULTANT` deve conter uma referência a uma entrada na tabela `CONSULTANT_STATUS`. Isso é indicado pela chave estrangeira `consultant_fk_consultant_status` que vincula as duas tabelas.

É possível exibir as chaves estrangeiras contidas nas tabelas expandindo o nó Chaves Estrangeiras da tabela na janela Serviços (Ctrl-5; &amp;#8984-5 no Mac).

image::images/consultant-fk.png[title="Examinar os atributos da chave estrangeira na janela Serviços"]
4. Para solucionar o erro de validação, selecione `entity.ConsultantStatus[statusId=A]` na lista drop-down `StatusId`. 

*Observação: *Você pode deixar o campo `RecruiterId` em branco. Conforme indicado no <<er-diagram,diagrama de relacionamento com as entidades do banco de dados>>, há um relacionamento que pode ser nulo, um para muitos entre as tabelas `CONSULTANT` e `RECRUITER`, indicando que as entradas em `CONSULTANT` não precisam estar associadas a uma entrada de `RECRUITER`.
5. Clique em Salvar. Será exibida uma mensagem indicando que a entrada do consultor foi salva com êxito. Se você clicar em `Exibir Todos os Itens do Consultor`, você verá a nova entrada listada na tabela.

Em geral, as páginas de Facelets geradas produzem erros para entradas do usuário que introduz:

* campos vazios em células de tabela que não podem ser nulas.
* modificações em dados que não podem ser alterados (por exemplo, chaves primárias).
* inserção de dados que não são do tipo correto.
* modificações em dados quando uma view do usuário não estiver mais sincronizada com o banco de dados.


[[editEntity]]
=== Editando as Classes de Entidade

Na subseção anterior, você viu como a lista drop-down `StatusId` forneceu a opção mais complexa `entity.ConsultantStatus[statusId=A]`. Você já deve ter notado que o texto exibido em cada item desta lista drop-down é a representação de uma string de cada entidade `ConsultantStatus` encontrada (por exemplo, o método `toString()` da classe de entidade é chamado).

Essa subseção demonstra como você pode utilizar a funcionalidade autocompletar código, a documentação e o suporte à navegação do editor para chegar a essa conclusão. Também oferece uma mensagem mais amigável para a lista drop-down.

1. Abra o arquivo `/consultant/Create.xhtml` no editor. Trata-se do form Criar Novo Consultor que você acaba de exibir no browser. Role para baixo até o código da lista drop-down `StatusId` (ilustrado em *negrito* abaixo).

[source,xml]
----

    <h:outputLabel value="#{bundle.CreateConsultantLabel_resume}" for="resume" />
    <h:inputTextarea rows="4" cols="30" id="resume" value="#{consultantController.selected.resume}" title="#{bundle.CreateConsultantTitle_resume}" />
    *<h:outputLabel value="#{bundle.CreateConsultantLabel_statusId}" for="statusId" />
    <h:selectOneMenu id="statusId" value="#{consultantController.selected.statusId}" title="#{bundle.CreateConsultantTitle_statusId}" required="true" requiredMessage="#{bundle.CreateConsultantRequiredMessage_statusId}">
        <f:selectItems value="#{consultantStatusController.itemsAvailableSelectOne}"/>
    </h:selectOneMenu>*
    <h:outputLabel value="#{bundle.CreateConsultantLabel_recruiterId}" for="recruiterId" />
    <h:selectOneMenu id="recruiterId" value="#{consultantController.selected.recruiterId}" title="#{bundle.CreateConsultantTitle_recruiterId}" >
        <f:selectItems value="#{recruiterController.itemsAvailableSelectOne}"/>
    </h:selectOneMenu>
</h:panelGrid>
----
2. Examine o `value` aplicado à tag `<f:selectItems>`. O atributo `value` determina o texto exibido para cada item na lista drop-down. 

Pressione Ctrl-Espaço em `itemsAvailableSelectOne`. A funcionalidade autocompletar código do editor indica que o método `getItemsAvailableSelectOne()` do `ConsultantStatusController` retorna um array de objetos `SelectItem`.
image::images/code-completion-returned-object.png[title="A funcionalidade autocompletar código exibe as classes retornadas para os métodos"]
3. Pressione Ctrl (&amp;#8984 no Mac) e, em seguida, mova o mouse sobre `itemsAvailableSelectOne`. É formado um link que permite ir diretamente para o método `getItemsAvailableSelectOne()` no código-fonte da entidade `ConsultantStatus`. Clique neste link.
4. Coloque o cursor sobre o valor de retorno `SelectItem[]` na assinatura do método e pressione Ctrl-Espaço para chamar a janela pop-up da documentação.
image::images/documentation-select-item.png[title="Pressione Ctrl-Espaço para chamar o suporte à documentação"]

Clique no ícone ( image::images/web-browser-icon.png[] ) Web browser na janela da documentação para abrir o Javadoc em um Web browser externo.

Como você pode ver, a classe `SelectItem` pertence ao framework JSF. O componente `UISelectOne`, conforme mencionado na documentação, é representado pela tag `<h:selectOneMenu>` da marcação que você examinou na <<markup,Etapa 1>> acima.
5. Pressione Ctrl (&amp;#8984 no Mac) e, em seguida, mova o mouse sobre `findAll()`. Uma janela pop-up será exibida com a assinatura do método. 
image::images/method-signature.png[title="Exibir pop-ups das assinaturas do método no editor"] 
É possível observar que aqui o `ejbFacade.findAll()` retorna uma `Lista` de objetos `ConsultantStatus`.
6. Vá para `JsfUtil.getSelectItems`. Coloque o mouse sobre `getSelectItems` e pressione Ctrl (&amp;#8984 no Mac), a seguir, clique no link exibido. 

*Observação: *Lembre-se de que `JsfUtil` é uma das classes de utilitário geradas ao concluir o <<jsfPagesEntityClasses,assistente de Páginas JSF de Classes de Entidade>>. 

O método cria o loop por meio da lista de entidades (por exemplo, a `List` de objetos `ConsultantStatus`), criando um `SelectItem` para cada entidade. Conforme indicado abaixo em *negrito*, cada `SelectItem` é criado utilizando o objeto da entidade e um _label_ para o objeto.

[source,java]
----

public static SelectItem[] getSelectItems(List<?> entities, boolean selectOne) {
    int size = selectOne ? entities.size() + 1 : entities.size();
    SelectItem[] items = new SelectItem[size];
    int i = 0;
    if (selectOne) {
        items[0] = new SelectItem("", "---");
        i++;
    }
    *for (Object x : entities) {
        items[i++] = new SelectItem(x, x.toString());
    }*
    return items;
}
----

O label é criado utilizando o método `toString()` da entidade e corresponde à representação do objeto quando renderizado na resposta. (Consulte a definição do Javadoc para o construtor `SelectItem(java.lang.Object value, java.lang.String label)`.)

Agora que você verificou que o método `toString()` da entidade é o método renderizado no browser ao exibir os itens em uma lista drop-down, modifique o método `toString()` do `ConsultantStatus`.

7. Abra a classe de entidade `ConsultantStatus` no editor. Modifique o método `toString` para retornar `statusId` e `description`. Trata-se das propriedades da entidade que correspondem às duas colunas da tabela `CONSULTANT_STATUS`.

[source,java]
----

public String toString() {
    return *statusId + ", " + description;*
}
----
8. Execute o projeto novamente. Quando o browser exibir a página de boas-vindas, clique no link `Mostrar Todos os Itens do Consultor` e, em seguida, em `Criar Novo Consultor`.

Inspecione a lista drop-down `StatusId`. Você verá que agora ela exibe o ID de status e a descrição do registro contido na tabela `CONSULTANT_STATUS` do banco de dados.

image::images/drop-down.png[title="A lista drop-down StatusId exibe itens de acordo com o método toString() da entidade ConsultantStatus"]


[[troubleshooting]]
== Solução de Problemas

Dependendo da sua configuração, a implantação da aplicação no servidor poderá falhar e você talvez veja a seguinte mensagem na janela Saída.


[source,java]
----

GlassFish Server 4 is running.
In-place deployment at /MyDocuments/ConsultingAgency/build/web
GlassFish Server 4, deploy, null, false
/MyDocuments/ConsultingAgency/nbproject/build-impl.xml:1045: The module has not been deployed.
See the server log for details.
----

A causa mais comum da falha é um problema ao gerar os recursos JDBC no servidor. Se esse for o caso, você provavelmente verá uma mensagem semelhante à seguinte na guia de log do servidor, na janela Saída.


[source,java]
----

Severe:   Exception while preparing the app : Invalid resource : jdbc/consult__pm
com.sun.appserv.connectors.internal.api.ConnectorRuntimeException: Invalid resource : jdbc/consult__pm
----

Se a guia de log do servidor não for aberta, será possível abri-la clicando com o botão direito do mouse no nó GlassFish Server, na janela Serviços, e escolhendo Exibir Log do Servidor de Domínio.

Essa aplicação exige dois recursos JDBC:

* Recurso ou Fonte de Dados JDBC. A aplicação usa a pesquisa JNDI para localizar o recurso JDBC. Se você examinar a unidade de persistência (`persistence.xml`), poderá ver que o nome da JNDI para a fonte de dados JTA dessa aplicação é `jdbc/consult`.

O recurso JDBC identifica o pool de conexões atualmente utilizado pela aplicação.

* Pool de Conexões JDBC. O pool de conexões especifica os detalhes da conexão do banco de dados, o que inclui local, nome do usuário e senha. O pool de conexões usado nessa aplicação é `consultPool`.

O recurso JDBC e o pool de conexões são especificados no arquivo `glassfish-resources.xml`. Você pode abrir `glassfish-resources.xml` no editor expandindo o nó Recursos do Servidor na janela Projetos e clicando duas vezes no arquivo. O arquivo será semelhante ao seguinte:


[source,xml]
----

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions//EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
<resources>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="com.mysql.jdbc.jdbc2.optional.MysqlDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="consultPool" non-transactional-connections="false" ping="false" pool-resize-quantity="2" pooling="true" res-type="javax.sql.DataSource" statement-cache-size="0" statement-leak-reclaim="false" statement-leak-timeout-in-seconds="0" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="serverName" value="localhost"/>
    <property name="portNumber" value="3306"/>
    <property name="databaseName" value="consult"/>
    <property name="User" value="root"/>
    <property name="Password" value="nb"/>
    <property name="URL" value="jdbc:mysql://localhost:3306/consult?zeroDateTimeBehavior=convertToNull"/>
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  /<jdbc-connection-pool>
  <jdbc-resource enabled="true" jndi-name="jdbc/consult" object-type="user" pool-name="consultPool"/>
/<resources>
----

Em `glassfish-resources.xml`, você poderá ver que o recurso JDBC `jdbc/consult` identifica `consultPool` como nome do pool de conexões. É possível também ver as propriedades de `consultPool`. Nessa aplicação, apenas uma fonte de dados e um pool de conexões são definidos em `glassfish-resources.xml`. Em alguns casos, convém especificar recursos adicionais, por exemplo, para identificar um armazenamento de dados temporário usado apenas para fins de desenvolvimento ou teste.

Se o recurso JDBC e o pool de conexões não tiverem sido gerados automaticamente no servidor quando você executou a aplicação, será possível realizar as etapas a seguir para criar manualmente os recursos na Console Admin do GlassFish.

1. Abra `glassfish-resources.xml` no editor se não tiver feito isso ainda.

Use os valores de propriedade especificados em `glassfish-resources.xml` ao criar o recurso JDBC e o pool de conexões.

2. Clique com o botão direito no nó GlassFish Server, na janela Serviços, e escolha Abrir Console Admin do Domínio no menu pop-up para abrir a Console do GlassFish no browser.
3. No painel de navegação Tarefas Comuns da Console do GlassFish, expanda o nó *JDBC* e os nós *Recursos JDBC* e *Pool de Conexões JDBC*. 
[.feature]
--
image::images/gf-admin-console-sm.png[role="left", link="images/gf-admin-console-lg.png"]
--

Você pode ver os recursos JDBC que estão registrados atualmente no servidor. Será necessário criar `jdbc/consult` e `consultPool` se não estiverem listados sob o nó JDBC no painel de navegação Tarefas Comuns. Alguns recursos JDBC foram criados por padrão quando você instalou o servidor e são exibidos como subnós.

4. Clique no nó *Pools de Conexões JDBC* e clique em Novo no painel Novo Pool de Conexões JDBC. 
image::images/gf-new-jdbc-pool1.png[title="Painel Novo Pool de Conexões JDBC na Console Admin do GlassFish"]
5. Digite *consultPool* como Nome do Pool, selecione *javax.sql.ConnectionPoolDataSource* como Tipo de Recurso e selecione *MySql* como Fornecedor do Driver de Banco de Dados. Clique em Próximo.
6. Na Etapa 2, localize e especifique os valores das propriedades *URL*, *nome do usuário* e *senha*. Clique em Finalizar. 
image::images/gf-new-jdbc-pool2.png[title="Painel Novo Pool de Conexões JDBC na Console Admin do GlassFish"]

Os valores das propriedades se encontram em `glassfish-resources.xml`.

O novo pool de conexões é criado no servidor quando você clica em Concluir e um nó do pool de conexões é exibido sob o nó Pools de Conexões JDBC.

7. Clique no nó *Recursos JDBC* no painel de navegação Tarefas Comuns e clique em Novo.
8. Digite *jdbc/consult* como Nome da JNDI e selecione *consultPool* na lista drop-down Nome do Pool. Clique em OK. 
image::images/gf-new-jdbc-resource.png[title="Painel Novo Recurso JDBC na Console Admin do GlassFish"]

O novo recurso JDBC é criado no servidor quando você clica em OK e um nó para o recurso é exibido sob o nó Recursos JDBC.

Na janela Serviço do IDE, você pode expandir o nó Recursos no GlassFish Server e ver se o IDE adicionou os novos recursos. Pode ser necessário atualizar a view (clique com o botão direito do mouse em Recursos e escolha Atualizar) para exibir as alterações.

image::images/gf-services-jdbc-resources.png[title="Recursos JDBC exibidos na janela Serviços do IDE"]

Para obter mais dicas sobre solução de problemas ao usar o MySQL e o IDE, consulte os seguintes documentos:

* Tutorial link:../ide/mysql.html[+Estabelecendo Conexão com um Banco de Dados MySQL+].
* A seção de solução de problemas de link:mysql-webapp.html#troubleshoot[+Criando uma Aplicação Web Simples Usando um Banco de Dados MySQL+]
link:/about/contact_form.html?to=3&subject=Feedback:%20Creating%20a%20JSF%202.0%20CRUD%20Application[+Enviar Feedback neste Tutorial+]


[[seealso]]
== Consulte Também

Para obter mais informações sobre o JSF 2.x, consulte os recursos a seguir:


=== Tutoriais e Artigos NetBeans

* link:jsf20-intro.html[+Introdução ao JavaServer Faces 2.x no NetBeans IDE+]
* link:jsf20-support.html[+Suporte a JSF 2.x no NetBeans IDE+]
* link:../../samples/scrum-toys.html[+Scrum Toys: A Aplicação de Amostra Completa do JSF 2.0+]
* link:../javaee/javaee-gettingstarted.html[+Conceitos Básicos sobre Aplicações do Java EE+]
* link:../../trails/java-ee.html[+Trilha do Aprendizado do Java EE e Java Web+]


=== Recursos Externos

* link:http://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html[+Tecnologia JavaServer Faces+] (homepage Oficial)
* link:http://jcp.org/aboutJava/communityprocess/final/jsr314/index.html[+Especificação do JSR 314 para o JavaServer Faces 2.0+]
* Capítulo link:http://docs.oracle.com/javaee/7/tutorial/doc/jsf-intro.htm[+Tecnologia do JavaServer Faces+] no Tutorial Java EE 7
* link:http://javaserverfaces.dev.java.net/[+Projeto Mojarra GlassFish+] (Implementação oficial de referência do JSF 2.x)
* link:http://forums.oracle.com/forums/forum.jspa?forumID=982[+Fóruns de Discussão OTN: JavaServer Faces+]
* link:http://www.jsfcentral.com/[+Central do JSF+]


=== Blogs

* link:http://www.java.net/blogs/edburns/[+Ed Burns+]
* link:http://www.java.net/blogs/driscoll/[+Jim Driscoll+]