Google Git
Sign in
apache / netbeans-website-cleanup / refs/heads/asciidoc-features / . / src / content / kb / docs / javaee / javaee-gettingstarted_pt_BR.html
blob: f4ba5c48c7b9c46a72aaebd5c5452715921f23a0 [file] [log] [blame]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
Copyright (c) 2009, 2010, 2011, Oracle and/or its affiliates. All rights reserved.
-->
<html>
<head>
<title>Introdução às Aplicações Java EE</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="description" content="A tutorial that introduces NetBeans IDE support for some of the new features in Java EE 6.">
<link rel="stylesheet" href="../../../netbeans.css">
<meta name="author" content="ken ganfield">
</head>
<body>
<h1>Introdução às Aplicações Java EE</h1>
<p>Este documento fornece uma breve introdução a algumas das funcionalidades apresentadas como parte da especificação Java Enterprise Edition 6 (Java EE 6). Para ilustrar as novas funcionalidades, este tutorial demonstrará como criar uma aplicação web Java EE simples que contenha uma fachada de bean de sessão sem estado EJB 3.1 para uma classe de entidade. Você utilizará assistentes no IDE para gerar a classe de entidade no bean de sessão. O código gerado pelo assistente utiliza consultas as quais estão definidas na API de critérios, que faz parte do JPA 2.x e está contida na especificação Java EE 6. Em seguida, você criará um bean gerenciado e nomeado que acessa a fachada de sessão, bem como uma camada de apresentação que utiliza o framework de view do Facelets como especificado no JSF 2.x.</p>
<p>Este tutorial é baseado no post do blog <a href="http://www.adam-bien.com/roller/abien/entry/simplest_possible_jsf_2_ejb" target="_blank" title="http://www.adam-bien.com/roller/abien/entry/simplest_possible_jsf_2_ejb"> Simplest Possible JSF 2 / EJB 3.1 / JPA Component - With WAR Deployment</a> de Adam Bien. Você pode encontrar exemplos adicionais de Java EE no projeto do Kenai de Adam Bien <a href="http://kenai.com/projects/javaee-patterns" target="_blank" title="http://kenai.com/projects/javaee-patterns"> Java EE Patterns and Best Practices</a> e no seu livro "Real World Java EE Patterns - Rethinking Best Practices", disponível em <a href="http://press.adam-bien.com" target="_blank" title="http://press.adam-bien.com">http://press.adam-bien.com</a>.</p>
<p><b>Exercícios do Tutorial</b></p>
<img alt="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0" class="stamp" src="../../../images_www/articles/73/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">
<ul>
<li><a href="#Exercise_1">Criando o Projeto de Aplicação Web</a></li>
<li><a href="#Exercise_2">Criando a Classe de Entidade e a Fachada de Sessão</a>
<ul>
<li><a href="#Exercise_2a">Criando a Classe de Entidade</a></li>
<li><a href="#Exercise_2b">Criando a Fachada da Sessão</a></li>
</ul>
</li>
<li><a href="#Exercise_3">Criando as Páginas Bean Gerenciado JSF e JSF</a>
<ul>
<li><a href="#Exercise_3a">Criando o Bean Gerenciado</a></li>
<li><a href="#Exercise_3b">Modificando a Página de Índice</a></li>
<li><a href="#Exercise_3c">Criando a Página de Resultados</a></li>
</ul>
</li>
<li><a href="#Exercise_4">Executando o Projeto</a></li>
<li><a href="#Exercise_5">Fazendo Download do Projeto da Solução</a></li>
</ul>
<p><b>Para seguir este tutorial, são necessários os recursos e o software a seguir.</b></p>
<table>
<tbody>
<tr>
<th class="tblheader" scope="col">Software ou Recurso</th>
<th class="tblheader" scope="col">Versão Necessária</th>
</tr>
<tr>
<td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
<td class="tbltd1">Versão Java EE 7.2, 7.3, 7.4, 8.0</td>
</tr>
<tr>
<td class="tbltd1"><a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">JDK (Java Development Kit)</a></td>
<td class="tbltd1">versão 7 ou 8</td>
</tr>
<tr>
<td class="tbltd1">GlassFish Server Open Source Edition</td>
<td class="tbltd1">3.x, 4.x</td>
</tr>
</tbody>
</table>
<p><b>Pré-requisitos</b></p>
<p>Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas:</p>
<ul>
<li>Programação em Java</li>
<li>NetBeans IDE</li>
</ul>
<p class="tips">Você pode fazer download <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App72.zip">de um arquivo compactado zip do projeto finalizado</a>.</p>
<!-- ===================================================================================== -->
<a name="Exercise_1"></a>
<!--Exercise 1: -->
<h2>Criando o Projeto de Aplicação Web</h2>
<p>Neste exercício será criada uma aplicação web simples. Quando você cria uma aplicação web, o GlassFish Server é especificado como o contêiner Java EE de destino. O GlassFish Server é compatível com o Java EE e inclui as bibliotecas JSF 2.x que são necessárias nesta aplicação.</p>
<p>No assistente Novo Projeto, você pode selecionar o Java EE 6 Web ou Java EE 7 como a versão Java EE. Java EE 6 Web e Java EE 7 Web são perfis de Java EE leves que contêm um subconjunto da plataforma Java EE completa. Os perfis Java EE Web foram criados para aplicações web que não requerem as tecnologias Java EE avançadas, como o suporte a interfaces remotas, a especificação completa do EJB 3.1 e a API Java Message Service (JMS).</p>
<p>Os perfis Web suportam o processamento da transação e o gerenciamento de persistência que normalmente são utilizados em aplicações web corporativas. Você pode utilizar os perfis Java EE Web para aplicações Web que utilizam beans de sessão com uma interface local ou sem uma interface. O perfil Java EE completo é necessário se a aplicação utilizar uma interface remota.</p>
<ol>
<li>Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.</li>
<li>Selecione Aplicação Web na categoria Java Web e clique em Próximo.</li>
<li>Digite <strong>SimpleEE6App</strong> como o nome do projeto e defina a localização do projeto. </li>
<li>Desmarque a opção Usar Pasta Dedicada, se ela estiver selecionada. Clique em Próximo.<br /> (Para este tutorial, não há motivo para copiar as bibliotecas de projeto em uma pasta dedicada, pois você não precisará compartilhar bibliotecas com outros usuários ou projetos).<br />
</li>
<li>Selecione o servidor GlassFish Server e defina a versão do Java EE como Java EE 6 Web ou Java EE 7 Web. Clique em Próximo.<br /> <img alt="Assistente Novo Projeto" class="margin-around b-all" src="../../../images_www/articles/74/javaee/gettingstarted/newappwizard.png" title="Painel Servidor e Definições no assistente Novo Projeto">
</li>
<li>Selecione JavaServer Faces no painel Frameworks. Clique em Finalizar.
<p>Se você estiver desenvolvendo uma aplicação web Java EE e implantando-a no GlassFish Server, o IDE selecionará a biblioteca JSF 2.x como default. A versão da biblioteca JSF default depende da versão encapsulada de seu servidor GlassFish. A biblioteca JSF 2.x permite utilizar Facelets como a linguagem da página e também fornece o suporte para JSF 1.2 e JSP.</p>
<img alt="Assistente Novo Projeto" class="margin-around b-all" src="../../../images_www/articles/74/javaee/gettingstarted/newappwizard2.png" title="Painel Frameworks no assistente Novo Projeto"></li>
</ol>
<p>Quando você clica em Finalizar, o IDE cria o projeto e o abre na janela Projetos. O IDE cria automaticamente a página <tt>index.xhtml</tt> e abre a página no editor.</p>
<a name="Exercise_2"></a>
<h2>Criando a Classe de Entidade e a Fachada de Sessão</h2>
<p>Nesta sessão, você criará uma classe de entidade e uma fachada de sessão para a classe de entidade. Uma classe de entidade é um objeto Java simples e antigo (POJO), uma classe Java simples que é identificada como uma entidade pela anotação <tt>@Entity</tt>. A partir da especificação Java EE 5, você pode utilizar classes de entidade como objetos persistentes para representar tabelas em um banco de dados. A Java Persistence API permite utilizar a persistência em aplicações web sem a necessidade de criar um módulo EJB.
</p>
<p>A fachada de sessão para a classe de entidade nesta aplicação é um bean de sessão sem estado. A arquitetura Enterprise JavaBean (EJB) 3.1 introduzida como parte da especificação Java EE 6 permite criar beans de sessão sem as interfaces de negócios que eram necessárias no EJB 3.0. A especificação Java EE 6 também permite encapsular componentes do EJB diretamente em um arquivo compactado WAR. Isso simplifica o desenvolvimento de aplicações web menores eliminando a necessidade de criar módulos EJB separados, que são encapsulados como um arquivo compactado JAR em um arquivo compactado EAR. No entanto, para aplicações enterprise maiores que são distribuídas entre diferentes máquinas, você ainda precisará criar arquivos compactados EAR para separar sua lógica de negócios da camada de apresentação.</p>
<p class="tips">Para obter mais informações sobre o uso do EJB 3.1 no IDE, consulte o tutorial <a href="javaee-entapp-ejb.html">Criando uma Aplicação Corporativa com o EJB 3.1</a>.</p>
<p class="tips">Para saber mais sobre classes de entidade, consulte o capítulo <a href="http://docs.oracle.com/javaee/7/tutorial/doc/persistence-intro.htm">Introdução à Java Persistence API</a> no <a href="http://download.oracle.com/javaee/7/tutorial/doc/">Tutorial do Java EE 7</a>.</p>
<p class="tips">Para obter mais informações sobre beans de sessão, consulte o capítulo <a href="http://docs.oracle.com/javaee/7/tutorial/doc/ejb-intro002.htm">O que é um Bean de Sessão?</a> no <a href="http://download.oracle.com/javaee/7/tutorial/doc/">Tutorial do Java EE 7</a>.</p>
<div class="indent">
<a name="Exercise_2a"></a>
<h3>Criando a Classe de Entidade</h3>
<p>Neste exercício, você utilizará o assistente Nova Classe de Entidade para criar uma classe de entidade persistente simples. Você também utilizará o assistente para criar uma unidade de persistência que define a origem dos dados e o gerenciador de entidade utilizado na aplicação. Você adicionará um campo na classe para representar os dados em sua tabela e gerar um getter e um setter para o novo campo.</p>
<p>Uma classe de entidade deve ter uma chave primária. Quando você cria a classe de entidade utilizando o assistente, o IDE gera, por default, o campo <tt>id</tt> e anota o campo com a anotação <tt>@Id</tt> para declarar o campo como a chave primária. O IDE também adiciona a anotação <tt>@GeneratedValue</tt> e especifica a estratégia de geração de chave para o campo de id primário.</p>
<p>Utilizar a Java Persistence em seu projeto simplifica tremendamente o desenvolvimento da aplicação, removendo a necessidade de configurar os descritores de implantação para fornecer informações de mapeamento relacional de objeto para campos ou propriedades persistentes. Em vez disso, você pode utilizar anotações para definir essas propriedades diretamente em uma classe Java simples.</p>
<p>A persistência de entidade é gerenciada pela API EntityManager. A API EntityManager trata o contexto de persistência e cada contexto de persistência é um grupo de instâncias de entidade. Ao desenvolver a aplicação, você pode utilizar anotações em sua classe para especificar a instância do contexto de persistência das suas instâncias de entidade. O ciclo de vida das instâncias de entidade será então tratado pelo contêiner.</p>
<p>Para criar a classe de entidade, execute as seguintes etapas.</p>
<ol>
<li>Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.</li>
<li>Selecione Classe de Entidade na categoria Persistência. Clique em Próximo.</li>
<li>Digite <strong>Message</strong> como o nome da classe.</li>
<li>Digite <strong>entities</strong> para o Pacote.</li>
<li>Selecione Criar Unidade de Persistência. Clique em Próximo.</li>
<li>Selecione uma fonte de dados (por exemplo, selecione <tt>jdbc/sample</tt> se desejar utilizar o JavaDB).
<p>A fonte de dados para <tt>jdbc/sample</tt> é incluída com o IDE ao instalar o IDE e o GlassFish Server, mas você pode especificar uma fonte de dados diferente se desejar utilizar um banco de dados diferente.</p>
<p>Você pode manter as outras opções default (nome da unidade de persistência, provedor da persistência EclipseLink). Confirme se a unidade de persistência está utilizando a Java Transaction API e se a Estratégia de Geração de Tabela é definida como Criar, para que as tabelas com base nas suas classes de entidade sejam criadas quando a aplicação é implantada.
</p></li>
<li>Clique em Finalizar no assistente Nova Classe de Entidade.
<p>Quando você clica em Finalizar, o IDE cria a classe de entidade e abre a classe no editor. Você pode ver que o IDE gerou o campo de id <tt>private Long id;</tt> e anotou o campo com <tt>@Id</tt> e <tt>@GeneratedValue(strategy = GenerationType.AUTO)</tt>.</p></li>
<li>No editor, adicione o campo <tt>mensagem</tt> (em negrito) abaixo do campo <tt>id</tt>.
<pre class="examplecode">
private Long id;
<strong>private String message;</strong></pre>
</li>
<li>Clique com o botão direito do mouse no editor e selecione Inserir Código (Alt-Insert; Ctrl+I no Mac) e, em seguida, selecione Getter e Setter.</li>
<li>Na caixa de diálogo Gerar Getters e Setters, selecione o campo <tt>mensagem</tt> e clique em Gerar.
<p>O IDE gera os métodos getter e setter para o campo <tt>mensagem</tt>.</p>
<img alt="Assistente Criar Unidade de Persistência" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/getters-dialog.png" title="Assistente Criar Unidade de Persistência"></li>
<li>Salve as alterações.</li>
</ol>
<p>A classe de entidade representa uma tabela no banco de dados. Quando você executa esta aplicação, uma tabela do banco de dados para Mensagem será criada automaticamente. A tabela conterá as colunas <tt>id</tt> e <tt>mensagem</tt>.</p>
<p>Se examinar a unidade de persistência no editor XML, verá que a aplicação utilizará a API de Transação Java (JTA) (<tt>transaction-type="JTA"</tt>). Isso especifica que a responsabilidade por gerenciar o ciclo de vida de entidades no contexto da persistência é designada ao contêiner. Isso resulta em menos código, porque o ciclo de vida da entidade é gerenciado pelo contêiner e não pela aplicação. Para obter mais informações sobre o uso de JTA para gerenciar transações, consulte a documentação da <a href="http://www.oracle.com/technetwork/java/javaee/jta/index.html" target="_blank">API de Transação Java</a>.</p>
<a name="Exercise_2b"></a>
<h3>Criando a Fachada da Sessão</h3>
<p>Neste exercício você utilizará um assistente para criar uma fachada de sessão sem estado para a entidade Mensagem. A especificação EJB 3.1. declara que as interfaces de negócios para beans de sessão agora são opcionais. Nesta aplicação, onde o cliente que acessa o bean é um cliente local, você tem a opção de utilizar uma interface local ou uma view sem interface para expor o bean.</p>
<p>Para criar o bean da sessão, execute as seguintes etapas.</p>
<ol>
<li>Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.</li>
<li>Selecione Beans de Sessão para Classes de Entidade na categoria Enterprise JavaBeans. Clique em Próximo.</li>
<li>Selecione a entidade <tt>Mensagem</tt> e clique em Adicionar. Clique em Próximo.</li>
<li>Digite <strong>boundary</strong> para o pacote. Clique em Finalizar.
<p>Observe que não foi necessário criar uma interface de negócios para o bean de sessão. Em vez disso, nessa aplicação, o bean será exposto a um bean gerenciado local utilizando uma view sem interface.</p>
<img alt="Assistente Beans de Sessão para Classes de Entidade" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/sessionwizard.png" title="Assistente Beans de Sessão para Classes de Entidade"></li>
</ol>
<p>Quando você clica em Finalizar, o IDE gera a classe de fachada da sessão <tt>MessageFacade.java</tt> e <tt>AbstractFacade.java</tt> e abre os arquivos no editor. Como podemos ver no código gerado, a anotação <tt>@Stateless</tt> é usada para declarar a classe <tt>MessageFacade.java</tt> como um componente de bean de sessão sem estado. <tt>MessageFacade.java</tt> estende <tt>AbstractFacade.java</tt>, que contém a lógica de negócio e gerencia a transação.</p>
<pre class="examplecode">
@Stateless
public class MessageFacade extends AbstractFacade&lt;Message&gt; {
@PersistenceContext(unitName = "SimpleEE6AppPU")
private EntityManager em;
</pre>
<p>Quando você cria a fachada para a entidade utilizando o assistente, como default, o IDE adiciona a anotação <tt>PersistenceContext</tt> (<tt>@PersistenceContext(unitName = "SimpleEE6AppPU")</tt>) para injetar recurso de gerenciador de entidades no componente do bean de sessão e para especificar o nome da unidade de persistência. Neste exemplo, o nome da unidade de persistência é explicitamente declarado, mas o nome é opcional se a aplicação tiver somente uma unidade de persistência.</p>
<p>O IDE também gera métodos em <tt>AbstractFacade.java</tt> para criar, editar, remover e localizar entidades. A API EntityManager define os métodos que são utilizados para interagir com o contexto da persistência. Você pode ver que o IDE gera alguns métodos de consulta default usados com frequência que podem ser utilizados para localizar objetos de entidade. Os métodos <tt>findAll</tt>, <tt>findRange</tt> e <tt>count</tt> utilizam os métodos definidos na API Critérios para criar consultas. A API Critérios faz parte da especificação JPA 2.x, que está incluída na especificação Java EE 6.</p>
</div>
<!-- ===================================================================================== -->
<a name="Exercise_3"></a>
<h2>Criando as Páginas Bean Gerenciado JSF e JSF</h2>
<p>Nesta seção, você criará a camada de apresentação para a aplicação utilizando o JavaServer Faces (JSF) 2.x e um backing bean gerenciado que é utilizado pelas páginas JSF. A especificação JSF 2.x adiciona o suporte para Facelets, como a tecnologia de exibição preferencial para aplicações com base em JSF. Começando com o JSF 2.x, você também poderá utilizar a anotação <tt>@ManagedBean</tt> em seu código-fonte para declarar uma classe como bean gerenciado. Não é mais necessário adicionar entradas no arquivo <tt>faces-config.xml</tt> para declarar beans gerenciados JSF. Você pode utilizar nomes de beans em páginas JSF para acessar métodos no bean gerenciado.</p>
<p class="tips">Para obter mais informações sobre o suporte do IDE para a especificação JavaServer Faces 2.x, consulte <a href="../web/jsf20-support.html">Suporte JSF 2.x no NetBeans IDE</a>.</p>
<p class="tips">Para obter mais informações sobre a especificação JavaServer Faces 2.x, consulte o capítulo <a href="http://docs.oracle.com/javaee/7/tutorial/doc/jsf-intro.htm" target="_blank">Tecnologia do JavaServer Faces</a> no Tutorial Java EE 7.</p>
<div class="indent">
<a name="Exercise_3a"></a>
<h3>Criando o Bean Gerenciado</h3>
<p>Neste exercício, será criado um bean gerenciado JSF simples, que é utilizado para acessar a fachada de sessão. A especificação do JSF 2.x permite utilizar anotações em uma classe do bean para identificá-la como um bean gerenciado pelo JSF e especificar o escopo e um nome para o bean.</p>
<p>Para criar o bean gerenciado, execute as seguintes etapas:</p>
<ol>
<li>Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.</li>
<li>Selecione Bean Gerenciado pelo JSF na categoria JavaServer Faces. Clique em Próximo.</li>
<li>Digite <strong>MessageView</strong> para o Nome da Classe.
<p>Você utilizará o bean gerenciado de nome <tt>MessageView</tt> como o valor para <tt>inputText</tt> e <tt>commandButton</tt> na página JSF <tt>index.xhtml</tt> ao chamar métodos no bean.</p>
</li>
<li>Digite <strong>my.presentation</strong> para o Pacote.</li>
<li>Digite <strong>MessageView</strong> para o Nome que será utilizado para o bean gerenciado.
<p class="notes"><strong>Observação.</strong> Quando você cria um bean gerenciado utilizando o assistente, o IDE designará, por default, um nome para o bean, com base no nome da classe bean com uma letra minúscula. Para este tutorial e para fins de demonstração, você designa explicitamente ao bean um nome que começa com uma letra maiúscula. Ao referenciar o bean nas páginas JSF, você usará <tt>MessageView</tt>, em vez de <tt>messageView</tt>. Se você não tiver designado o nome explicitamente, deverá usar <tt>messageView</tt> default na página JSF.</p></li>
<li>Defina Escopo como Requisição. Clique em Finalizar.</li>
</ol>
<img alt="Novo assistente de Bean Gerenciado pelo JSF" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/newjsfbean.png" title="Novo assistente de Bean Gerenciado pelo JSF">
<p>Quando você clicar em Finalizar, o IDE gerará a classe bean e abrirá a classe no editor. Na janela Projetos, você verá os seguintes arquivos.</p>
<img alt="Janela Projeto que mostra estrutura de arquivos" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/projectswindow.png" title="Janela Projeto que mostra estrutura de arquivos">
<p>No editor, você pode ver que o IDE adicionou as anotações <tt>@ManagedBean</tt> e <tt>@RequestScoped</tt> e o nome do bean.</p>
<pre class="examplecode">
@ManagedBean(name="MessageView")
@RequestScoped
public class MessageView {
/** Creates a new instance of MessageView */
public MessageView() {
}
}
</pre>
<p>Agora, você adicionará uma anotação <tt>@EJB</tt> será adicionada para utilizar injeção de dependência para obter uma referência ao bean de sessão MessageFacade. Você também chamará os métodos <tt>findAll</tt> e <tt>create</tt> que estão expostos na fachada. A funcionalidade autocompletar código do IDE pode ajudá-lo enquanto você digita os métodos.</p>
<ol>
<li>Clique com o botão direito do mouse no editor, selecione Inserir Código (Alt-Insert; Ctrl-I no Mac) e Chamar Enterprise Bean no menu pop-up.</li>
<li>Selecione MessagFacade na caixa de diálogo Chamar Enterprise Bean. Clique em OK.<br /> <img alt="Caixa de diálogo Chamar Enterprise Bean" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/callbean.png" title="Caixa de diálogo Chamar Enterprise Bean">
<p>Quando você clica em OK, o IDE adiciona o seguinte código (em negrito) para injetar o bean.</p>
<pre class="examplecode">
public class MessageView {
/** Creates a new instance of MessageView */
public MessageView() {
}
// Injects the MessageFacade session bean using the @EJB annotation
<strong>@EJB
private MessageFacade messageFacade;</strong>
}
</pre>
</li>
<li>Adicione o código a seguir para criar uma nova instância.
<pre class="examplecode">/** Creates a new instance of MessageView */
public MessageView() {
this.message = new Message();
}</pre>
</li>
<li>Adicione o seguinte código à classe.
<pre class="examplecode">
// Creates a new field
private Message message;
// Calls getMessage to retrieve the message
public Message getMessage() {
return message;
}
// Returns the total number of messages
public int getNumberOfMessages(){
return messageFacade.findAll().size();
}
// Saves the message and then returns the string "theend"
public String postMessage(){
this.messageFacade.create(message);
return "theend";
}
</pre>
</li>
<li>Clique com o botão direito do mouse no editor, selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) e salve as alterações.</li>
</ol>
<p class="tips">Você pode utilizar a funcionalidade para autocompletar código no editor para ajudar a digitar seu código.
</p>
<p>Observe que o método <tt>postMessage</tt> retorna a string "theend". A especificação JSF 2.x permite a utilização de regras de navegação implícitas em aplicações que utilizam a tecnologia Facelets. Nesta aplicação, não há regras de navegação configuradas em <tt>faces-config.xml</tt>. Em vez disso, o handler de navegação tentará localizar a página adequada na aplicação. Neste caso, o handler de navegação tentará localizar uma página nomeada <tt>theend.xhtml</tt> quando o método <tt>postMessage</tt> for chamado.<p>
<a name="Exercise_3b"></a>
<h3>Modificando a Página de Índice</h3>
<p>Neste exercício, você fará algumas alterações simples na página <tt>index.xhtml</tt> para adicionar alguns componentes de interface do usuário. Você adicionará um form com um campo de entrada de texto e um botão.</p>
<ol>
<li>Abra o <tt>index.xhtml</tt> no editor.</li>
<li>Modifique o arquivo para adicionar o seguinte form simples entre as tags <tt>&lt;h:body></tt>.
<pre class="examplecode">
&lt;h:body&gt;
<strong>&lt;f:view&gt;
&lt;h:form&gt;
&lt;h:outputLabel value="Message:"/&gt;&lt;h:inputText value="#{MessageView.message.message}"/&gt;
&lt;h:commandButton action="#{MessageView.postMessage}" value="Post Message"/&gt;
&lt;/h:form&gt;
&lt;/f:view&gt;</strong>
&lt;/h:body&gt;</pre>
<p class="tips">A funcionalidade autocompletar código JSF pode ajudá-lo ao digitar o código.
</p>
<img alt="Autocompletar código no editor de código-fonte" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/jsfcodecompletion1.png" title="Autocompletar código no editor de código-fonte">
<p class="notes"><strong>Observação.</strong> Se você copiar e colar o código no arquivo, receberá uma advertência na margem esquerda ao lado da linha que contém <tt>&lt;f:view></tt>. Você pode colocar o cursor de inserção na linha e digitar Alt-Espaço para abrir a dica sobre como resolver o erro. A dica informa que é necessário adicionar a declaração de biblioteca <tt>xmlns:f="http://xmlns.jcp.org/jsf/core"</tt>.</p>
</li>
<li>Salve as alterações.
</li>
</ol>
<p>Os componentes <tt>inputText</tt> e <tt>commandButton</tt> chamarão os métodos no bean gerenciado JSF nomeado <tt>MessageView</tt>. O método <tt>postMessage</tt> retornará "theend" e o handler de navegação procurará por uma página nomeada <tt>theend.xhtml</tt>.</p>
<a name="Exercise_3c"></a>
<h3>Criando a Página de Resultados</h3>
<p>Neste exercício, você criará a página JSF <tt>theend.xhtml</tt>. A página será exibida quando o usuário clicar no botão Postar Mensagem no <tt>index.xhtml</tt> e chamar o método <tt>postMessage</tt> no bean gerenciado JSF.</p>
<ol>
<li>Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.</li>
<li>Selecione a Página JSF na categoria JavaServer Faces. Clique em Próximo.</li>
<li>Digite <strong>theend</strong> como o Nome do Arquivo.</li>
<li>Certifique-se de que a opção Facelets esteja selecionada. Clique em Finalizar.<br> <img alt="tela do assistente Novo Arquivo JSF" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/result-jsf-page.png" title="Criando o arquivo JSF theend no assistente Novo Arquivo JSF">
</li>
<li>Modifique o arquivo digitando o seguinte entre as tags &lt;h:body>.
<pre class="examplecode">
&lt;h:body&gt;
<strong>&lt;h:outputLabel value="Thanks! There are "/&gt;
&lt;h:outputText value="#{MessageView.numberOfMessages}"/&gt;
&lt;h:outputLabel value=" messages!"/&gt;</strong>
&lt;/h:body&gt;</pre>
</li>
</ol>
<p class="tips">Quando você começa a digitar, o IDE adiciona automaticamente a definição de biblioteca de tags <tt>xmlns:h="http://xmlns.jcp.org/jsf/html"</tt> ao arquivo para os elementos JSF.</p>
</div>
<a name="Exercise_4"></a>
<h2>Executando a Aplicação</h2>
<p>Você agora finalizou a codificação da aplicação. Agora você pode testar a aplicação no browser.</p>
<ol>
<li>Clique com o botão direito do mouse no nó na janela Projetos e selecione Executar.
<p>Quando você seleciona Executar, o IDE constrói e implanta a aplicação e abre o <tt>index.xhtml</tt> no browser.</p></li>
<li>Digite uma mensagem no campo de texto. Clique em Postar Mensagem. <br /> <img alt="Aplicação no browser" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/browser1.png" title="Aplicação no browser">
</li>
</ol>
<p>Quando você clica em Postar Mensagem, a mensagem será salva no banco de dados e o número de mensagens será recuperado e exibido.</p>
<img alt="Aplicação no browser mostrando resultados" class="margin-around b-all" src="../../../images_www/articles/72/javaee/gettingstarted/browser2.png" title="Aplicação no browser mostrando resultados"> <a name="Exercise_5"></a>
<h2>Fazendo Download do Projeto da Solução</h2>
<p>Você pode fazer o download dos projetos de amostra usados neste tutorial das seguintes formas:</p>
<ul>
<li>Faça download <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App72.zip">de um arquivo compactado zip do projeto finalizado</a>.</li>
<li>Faça o check-out do código-fonte do projeto das Amostras do NetBeans ao executar as etapas a seguir:
<ol>
<li>Escolha Equipe > Subversion > Efetuar check-out no menu principal.</li>
<li>Na caixa de diálogo Efetuar Check-out, insira o Repositório URL a seguir:<br /> <tt>https://svn.netbeans.org/svn/samples~samples-source-code</tt><br /> Clique em Próximo.</li>
<li>Clique em Procurar para abrir a caixa de diálogo Procurar Pastas do Repositório.</li>
<li>Expanda o nó de raiz e selecione <strong>samples/javaee/SimpleEE6App</strong>. Clique em OK.</li>
<li>Especifique a Pasta Local para o códigos-fonte (a pasta local precisa estar vazia).</li>
<li>Clique em Finalizar.
<p>Quando você clica em Finalizar, o IDE inicializa a pasta local como um repositório Subversion e verifica os códigos-fonte do projeto.</p>
</li>
<li>Clique em Abrir Projeto na caixa de diálogo exibida quando o check-out for concluído.</li>
</ol>
<p class="notes"><strong>Observações.</strong></p>
<ul>
<li>É necessário um cliente Subversion para verificar os códigos-fonte. Para saber mais sobre a instalação do Subversion, consulte a seção <a href="../ide/subversion.html#settingUp">Configurando o Subversion</a> no <a href="../ide/subversion.html">Guia do Subversion no NetBeans IDE</a>.</li>
</ul>
</li>
</ul>
<br>
<div class="feedback-box" ><a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Getting%20Started%20with%20Java%20EE%206%20Applications">Enviar Feedback neste Tutorial</a></div>
<br style="clear:both;" />
<!-- ======================================================================================= -->
<h2><a name="nextsteps"></a>Consulte Também</h2>
<p>Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java EE, consulte os seguintes recursos:
</p>
<ul>
<li><a href="javaee-intro.html">Introdução à Tecnologia Java EE</a></li>
<li><a href="../web/jsf20-support.html">Suporte a JSF 2.x no NetBeans IDE</a></li>
<li><a href="../../trails/java-ee.html">Trilha de Aprendizado do Java EE e Java Web</a></li>
</ul>
<p>Você pode encontrar mais informações sobre o uso das tecnologias Java EE 6 para desenvolver aplicações no <a href="http://download.oracle.com/javaee/7/tutorial/doc/">Tutorial do Java EE 7</a>.</p>
<p>Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento do Java EE do NetBeans IDE, <a href="../../../community/lists/top.html">inscreva-se na lista de correspondência de nbj2ee</a>.</p>
</body>
</html>