// 
//     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 ao Suporte para a Tecnologia Java EE no NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Introdução ao Suporte para a Tecnologia Java EE no NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Introdução ao Suporte para a Tecnologia Java EE no NetBeans IDE

O NetBeans IDE foi desenvolvido em cooperação estreita com as equipes do Java EE e do GlassFish para oferecer a maior integração e a de mais fácil uso possível da especificação Java EE. O NetBeans IDE é a melhor maneira de aprender rapidamente e se tornar produtivo em programação Java EE.

Este documento oferece uma introdução aos conceitos principais das especificações Java EE e de como eles se relacionam com sua programação prática. Os seguintes tópicos são tratados:

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"]

* <<annotations,Anotações Em Vez de Descritores de Implantação>>
* <<ejb,Desenvolvimento Simplificado do Software EJB>>
* <<injection,Uso de Injeção de Dependência para Acessar Recursos>>
* <<persistence,Modelo da Java Persistence API>>
* <<webservice,Web Services>>

Você pode encontrar mais informações sobre o desenvolvimento e a implantação de aplicações Java EE no link:http://download.oracle.com/javaee/7/tutorial/doc/[+Tutorial do Java EE 7 +] e no link:http://download.oracle.com/javaee/6/tutorial/doc/[+Tutorial do Java EE 6+].


== Anotações Em Vez de Descritores de Implantação

A plataforma Java EE simplifica a implantação removendo a necessidade de descritores de implantação, exceto do descritor de implantação de que a especificação do servlet necessita, o arquivo  ``web.xml`` . Outros descritores de implantação, como o  ``ejb-jar.xml``  e entradas relacionadas aos Web services no  ``web.xml`` , estão obsoletos. Os descritores de implantação do J2EE 1.4 eram, em geral, complexos e era fácil cometer erros ao preenchê-los. Em vez disso, a plataforma Java EE usa “anotações”. Anotações são modificadores Java, semelhantes a  ``público``  e  ``privado``  que você especifica no código. Por exemplo, a especificação EJB 3, que é um subconjunto da especificação Java EE, define anotações para o tipo de bean, tipo de interface, referências de recurso, atributos de transação, segurança e mais. Um conjunto de anotações semelhante é fornecido para Web services pela especificação JAX-WS 2.0. Algumas anotações são usadas para gerar artefatos. Outras são usadas para documentar seu código. Outras ainda fornecem serviços melhorados, como segurança ou lógica específica do runtime. Em resumo, a plataforma Java EE fornece anotações para as seguintes tarefas, entre outras:

* Definindo e usando Web services
* Desenvolvendo aplicações do software EJB
* Mapeando classes da tecnologia Java para XML
* Mapeando classes da tecnologia Java para bancos de dados
* Mapeando métodos para operações
* Especificando dependências externas
* Especificando informações de implantação, inclusive atributos de segurança

Anotações são marcadas com um caractere  ``@`` . No IDE, quando você cria um tipo que faz uso de anotações no Java EE, placeholders relacionados são fornecidos no código gerado. Por exemplo, quando você usa o IDE para criar um Bean de sessão sem estado, é gerado o código abaixo, que inclui a anotação  ``@Stateless()`` :


[source,java]
----

package mypackage;

import javax.ejb.*;

@Stateless()
public class HelloWorldSessionBean implements mypackage.HelloWorldSessionLocal {

}
----

A funcionalidade autocompletar código oferece acesso a atributos de anotação específicos do item sob o cursor. Por exemplo, quando você pressiona Ctrl-Espaço nos parênteses de uma anotação  ``@WebService()`` , você vê o seguinte:

image::images/jax-ws-annotate.png[]

Cada atributo tem valores default. Portanto, não é necessário especificar nenhum atributo, a não ser que você deseje usar um valor diferente do valor default. Em casos simples, o valor default é suficiente, o que significa que você nem sequer precisa fornecer atributos.


== Desenvolvimento Simplificado do Software EJB

A nova API do EJB 3.0 facilita o desenvolvimento do software ao reduzir e simplificar a quantidade de trabalho exigida do desenvolvedor. Em outras palavras, menos classes e menos código. Isso é possível porque uma quantidade maior do trabalho é agora executada pelo contêiner. Eis algumas das funcionalidades e benefícios do EJB 3:

* *Menos classes e interfaces necessárias.* Não é mais necessário interfaces home e de objeto para componentes do EJB, pois o contêiner é agora responsável por expor os métodos necessários. É necessário somente fornecer a interface de negócio. Você pode usar anotações para declarar componentes EJB e o contêiner irá gerenciar as transações.
* *Não há mais descritor de implantação.* Você pode usar anotações diretamente na classe para informar ao contêiner sobre as dependências e a configuração que definiu anteriormente nos descritores de implantação. Se não houver instruções específicas, o contêiner usará regras default para tratar as situações mais comuns.
* *Pesquisas simples.* O `Contexto EJBC` permite pesquisar objetos no espaço para nomes JNDI diretamente na classe.
* *Mapeamento relacional de objeto simplificado.* A nova Java Persistence API torna o mapeamento relacional de objeto muito mais simples e transparente, permitindo usar anotações em POJOs para mapear objetos Java para bancos de dados relacionais.

No IDE, você pode codificar enterprise beans como codificaria outras classes Java, usando a funcionalidade autocompletar código e dicas do editor para implementar os métodos corretos e manter as classes em sincronia com as interfaces. Não é necessário usar comando e caixas de diálogo especiais para gerar coisas como métodos de negócios ou operações de Web service, embora os comandos ainda estejam disponíveis para ajudar você a se familiarizar com a sintaxe de código do Java EE.


== Uso de Injeção de Dependência para Acessar Recursos

A _Injeção de dependência_ permite que um objeto use anotações para solicitar recursos externos diretamente. Isso resulta em código mais limpo, porque não é mais necessário sobrecarregar o código com a criação de recursos e código de pesquisa. Você pode usar injeção de recursos em componentes do EJB, contêiner Web e clientes.

Para solicitar a injeção de um recurso, um componente usa a anotação `@Resource` ou, no caso de alguns recursos especializados, as anotações `@EJB` e `@WebServiceRef`. Entre os recursos que podem ser injetados estão:

* Objeto `SessionContext`
* Objeto `DataSources`
* Objeto `EntityManager`
* Outros enterprise beans
* Web services
* Filas de mensagens e tópicos
* Fábricas de conexão para adaptadores de recursos

No IDE, o Editor de Código-Fonte fornece funcionalidade autocompletar código completa para anotações de injeção de recursos fornecidas pela plataforma Java EE. Além disso, o IDE injeta automaticamente recursos nos arquivos quando você executa comandos como Chamar EJB e Usar Banco de dados.


== Modelo da Java Persistence API

A plataforma Java EE introduz a Java Persistence API, que foi desenvolvida como parte do link:http://jcp.org/en/jsr/detail?id=220[+JSR-220+]. A Java Persistence API também pode ser usada fora de componentes EJB, por exemplo em aplicações web e aplicações web clientes e também fora da plataforma Java EE, em aplicações Java SE.

A Java Persistence API tem as seguintes funcionalidades-chave:

* *Entidades são POJOs.* Diferente de componentes EJB, que usavam persistência gerenciada por contêiner (CMP), objetos de entidade que usam as novas APIs não são mais componentes e não precisam mais estar em um módulo EJB.
* *Mapeamento relacional de objeto padronizado.* A nova especificação padroniza como o mapeamento relacional de objeto é tratado, liberando o desenvolvedor de aprender estratégicas específicas do fornecedor. A Java Persistence API usa anotações para especificar informações do mapeamento relacional de objeto, mas ainda oferece suporte a descritores XML.
* *Consultas nomeadas.* Uma consulta nomeada é agora uma consulta estática expressa em metadados. A consulta pode ser uma consulta da Java Persistence API ou uma consulta nativa. Isto simplifica muito a reutilização de consultas.
* *Regras simples de encapsulamento.* Como os beans de entidade são classes de tecnologia Java simples, eles podem ser encapsulados virtualmente em qualquer lugar em uma aplicação Java EE. Por exemplo, beans de entidade podem fazer parte de um `JAR` de EJB, `JAR` de cliente de aplicação, `WEB-INF/lib`, `WEB-INF/classes`, ou mesmo parte de um `JAR` de utilitário em um arquivo compactado de aplicação corporativa (EAR). Com essas regras de encapsulamento simples, não é mais necessário fazer com que um arquivo EAR use beans de entidade de uma aplicação web ou de um cliente de aplicação.
* *Entidades desanexadas.* Como os beans de entidade são POJOs, eles podem ser serializados e enviados pela rede para um espaço de endereço diferente e usados em um ambiente sem relação com a persistência. Como resultado, não é mais necessário usar objetos de transferência de dados (DTOs).
* *API EntityManager.* Os programadores de aplicações agora usam uma API EntityManager para executar operações `Create Read Update Delete` (CRUD) que envolvem entidades.

O IDE oferece ferramentas para trabalhar com a nova Java Persistence API. Você pode gerar classes de entidade automaticamente de um banco de dados ou classes de entidade de código manualmente. O IDE também fornece modelos e editores de gráfico para criar e manter unidades de persistência. Consulte link:javaee-gettingstarted.html[+Conceitos Básicos sobre Aplicações Java EE+] para obter mais informações sobre o uso da Java Persistence API.


== Web Services

Na plataforma Java EE , o uso de anotações aperfeiçoou e simplificou bastante o suporte de Web services. As especificações seguintes contribuíram para esta área: JSR 224, Java API para Web Services Baseados em XML (JAX-WS) 2.0; JSR 222, Arquitetura Java para Vinculação de XML (JAXB) 2.0; e JSR 181, Metadados de Web Services para a Plataforma Java.


=== JAX-WS 2.0

O JAX-WS 2.0 é a nova API para Web services na plataforma Java EE. Como um sucessor do JAX-RPC 1.1, o JAX-WS 2.0 mantém o modelo de programação RPC natural, enquanto se aprimora em vários sentidos: vinculação de dados, protocolo e independência de transporte, suporte ao estilo `REST` de Web services, e facilidade de desenvolvimento.

Uma diferença crucial do JAX-RPC 1.1 é que toda a vinculação de dados foi agora delegada ao JAXB 2.0. Isso permite aos Web services baseados em JAX-WS utilizar 100% de Esquema XML, o que resulta em melhor interoperabilidade e facilidade de uso. As duas tecnologias são bem integradas, de modo que os usuários não precisam manipular dois conjuntos de ferramentas. Ao iniciar usando classes da tecnologia Java, o JAXB 2.0 pode gerar documentos do Esquema XML que são incorporados automaticamente a um documento de Web Service Description Language (WSDL), de maneira que os usuários não precisam executar manualmente esta integração propensa a erros.

Pronta para ser utilizado, o JAX-WS 2.0 oferece suporte aos protocolos SOAP 1.1, SOAP 1.2 e XML/HTTP. A extensibilidade de protocolos foi uma meta desde o início, e o JAX-WS 2.0 permite que os fornecedores ofereçam suporte a protocolos e codificações adicionais para um melhor desempenho -- por exemplo, o FAST Infoset -- ou a aplicações especializadas. Os Web services que usam anexos para otimizar o envio e o recebimento de dados binários grandes podem aproveitar o MTOM/XOP (abreviatura de mecanismo de otimização de transmissão de mensagens/pacote otimizado binário XML) padronizado de W3C sem qualquer efeito adverso sobre o modelo de programação. (Veja esta página para obter informações sobre link:http://www.w3.org/TR/2005/REC-soap12-mtom-20050125/[+MTOM/XOP+].) Antes da tecnologia Java EE , a definição de um Web service requeria descritores longos e difíceis de manejar. Agora é fácil como colocar a anotação `@WebService` em uma classe de tecnologia Java. Todos os métodos públicos na classe são publicados automaticamente como operações de Web service e todos os argumentos são mapeados para tipos de dados do Esquema XML usando o JAXB 2.0.


=== Web Services Assíncronos

Como as chamadas de Web service ocorrem em uma rede, podem ter uma duração de tempo imprevisível. Muitos clientes, principalmente os interativos, como aplicações de área de trabalho baseadas em JFC/Swing, experimentam séria degradação de desempenho por terem de aguardar uma resposta do servidor. Para evitar essa degradação, o JAX-WS 2.0 fornece uma nova API de cliente assíncrona. Com esta API, os programadores de aplicações já não precisam criar trheads sozinhos. Em vez disso, podem confiar no runtime do JAX-WS para gerenciar chamadas remotas de longa duração.

Os métodos assíncronos podem ser usados juntamente com qualquer interface gerada por WSDL, assim como com a API `Dispatch` mais dinâmica. Para sua conveniência, ao importar um documento WSDL, você pode precisar que métodos assíncronos sejam gerados por qualquer uma das operações definidas pelo Web service.

Existem dois modelos de uso:

* No modelo de sondagem, você faz uma chamada. Quando está preparado, você solicita os resultados.
* No modelo de retorno de chamada, você registra um handler. Assim que a resposta chega, você é notificado.

Observe que o suporte de chamada assíncrona não é totalmente implementado no lado do cliente, de maneira que nenhuma alteração é necessária no Web service de destino.

O IDE oferece ferramentas para trabalhar com o JAX-WS. Você pode usar modelos no assistente Novo Arquivo para gerar artefatos JAX-WS. Os Web services assíncronos podem ser criados por meio de um editor de Personalização de Web Service. A funcionalidade autocompletar código inclui anotações que você pode utilizar nos Web services.


link:/about/contact_form.html?to=3&subject=Feedback:%20Intro%20to%20Java%20EE%205%20Technology[+Enviar Feedback neste Tutorial+]


== Próximas Etapas

Para obter mais informações sobre o uso do NetBeans IDE para desenvolver aplicações Java EE, consulte os seguintes recursos:

* link:javaee-gettingstarted.html[+Conceitos Básicos sobre Aplicações do Java EE+]
* link:../websvc/jax-ws.html[+Introdução aos Web Services JAX-WS+]
* link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+]

Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento Java EE do NetBeans IDE, link:../../../community/lists/top.html[+inscreva-se na lista de correio nbj2ee@netbeans.org+].