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 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 Java EE Patterns and Best Practices i al seu llibre "Real World Java EE Patterns - Rethinking Best Practices", disponible a http://press.adam-bien.com.

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

Exercicis de la guia d'aprenentatge

El contingut d'aquesta pàgina s'aplica al IDE NetBeans 7.1

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

Programari o Recurs Versió necessària
IDE NetBeans 6.8, versió Java
Kit de desenvolupament de Kava (JDK) versió 6
GlassFish Server Open Source Edition 3.0.1

Nota. 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.)
  5. Establiu el servidor a GlassFish v3 i establiu la versió de Java EE a Java EE 6 web. Cliqueu a Següent.
    Assistent nou projecte
  6. 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.

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

  7. Cliqueu a Crear, en l'assistent Nova unitat de persistència.
  8. 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).

  9. En l'editor, afegiu el camp message (en negreta) després del camp id.
    private Long id;
    private String message;
  10. Cliqueu amb el botó dret a l'editor i seleccioneu Inserir codi (Ctrl+I) i després seleccioneu Getter i Setter.
  11. 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.

    Assistent crear unitat de persistència
  12. 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'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.

    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.

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

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

  4. Escriviu my.presentation pel paquet.
  5. 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.

  6. Establir l'Àmbit a Petició. Cliqueu a Finalitzar
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.

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.

@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.
    Diàleg Cridar Bean empresarial

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

    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;
    }
    
  4. Afegiu el següent codi a la classe.
        // 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";
        }
    
  5. 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>.
    <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.

    Auto-completat de codi en l'editor de codi
  3. 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>.
    <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.

  2. Escriviu un missatge en el camp de text. Cliqueu a Enviar missatge.
    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.

Aplicació en el navegador mostrant resultats

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:

Podeu trobar més informació quant a la utilització de tecnologies Java EE 6 per a desenvolupar aplicacions en la 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, uniu-vos a la llita de correu nbj2ee.

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo