Google Git
Sign in
apache / netbeans-website / 44443f9641a4bc18331d3d9c0e0f178c417e52be / . / netbeans.apache.org / src / content / kb / docs / javaee / javaee-gettingstarted_pt_BR.asciidoc
blob: c30dd736b6e1c0bbc59b01f0c6c6a485634db617 [file] [log] [blame]
//
// 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.
//
= Introdução às Aplicações Java EE
:jbake-type: tutorial
:jbake-tags: tutorials
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Introdução às Aplicações Java EE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Introdução às Aplicações Java EE
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.
Este tutorial é baseado no post do blog link: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+] de Adam Bien. Você pode encontrar exemplos adicionais de Java EE no projeto do Kenai de Adam Bien link:http://kenai.com/projects/javaee-patterns[+ Java EE Patterns and Best Practices+] e no seu livro "Real World Java EE Patterns - Rethinking Best Practices", disponível em link:http://press.adam-bien.com[+http://press.adam-bien.com+].
*Exercícios do Tutorial*
* <<Exercise_1,Criando o Projeto de Aplicação Web>>
* <<Exercise_2,Criando a Classe de Entidade e a Fachada de Sessão>>
* <<Exercise_2a,Criando a Classe de Entidade>>
* <<Exercise_2b,Criando a Fachada da Sessão>>
* <<Exercise_3,Criando as Páginas Bean Gerenciado JSF e JSF>>
* <<Exercise_3a,Criando o Bean Gerenciado>>
* <<Exercise_3b,Modificando a Página de Índice>>
* <<Exercise_3c,Criando a Página de Resultados>>
* <<Exercise_4,Executando o Projeto>>
* <<Exercise_5,Fazendo Download do Projeto da Solução>>
*Para seguir este tutorial, são necessários os recursos e o software a seguir.*
|===
|Software ou Recurso |Versão Necessária
|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Versão 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)+] |versão 7 ou 8
|GlassFish Server Open Source Edition |3.x, 4.x
|===
*Pré-requisitos*
Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas:
* Programação em Java
* NetBeans IDE
Você pode fazer download link:https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App72.zip[+de um arquivo compactado zip do projeto finalizado+].
== Criando o Projeto de Aplicação Web
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.
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).
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.
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal.
2. Selecione Aplicação Web na categoria Java Web e clique em Próximo.
3. Digite *SimpleEE6App* como o nome do projeto e defina a localização do projeto.
4. Desmarque a opção Usar Pasta Dedicada, se ela estiver selecionada. Clique em Próximo.
(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).
. 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.
image::images/newappwizard.png[title="Painel Servidor e Definições no assistente Novo Projeto"]
. Selecione JavaServer Faces no painel Frameworks. Clique em Finalizar.
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.
image::images/newappwizard2.png[title="Painel Frameworks no assistente Novo Projeto"]
Quando você clica em Finalizar, o IDE cria o projeto e o abre na janela Projetos. O IDE cria automaticamente a página ``index.xhtml`` e abre a página no editor.
== Criando a Classe de Entidade e a Fachada de Sessão
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 ``@Entity`` . 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.
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.
Para obter mais informações sobre o uso do EJB 3.1 no IDE, consulte o tutorial link:javaee-entapp-ejb.html[+Criando uma Aplicação Corporativa com o EJB 3.1+].
Para saber mais sobre classes de entidade, consulte o capítulo link:http://docs.oracle.com/javaee/7/tutorial/doc/persistence-intro.htm[+Introdução à Java Persistence API+] no link:http://download.oracle.com/javaee/7/tutorial/doc/[+Tutorial do Java EE 7+].
Para obter mais informações sobre beans de sessão, consulte o capítulo link:http://docs.oracle.com/javaee/7/tutorial/doc/ejb-intro002.htm[+O que é um Bean de Sessão?+] no link:http://download.oracle.com/javaee/7/tutorial/doc/[+Tutorial do Java EE 7+].
=== Criando a Classe de Entidade
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.
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 ``id`` e anota o campo com a anotação ``@Id`` para declarar o campo como a chave primária. O IDE também adiciona a anotação ``@GeneratedValue`` e especifica a estratégia de geração de chave para o campo de id primário.
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.
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.
Para criar a classe de entidade, execute as seguintes etapas.
1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
2. Selecione Classe de Entidade na categoria Persistência. Clique em Próximo.
3. Digite *Message* como o nome da classe.
4. Digite *entities* para o Pacote.
5. Selecione Criar Unidade de Persistência. Clique em Próximo.
6. Selecione uma fonte de dados (por exemplo, selecione ``jdbc/sample`` se desejar utilizar o JavaDB).
A fonte de dados para ``jdbc/sample`` é 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.
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.
. Clique em Finalizar no assistente Nova Classe de Entidade.
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 ``private Long id;`` e anotou o campo com ``@Id`` e ``@GeneratedValue(strategy = GenerationType.AUTO)`` .
. No editor, adicione o campo ``mensagem`` (em negrito) abaixo do campo ``id`` .
[source,java]
----
private Long id;
*private String message;*
----
. 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.
. Na caixa de diálogo Gerar Getters e Setters, selecione o campo ``mensagem`` e clique em Gerar.
O IDE gera os métodos getter e setter para o campo ``mensagem`` .
image::images/getters-dialog.png[title="Assistente Criar Unidade de Persistência"]
. Salve as alterações.
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 ``id`` e ``mensagem`` .
Se examinar a unidade de persistência no editor XML, verá que a aplicação utilizará a API de Transação Java (JTA) ( ``transaction-type="JTA"`` ). 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 link:http://www.oracle.com/technetwork/java/javaee/jta/index.html[+API de Transação Java+].
=== Criando a Fachada da Sessão
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.
Para criar o bean da sessão, execute as seguintes etapas.
1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
2. Selecione Beans de Sessão para Classes de Entidade na categoria Enterprise JavaBeans. Clique em Próximo.
3. Selecione a entidade ``Mensagem`` e clique em Adicionar. Clique em Próximo.
4. Digite *boundary* para o pacote. Clique em Finalizar.
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.
image::images/sessionwizard.png[title="Assistente Beans de Sessão para Classes de Entidade"]
Quando você clica em Finalizar, o IDE gera a classe de fachada da sessão ``MessageFacade.java`` e ``AbstractFacade.java`` e abre os arquivos no editor. Como podemos ver no código gerado, a anotação ``@Stateless`` é usada para declarar a classe ``MessageFacade.java`` como um componente de bean de sessão sem estado. ``MessageFacade.java`` estende ``AbstractFacade.java`` , que contém a lógica de negócio e gerencia a transação.
[source,java]
----
@Stateless
public class MessageFacade extends AbstractFacade<Message> {
@PersistenceContext(unitName = "SimpleEE6AppPU")
private EntityManager em;
----
Quando você cria a fachada para a entidade utilizando o assistente, como default, o IDE adiciona a anotação ``PersistenceContext`` ( ``@PersistenceContext(unitName = "SimpleEE6AppPU")`` ) 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.
O IDE também gera métodos em ``AbstractFacade.java`` 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 ``findAll`` , ``findRange`` e ``count`` 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.
== Criando as Páginas Bean Gerenciado JSF e JSF
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 ``@ManagedBean`` em seu código-fonte para declarar uma classe como bean gerenciado. Não é mais necessário adicionar entradas no arquivo ``faces-config.xml`` para declarar beans gerenciados JSF. Você pode utilizar nomes de beans em páginas JSF para acessar métodos no bean gerenciado.
Para obter mais informações sobre o suporte do IDE para a especificação JavaServer Faces 2.x, consulte link:../web/jsf20-support.html[+Suporte JSF 2.x no NetBeans IDE+].
Para obter mais informações sobre a especificação JavaServer Faces 2.x, consulte o capítulo link:http://docs.oracle.com/javaee/7/tutorial/doc/jsf-intro.htm[+Tecnologia do JavaServer Faces+] no Tutorial Java EE 7.
=== Criando o Bean Gerenciado
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.
Para criar o bean gerenciado, execute as seguintes etapas:
1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
2. Selecione Bean Gerenciado pelo JSF na categoria JavaServer Faces. Clique em Próximo.
3. Digite *MessageView* para o Nome da Classe.
Você utilizará o bean gerenciado de nome ``MessageView`` como o valor para ``inputText`` e ``commandButton`` na página JSF ``index.xhtml`` ao chamar métodos no bean.
. Digite *my.presentation* para o Pacote.
. Digite *MessageView* para o Nome que será utilizado para o bean gerenciado.
NOTE: 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á ``MessageView`` , em vez de ``messageView`` . Se você não tiver designado o nome explicitamente, deverá usar ``messageView`` default na página JSF.
. Defina Escopo como Requisição. Clique em Finalizar.
image::images/newjsfbean.png[title="Novo assistente de Bean Gerenciado pelo JSF"]
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.
image::images/projectswindow.png[title="Janela Projeto que mostra estrutura de arquivos"]
No editor, você pode ver que o IDE adicionou as anotações ``@ManagedBean`` e ``@RequestScoped`` e o nome do bean.
[source,java]
----
@ManagedBean(name="MessageView")
@RequestScoped
public class MessageView {
/** Creates a new instance of MessageView */
public MessageView() {
}
}
----
Agora, você adicionará uma anotação ``@EJB`` 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 ``findAll`` e ``create`` que estão expostos na fachada. A funcionalidade autocompletar código do IDE pode ajudá-lo enquanto você digita os métodos.
1. 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.
2. Selecione MessagFacade na caixa de diálogo Chamar Enterprise Bean. Clique em OK.
image::images/callbean.png[title="Caixa de diálogo Chamar Enterprise Bean"]
Quando você clica em OK, o IDE adiciona o seguinte código (em negrito) para injetar o bean.
[source,java]
----
public class MessageView {
/** Creates a new instance of MessageView */
public MessageView() {
}
// Injects the MessageFacade session bean using the @EJB annotation
*@EJB
private MessageFacade messageFacade;*
}
----
. Adicione o código a seguir para criar uma nova instância.
[source,java]
----
/** Creates a new instance of MessageView */
public MessageView() {
this.message = new Message();
}
----
. Adicione o seguinte código à classe.
[source,java]
----
// 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";
}
----
. 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.
Você pode utilizar a funcionalidade para autocompletar código no editor para ajudar a digitar seu código.
Observe que o método ``postMessage`` 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 ``faces-config.xml`` . 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 ``theend.xhtml`` quando o método ``postMessage`` for chamado.
=== Modificando a Página de Índice
Neste exercício, você fará algumas alterações simples na página ``index.xhtml`` para adicionar alguns componentes de interface do usuário. Você adicionará um form com um campo de entrada de texto e um botão.
1. Abra o ``index.xhtml`` no editor.
2. Modifique o arquivo para adicionar o seguinte form simples entre as tags ``<h:body>`` .
[source,xml]
----
<h:body>
*<f:view>
<h:form>
<h:outputLabel value="Message:"/><h:inputText value="#{MessageView.message.message}"/>
<h:commandButton action="#{MessageView.postMessage}" value="Post Message"/>
</h:form>
</f:view>*
</h:body>
----
A funcionalidade autocompletar código JSF pode ajudá-lo ao digitar o código.
image::images/jsfcodecompletion1.png[title="Autocompletar código no editor de código-fonte"]
NOTE: Se você copiar e colar o código no arquivo, receberá uma advertência na margem esquerda ao lado da linha que contém ``<f:view>`` . 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 ``xmlns:f="http://xmlns.jcp.org/jsf/core"`` .
. Salve as alterações.
Os componentes ``inputText`` e ``commandButton`` chamarão os métodos no bean gerenciado JSF nomeado ``MessageView`` . O método ``postMessage`` retornará "theend" e o handler de navegação procurará por uma página nomeada ``theend.xhtml`` .
=== Criando a Página de Resultados
Neste exercício, você criará a página JSF ``theend.xhtml`` . A página será exibida quando o usuário clicar no botão Postar Mensagem no ``index.xhtml`` e chamar o método ``postMessage`` no bean gerenciado JSF.
1. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
2. Selecione a Página JSF na categoria JavaServer Faces. Clique em Próximo.
3. Digite *theend* como o Nome do Arquivo.
4. Certifique-se de que a opção Facelets esteja selecionada. Clique em Finalizar.
image::images/result-jsf-page.png[title="Criando o arquivo JSF theend no assistente Novo Arquivo JSF"]
. Modifique o arquivo digitando o seguinte entre as tags <h:body>.
[source,xml]
----
<h:body>
*<h:outputLabel value="Thanks! There are "/>
<h:outputText value="#{MessageView.numberOfMessages}"/>
<h:outputLabel value=" messages!"/>*
</h:body>
----
Quando você começa a digitar, o IDE adiciona automaticamente a definição de biblioteca de tags ``xmlns:h="http://xmlns.jcp.org/jsf/html"`` ao arquivo para os elementos JSF.
== Executando a Aplicação
Você agora finalizou a codificação da aplicação. Agora você pode testar a aplicação no browser.
1. Clique com o botão direito do mouse no nó na janela Projetos e selecione Executar.
Quando você seleciona Executar, o IDE constrói e implanta a aplicação e abre o ``index.xhtml`` no browser.
. Digite uma mensagem no campo de texto. Clique em Postar Mensagem.
image::images/browser1.png[title="Aplicação no browser"]
Quando você clica em Postar Mensagem, a mensagem será salva no banco de dados e o número de mensagens será recuperado e exibido.
image::images/browser2.png[title="Aplicação no browser mostrando resultados"]
== Fazendo Download do Projeto da Solução
Você pode fazer o download dos projetos de amostra usados neste tutorial das seguintes formas:
* Faça download link:https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App72.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.
. Clique em Procurar para abrir a caixa de diálogo Procurar Pastas do Repositório.
. Expanda o nó de raiz e selecione *samples/javaee/SimpleEE6App*. Clique em OK.
. Especifique a Pasta Local para o códigos-fonte (a pasta local precisa estar vazia).
. 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.
. Clique em Abrir Projeto na caixa de diálogo exibida quando o check-out for concluído.
*Observações.*
* É necessário um cliente Subversion para verificar os códigos-fonte. 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+].
link:/about/contact_form.html?to=3&subject=Feedback:%20Getting%20Started%20with%20Java%20EE%206%20Applications[+Enviar Feedback neste Tutorial+]
== Consulte Também
Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java EE, consulte os seguintes recursos:
* link:javaee-intro.html[+Introdução à Tecnologia Java EE+]
* link:../web/jsf20-support.html[+Suporte a JSF 2.x no NetBeans IDE+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]
Você pode encontrar mais informações sobre o uso das tecnologias Java EE 6 para desenvolver aplicações no link:http://download.oracle.com/javaee/7/tutorial/doc/[+Tutorial do Java EE 7+].
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, link:../../../community/lists/top.html[+inscreva-se na lista de correspondência de nbj2ee+].