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

= Com començar amb aplicacions Java EE 6
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Com començar amb aplicacions Java EE 6 - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Com començar amb aplicacions Java EE 6

aquest document proporciona un breu introducció a algunes de les característiques introduïdes com a part de l'especificació de l'edició empresarial de Java 6 (Java EE 6). Per il·lustrar les noves característiques, aquest tutoria demostrarà com crear una aplicació web senzilla de Java EE 6 web que conté un bean de sessió sense-estat EJB 3.1 en la part frontal d'una classe d'entitat. Utilitzareu l'assistent al IDE per generar una classe d'entitat i un bean de sessió. El codi generat per l'assistent utilitza consultes que estan definides en l'API Criteria que forma part de JPA 2.0 i que està contemplada en l'especificació de Java EE 6. Després creareu un bean gestionat amb nom que accedeixi a la part frontal de la sessió i al disseny de presentació que utilitza el Framework de visualització Facelets com s'especifica en JSF 2.0.

Aquesta guia d'aprenentatge està basada en l'entrada del 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+] per Adam Bien. Podeu trobar exemples addicionals de Java EE al projecte kenai d'Adam Bien link:http://kenai.com/projects/javaee-patterns[+ Java EE Patterns and Best Practices+] i al seu llibre "Real World Java EE Patterns - Rethinking Best Practices", disponible a link:http://press.adam-bien.com[+http://press.adam-bien.com+].

Aquest document utilitza el llançament de l'IDE NetBeans 6.8.

*Exercicis de la guia d'aprenentatge*


* <<Exercise_1,Creant el projecte d'aplicació Web>>
* <<Exercise_2,Creant la classe d'entitat i la part frontal de la sessió>>
* <<Exercise_2a,Creant la classes d'entitat>>
* <<Exercise_2b,Creant la part frontal de la sessió>>
* <<Exercise_3,Creant el Bean gestionat JSF i les pàgines JSF>>
* <<Exercise_3a,Creant el Bean gestionat>>
* <<Exercise_3b,Modificant la pàgina d'índex>>
* <<Exercise_3c,Creant la pàgina de resultats>>
* <<Exercise_4,Executant el projecte>>

*Per seguir aquesta guia d'aprenentatge, necessiteu el següent programari i recursos.*

|===
|Programari o Recurs |Versió necessària 

|link:https://netbeans.org/downloads/index.html[+IDE NetBeans+] |6.8, versió Java 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Kit de desenvolupament de Kava (JDK)+] |versió 6 

|GlassFish Server Open Source Edition |3.0.1 
|===

NOTE:  GlassFish V3 necessita el kit de desenvolupament de Java (JDK) 6.

*Prerequisits*

Aquest document assumeix que teniu un coneixement bàsic de, o experiència de programació amb, les següent tecnologies:

* Programació Java
* IDE NetBeans


== Creant el projecte d'aplicació Web

En aquest exercici creareu una aplicació web senzilla. Quant creeu l'aplicació web especificareu el servidor d'aplicacions GlassFish v3 com a objectiu del contenidor Java EE. El servidor d'aplicacions GlassFish v3 és compatible amb Java EE i inclou les biblioteques JSF 2.0 que es necessiten en aquesta aplicació.

En l'assistent de nou projecte seleccionareu Java EE 6 web com la versió de Java EE. Java EE 6 Web és un perfil Java EE 6 lleuger que conté un subconjunt de la plataforma sencera de Java EE 6. El perfil Java EE 6 Web està dissenyat per a aplicacions web que no necessiten tecnologies avançades de Java EE 6 com el suport per a interfícies remotes, tota l'especificació de EJB 3.1 i l'API de servei de missatges Java (JMS, de l'anglès Java Message Service).

El perfil Web suporta el processament de la transacció i la gestió de persistència que són utilitzats de freqüentment en aplicacions web empresarials. Podeu utilitzar el perfil Java EE Web per aplicacions web que utilitzen beans de sessió amb interfície local o sense interfície. El perfil Java EE sencer es requerit si l'aplicació utilitza una interfície remota.

1. Seleccioneu Fitxer > Nou projecte (Ctrl-Maj-N) des del menú principal.
2. Seleccioneu Aplicació Web des de la categoria Java Web i cliqueu a Següent.
3. Escriviu *SimpleEE6App* pel nom del projecte i establiu una localització per al projecte.
4. Desmarqueu l'opció Utilitzar un directori dedicat per emmagatzemar biblioteques, si estès seleccionat. Cliqueu a Següent.
(Per aquesta guia d'aprenentatge no hi ha cap raó de pes per copiar les biblioteques del projecte a una carpeta dedicada perquè no necessitareu compartir les biblioteques amb altres usuaris o projectes.)


. Establiu el servidor a GlassFish v3 i establiu la versió de Java EE a Java EE 6 web. Cliqueu a Següent.

image::../../../images_www/articles/71/javaee/gettingstarted/newappwizard.png[title="panell servidor i preferències en l'assistent de nou projecte"]


. Seleccioneu JavaServer Faces en el panell de Frameworks. Cliqueu a Finalitzar

Per defecte, si esteu desenvolupant una aplicació web Java EE 6 i desplegant a GlassFish V3, l'IDE seleccionarà la biblioteca JSF2.0. La biblioteca JSF 2.0 us permet utilitzar Facelets com a llenguatge de la pàgina i també proporciona suport per a JSF 1.2 i JSP.

image::../../../images_www/articles/71/javaee/gettingstarted/newappwizard2.png[title="panell Frameworks en l'assistent de nou projecte"]

Quant cliqueu a Finalitzar, l'IDE crea el projecte i l'obre en la finestra de projectes. El IDE crea automàticament la pàgina JSF  ``index.xhtml``  i l'obre en l'editor.


== Creant la classe d'entitat i la part frontal de la sessió

En aquesta secció creareu una classe d'entitat i la part frontal de la sessió per a la classe d'entitat. Una classe d'entitat és un objecte Java antic i planer (POJO, de l'anglès Plain Old Java Object), una classe Java senzilla que està identificada com una entitat mitjançant l'anotació  ``@Entity`` . Començant amb l'especificació Java EE 5, podeu utilitzar les classes d'entitat com a objectes persistents per a representar taules en una base de dades.

La part frontal de la sessió per la classe d'entitat en aquesta aplicació és un bean de sessió sense estat. L'arquitectura JavaBean Empresaria (EJB, de l'anglès Enterprise JavaBean) 3.1 introduïda com a part de l'especificació de Java EE 6 us permet crear beans de sessió sense les interfícies de negoci que eren necessàries en EJB 3.0. L'especificació Java EE 6 també us permet empaquetar components EJB directament en un fitxer WAR. Aquest simplifica el desenvolupament d'aplicacions web petites tot eliminant la necessitat de crear mòduls EJB separats que estan empaquetats com a arxius JAR en un arxiu EAR. Tanmateix, per a aplicacions empresarials grans que estan distribuïdes al voltant de màquines diferents, encara voldreu continuar creant arxius EAR per separar la vostra lògica de negoci de la capa de presentació.

Per a més informació quant a les classes d'entitat i persistència, vegeu el capítol *Introducció a l'API Persistència de Java* en la link:http://java.sun.com/javaee/6/docs/tutorial/doc/index.html[+Guia d'aprenentatge Java EE 6, Volum I+].

Per a més informació quant als beans de sessió, vegeu el capítol *Beans Empresarials* en la link:http://java.sun.com/javaee/6/docs/tutorial/doc/index.html[+Guia d'aprenentatge Java EE 6, Volum I+].


=== Creant la classe d'entitat

En aquest exercici utilitzareu l'assistent Nova classe d'entitat, per crear una senzilla classe d'entitat persistent. També utilitzareu l'assistent per crear una unitat de persistència que defineixi la font de dades i el gestor d'entitat utilitzats en l'aplicació. Afegireu un camp en la classe per representar les dades en la vostra taula i generar els mètodes getter i setter pel nou camp.

Una classe d'entitat ha de tenir una clau primària. Quant creeu la classe d'entitat mitjançant l'assistent, l'IDE per defecte genera el camp  ``id``  i anota el camp amb l'anotació  ``@Id``  per declarar el camp com a clau primària. El IDE també afegeix l'anotació  ``@GeneratedValue``  i especifica l'estratègia de generació de clau pel camp id primari.

Per crear la classe d'entitat. realitzeu els següent passos.

1. En el node del projecte amb un clic dret de ratolí, seleccioneu Nou > Altres.
2. Seleccioneu la classe d'entitat des de la categoria Persistència. Cliqueu a Següent.
3. Escriviu *Message* pel nom de la classe.
4. Escriviu *entities* pel paquet.
5. Cliqueu al botó Crear Unitat Persistència.
6. Seleccioneu la font de dades (per exemple, seleccioneu  ``jdbc/sample``  si voleu utilitzar JavaDB).

La font de dades per  ``jdbc/sample``  està integrada amb l'IDE quant instal·leu l'IDE i GlassFish, però podeu especificar una font de dades diferent si voleu utilitzar una base de dades diferent.

Podeu mantindre les altres opcions predeterminades (nom unitat de persistència, proveïdor de persistència EclipseLink). Comproveu que la unitat de persistència estigui utilitzant l'API de Transacció Java i que l'estratègia de generació de taula estigui establerta a Crear, ja que les tales basades en les vostres classes d'entitat són creades quant l'aplicació és desplegada.


. Cliqueu a Crear, en l'assistent Nova unitat de persistència.


. Cliqueu a Finalitzar el l'assistent de la nova classe d'entitat.

Quant cliqueu a Finalitzar, l'IDE crea la classe d'entitat i obre la classe en l'editor. Podeu veure que l'IDE ha generat el camp id  ``private Long id;``  i ha anotat el camp amb  ``@Id``  i  ``@GeneratedValue(strategy = GenerationType.AUTO)`` .


. En l'editor, afegiu el camp  ``message``  (en negreta) després del camp  ``id`` .

[source,java]
----

private Long id;
*private String message;*
----


. Cliqueu amb el botó dret a l'editor i seleccioneu Inserir codi (Ctrl+I) i després seleccioneu Getter i Setter.


. En el quadre de diàleg Generar Generate Getters i Setters, seleccioneu el camp  ``message``  i cliqueu a Generar.

El IDE genera els mètodes getter i setter pel camp  ``message`` .

image::images/getters-dialog.png[title="Assistent crear unitat de persistència"]


. Deseu els vostres canvis.

La classe d'entitat representa una taula en la base de dades. Quant executeu aquesta aplicació, es crearà automàticament una taula Message a la base de dades. La taula contindrà les columnes  ``id``  i  ``message`` .

Si observeu la unitat de persistència en l'editor XML, podeu veure que l'aplicació utilitzarà l'API de transacció Java (JTA, de l'anglès Java Transaction API) ( ``transaction-type="JTA"`` ). Això especifica que la responsabilitat del cicle de vida de les entitats en el content de persistència està assignat al contenidor. Això resulta un menor codi perquè el cicle de vida de l'entitat està gestionat pel contenidor no per l'aplicació. Per a més informació quant a la utilització de JTA per gestionar transaccions, vegeu la documentació de l'link:http://java.sun.com/javaee/technologies/jta/index.jsp[+API transacció de Java+].


=== Creant la part frontal de la sessió

En aquest execici utilitzareu un assistent per a la part frontal d'una sessió sense estat per a l'entitat Message. Les especificacions EJB 3.1. fan constar que les interfícies de negoci pels beans de sessió ara són opcionals. En aquesta aplicació on el client que accedeix al bean és un client local, teniu l'opció d'utilitzar una interfície local o una vista sense interfície per exposar el bean.

Per crear el bean de sessió, realitzeu els següent passos.

1. En el node del projecte cliqueu amb el boto dret i seleccioneu Nou > Altres.
2. Seleccioneu Beans de sessió per a classes d'entitat, des de la categoria Java EE. Cliqueu a Següent.
3. Seleccioneu l'entitat  ``Message``  i cliqueu Afegir. Cliqueu a Següent.
4. Escriviu *boundary* pel paquet. Cliqueu a Finalitzar.

Fixeu-vos que no heu necessitat crear una interfície de negoci per al bean de sessió. En canvi, en aquesta aplicació el bean serà exposat a un bean gestionat localment mitjançant una vista sense interfície.

image::images/sessionwizard.png[title="Assistent Beans de sessió per a classes d'entitat"]

Quant cliqueu a Finalitzar, la classe de la part frontal de sessió  ``MessageFacade.java``  és creada i s'obre en l'editor de codi font. La classe bean conté la lògica de negoci i gestiona l'EntityManager. Com podeu veure en el codi generat, s'utilitza l'anotació  ``@Stateless``  per declarar la classe com un component bean de sessió sense estat.


[source,java]
----

@Stateless
public class MessageFacade {
    @PersistenceContext(unitName = "SimpleEE6AppPU")
    private EntityManager em;
            
----

Quant creeu la part frontal per l'entitat mitjançant l'assistent, per defecte el IDE afegeix l'anotació  ``PersistenceContext``  ( ``@PersistenceContext(unitName = "SimpleEE6AppPU")`` ) per injectar el recurs de gestió d'entitat dins del component bean de sessió, i per especificar el nom de la unitat de persistència. En aquest exemple el nom de la unitat de persistència està declarat explícitament, no obstant el nom és opcional si l'aplicació té únicament una unitat de persistència.

El IDE també genera els mètodes en la part frontal per crear, editar, treure i trobar entitats. L'API EntityManager defineix els mètodes que s'utilitzen per interactuar amb el context de persistència. Podeu veure que l'IDE genera alguns mètodes de consulta predeterminats utilitzant freqüentment que poden ser utilitzats per a trobar objectes d'entitat.


[source,java]
----

public List<Message> findAll() {
    CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
    cq.select(cq.from(Message.class));
    return em.createQuery(cq).getResultList();
}

public List<Message> findRange(int[] range) {
    CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
    cq.select(cq.from(Message.class));
    Query q = em.createQuery(cq);
    q.setMaxResults(range[1] - range[0]);
    q.setFirstResult(range[0]);
    return q.getResultList();
}

public int count() {
    CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
    Root<Message> rt = cq.from(Message.class);
    cq.select(em.getCriteriaBuilder().count(rt));
    Query q = em.createQuery(cq);
    return ((Long) q.getSingleResult()).intValue();
}

----

Els mètodes  ``findAll`` ,  ``findRange``  i  ``count`` , utilitzen mètodes definits en l'API Criteria per a la creació de consultes. L'API Criteria API forma part de l'especificació JPA 2.0 que estàa inclosa en l'especificació Java EE 6.


== Creant el Bean gestionat JSF i les pàgines JSF

En aquesta secció creareu la capa de presentació per l'aplicació utilitzant JavaServer Faces (JSF) 2.0 i el bean gestionat que dona suport al bean que és utilitzat per les pàgines JSF. L'especificació JSF 2.0 afegeix suport per a Facelets com la tecnologia de visualització preferida per a les aplicacions basades amb JSF. Començant amb JSF 2.0, també podeu utilitzar l'anotació  ``@ManagedBean``  al vostre codi font per declarar una classe de bean gestionat. Ja no necessiteu afegir més entitats en el fitxer  ``faces-config.xml``  per declarar els bans gestionats JSF. Podeu utilitzar noms en pàgines JSF per accedir als mètodes en el bean gestionat.

Per a més informació quan al suport de l'IDE per les especificacions de JavaServer Faces 2.0, vegeu link:../web/jsf20-support.html[+Suport JSF 2.0 en l'IDE NetBeans 6.8+].

Per a més informació quant a l'especificació de JavaServer Faces 2.0, vegeu el capítol de la tecnologia JavaServer Faces en la link:http://java.sun.com/javaee/6/docs/tutorial/doc/index.html[+Guia d'aprenentatge Java EE 6, Volum I+].


=== Creant un Bean gestionat

En aquest exercici creareu un senzill bean gestionat JSF utilitzat per accedir a la part frontal de la sessió L'especificació JSF 2.0 que forma part de Java EE 6 us permet utilitzar anotacions en la classe bean per identificar la classe com un bean gestionat JSF, per especificar l'àmbit i el nom pel bean.

Per crear un bean gestionat, realitzeu els següents passos.

1. Cliqueu amb el botó dret damunt del node del projecte i seleccioneu Nou > Altres.
2. Seleccioneu Bean gestionat JSF des de la categoria JavaServer Faces. Cliqueu a Següent.
3. Escriviu *MessageView* pel nom de la classe.

Utilitzareu el nom pel bean gestionat  ``MessageView``  com el valor pel  ``inputText``  i  ``commandButton``  en la pàgina JSF  ``index.xhtml``  quant crideu els mètodes en el bean.


. Escriviu *my.presentation* pel paquet.


. Escriviu *MessageView* pel nom que serà utilitzat pel bean gestionat.

Quan creeu el bean gestionat mitjançant l'assistent, l'IDE per defecte assignarà un nom al bean basat amb el nom de la classe bean.


. Establir l'Àmbit a Petició. Cliqueu a Finalitzar

image::../../../images_www/articles/71/javaee/gettingstarted/newjsfbean.png[title="Nou assistent Bean gestionat per JSF"]

Quan cliqueu a Finalitzar, l'IDE crea la classe bean i l'obre en l'editor. En la finestra de projectes veureu els següent fitxers.

image::images/projectswindow.png[title="Finestra de projecte mostrant l'estructura de fitxers"]

En l'editor, podeu veure que l'IDE ha afegit les anotacions  ``@ManagedBean``  i  ``@RequestScoped``  i el nom del bean.


[source,java]
----

@ManagedBean(name="MessageView")
@RequestScoped
public class MessageView {

    /** Crea una nova instància de MessageView */
    public MessageView() {
    }

}

----

Ara utilitzareu la injecció de dependència per obtenir una referència al bean de sessió MessageFacade amb l'anotació  ``@EJB`` . També podreu cridar els mètodes  ``findAll``  i  ``create``  que estan exposats en la part frontal de la sessió. L'auto-completat de codi pot ajudar-vos quant escriviu els mètodes.

1. Cliqueu amb el botó dret en l'editor i seleccioneu Inserir codi (Ctrl+I) per obrir el menú emergent.
2. Seleccioneu Cridar Bean empresarial, en el menú emergent.
3. Seleccioneu MessageFacade en el quadre de diàleg Cridar Bean empresarial. Cliqueu a Acceptar.

image::images/callbean.png[title="Diàleg Cridar Bean empresarial,"]

Quan cliqueu a Acceptar, l'IDE afegeix el següent codi (en negreta) per injectar el bean.


[source,java]
----

public class MessageView {

    /** Crea una nova instància de MessageView */
    public MessageView() {
    }

    *// Injecta el bean de sessió MessageFacade utilitzant l'anotació @EJB
    @EJB
    MessageFacade messageFacade;*
}

----


. Afegiu el següent codi a la classe.

[source,java]
----

    // Crea un nou camp
    private Message message;

    // Crea una nova instància de Message
    public MessageView() {
       this.message = new Message();
    }

    // Crida a getMessage per recuperar un missatge
    public Message getMessage() {
       return message;
    }

    // Retorna el nombre total de missatges
    public int getNumberOfMessages(){
       return messageFacade.findAll().size();
    }

    // Desa el missatge i després retorna la cadena de text "theend"
    public String postMessage(){
       this.messageFacade.create(message);
       return "theend";
    }

----


. Corregiu les vostres importacions (Ctrl-Maj-I) i deseu els canvis.

Utilitzeu l'auto-completat de codi per a ajudar-vos quant escriviu el vostre codi.

Observeu que el mètode  ``postMessage``  retorna la cadena de text "theend". L'especificació de JSF 2.0 permet la utilització de regles de navegació implícita en l'aplicació que utilitza tecnologia Facelets. En aquesta aplicació, cap regla de navegació està configurada en  ``faces-config.xml`` . En lloc seu, l'encarregat de navegació intentarà localitzar una pàgina adequada en l'aplicació. En aquest cas, l'encarregat de la navegació intentarà localitzar una pàgina anomenada  ``theend.xhtml``  qual el mètode  ``postMessage``  sigui invocat.


=== Modificant la pàgina d'Índex

en aquest exercici fareu alguns canvis senzill a la pàgina  ``index.xhtml``  per afegir alguns components d'interfície gràfica (UI). Afegireu un formulari amb un camp de text d'entada i un botó.

1. Obriu  ``index.xhtml``  en l'editor.
2. Modifiqueu el fitxer per afegir el següent formulari senzill entre les etiquetes  ``<h:body>`` .

[source,xml]
----

<h:body>
    <f:view>
        <h:form>
            <h:outputLabel value="Missatge:"/><h:inputText value="#{MessageView.message.message}"/>
            <h:commandButton action="#{MessageView.postMessage}" value="Enviar missatge"/>
        </h:form>
    </f:view>
</h:body>
----

L'auto-completat de codi JSF pot ajudar-vos quant escriviu el codi.

image::images/jsfcodecompletion1.png[title="Auto-completat de codi en l'editor de codi"]


. Deseu els vostres canvis.

Els components  ``inputText``  i  ``commandButton``  invocaran els mètodes en el bean gestionat JSF anomenat  ``MessageView`` . El mètode  ``postMessage``  retornarà "theend", i l'encarregat de navegació cercarà una pàgina anomenada  ``theend.xhtml`` .


=== Creant la pàgina de resultats

En aquest exercici creareu la pàgina JSF  ``theend.xhtml`` . La pàgina es mostrarà quant l'usuari cliqui al botó Enviar missatge, en  ``index.xhtml``  i invoqui el mètode  ``postMessage``  en el bean gestionat JSF.

1. Cliqueu amb el botó dret al node del projecte i seleccioneu Nou > Altres.
2. Seleccionau Pàgina JSF, des de a categoria JavaServer. Cliqueu a Següent.
3. Escriviu *theend* com a nom de fitxer.
4. Assegureu-vos que estigui marcada l'opció Facelets. Cliqueu a Finalitzar
5. Modifiqueu el fitxer escrivint el següent entre les etiquetes <h:body>.

[source,xml]
----

<h:body>
    <h:outputLabel value="Gràcies! Hi han "/>
    <h:outputText value="#{MessageView.numberOfMessages}"/> missatges!
</h:body>
----

Quant comenceu a escriure, el IDE afegirà automàticament la definició de la biblioteca d'etiquetes  ``xmlns:h="http://java.sun.com/jsf/html``  al fitxer pels elements JSF.


== Executant l'aplicació

Ara hageu finalitzat la codificació de l'aplicació. Ara podeu provar l'aplicació al vostre navegador.

1. Cliqueu amb el botó dret en la finestra de projectes i seleccioneu Executar.

Quant seleccioneu Executar, l'IDE construeix i desplega l'aplicació i obre  ``index.xhtml``  en el vostre navegador.


. Escriviu un missatge en el camp de text. Cliqueu a Enviar missatge. 

image::images/browser1.png[title="Aplicació en el navegador"]

Quant cliqueu a Enviar missatge, el missatge és desat a la base de dades i el nombre de missatges és recuperant i mostrat.

image::images/browser2.png[title="Aplicació en el navegador mostrant resultats"] 

link:/about/contact_form.html?to=3&subject=Feedback:%20Getting%20Started%20with%20Java%20EE%206%20Applications[+Envia'ns la vostra opinió+]


== Vegeu també

Per a més informació quant a la utilització de l'IDE NetBeans per desenvolupar aplicacions Java EE, vegeu els següents recursos:

* link:javaee-intro.html[+Introducció a la tecnologia Java EE+]
* link:../web/jsf20-support.html[+Suport JSF 2.0 en NetBeans IDE 6.8+]
* link:../../trails/java-ee.html[+Camí d'aprenentatge d'aplicacions de serveis Web &amp; EJB+]

Podeu trobar més informació quant a la utilització de tecnologies Java EE 6 per a desenvolupar aplicacions en la link:http://download.oracle.com/javaee/6/tutorial/doc/[+Guia d'aprenentatge de Java EE 6+].

Per enviar comentaris i suggeriments, obtenir suport, i mantindre's informat dels últims desenvolupaments en característiques de desenvolupament Java EE al IDE NetBeans, link:../../../community/lists/top.html[+uniu-vos a la llita de correu nbj2ee+].