We wcześniejszym wpisie pokazałem, jak w prosty sposób można skonfigurować środowisko IDE. Jeśli mamy już ten etap za sobą można przystąpić do utworzenia pierwszej działającej aplikacji wykorzystującej framework JSF2 oraz technologię EJB. Oczywiście potrzebna będzie jeszcze zainstalowana lokalnie baza danych. Ja używam MySQL, który miałem zainstalowany wraz z pakietem XAMPP (Apache + MySQL + PHP + Perl).

Zaczynamy…


Po uruchomieniu Eclipsa tworzymy nowy projekt „Enterprise Application Project”. Będzie on „opakowywał” utworzone poniżej modułu (EJB oraz WAR) do pliku .ear.

Java EE - Eclipse 1

Jako Project name należy wpisać nazwę projektu np. MyApplication, resztę ustawić tak jak na slajdzie poniżej i zatwierdzić przyciskiem Finish:

Java EE - Eclipse 2

W Project Explorerze pojawi się nasz nowy projekt.

W analogiczny sposób tworzymy moduł EJB – wybierająć EJB Project, czyli:

Java EE - Eclipse 3W otwartym oknie wpisujemy nazwę modułu w polu Project name np. „MyApplication-ejb”.

Dodatkowo zaznaczamy Add project to an EAR co powoduje dodanie modułu EJB do głównego projektu aplikacji.

Java EE - Eclipse 4

Następnie 2x przycisk Next i w ostatniej części należy odznaczyć pole Create an EJB Client JAR module to hold the client interfaces and classes i zaznaczyć Generate ejb-jar.xml deployment descriptor po czym potwierdzić zmiany przyciskiem Finish.

Java EE - Eclipse 5

 

Przyszła kolej na utworzenie ostatniej już części składowej, na którą składa się projekt EAR czyli modułu JSF:

  • New -> Dynamic Web Project
    Java EE - Eclipse 6
  • W oknie, które się pojawiło jako nazwę wpisujemy „MyApplication-war” oraz zaznaczamy Add project to an EAR wybierając główny projekt „MyApplication”, zatwierdzając przyciskiem Next.Java EE - Eclipse 7
  • Następnie należy zaznaczyć Generate web.xml deployment descriptor w celu utworzenia pustego pliku deskryptora wdrożenia.Java EE - Eclipse 8
  • Akceptujemy poprzednie kroki przyciskiem Finish.

 

Następnym etapem jest skonfigurowanie datasources (źródła danych) w  JBoss’ie.

Ze strony mySQL’a pobieramy najnowsze archiwum Connector/J, na dzień dzisiejszy jest to wersja 5.1.27 (wybrałem wersję niezależną od platformy). Po wypakowaniu archiwum znajdujący się w folderze głównym plik mysql-connector-java-5.1.27-bin.jar kopiujemy do utworzonego wcześniej folderu : $JBOSS_HOME/modules/com/mysql/main. W tym samym katalogu tworzymy plik o nazwie: module.xml, o następującej zawartości:

<module xmlns="urn:jboss:module:1.0" name="com.mysql">  
   <resources>  
      <resource-root path="mysql-connector-java-5.1.27-bin.jar"/>  
   </resources>   
   <dependencies>  
      <module name="javax.api"/>  
   </dependencies>  
</module>

Kolejnym krokiem jest modyfikacja pliku standalone.xml znajdującego się się w katalogu $JBOSS_HOME/standalone/configuration/:

  1. w węźle datasources dodać lub zamienić istniejący węzeł datasource:
    <datasource jta="true" jndi-name="java:jboss/datasources/MyApplicationDS" pool-name="MyApplicationDS_Pool" enabled="true" use-java-context="true" use-ccm="true">  
      <connection-url>jdbc:mysql://localhost:3306/MyExampleDB</connection-url>  
      <driver>com.mysql</driver>  
      <security>  
        <user-name>root</user-name>  
        <password></password>  
      </security>  
    <!--
      <timeout>  
        <idle-timeout-minutes>0</idle-timeout-minutes>  
        <query-timeout>600</query-timeout>  
      </timeout>  
      <statement>  
        <prepared-statement-cache-size>100</prepared-statement-cache-size>  
        <share-prepared-statements>true</share-prepared-statements>  
      </statement>  
    -->
    </datasource>

    Na tym etapie ważne jest, aby w elemencie connection-url znajdowała się nazwa bazy danych utworzonej na potrzeby tej aplikacji.
    Element security zawiera nazwę użytkownika oraz hasło dostępu do bazy danych.

  2. oraz w węźle datasources->drivers dodać lub zamienić istniejący węzeł driver na następujący:
     <driver name="com.mysql" module="com.mysql">  
       <xa-datasource-class>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</xa-datasource-class>  
     </driver>

Aby zamknąć „rozdział” konfiguracji bazy danych należy jeszcze:

  • zaznaczyć projekt ejb klikając na nim prawym przyciskiem myszy i z menu kontekstowego wybrać Properties.
    Java EE - Eclipse 9
  • Gdy otworzy się nowe okno po lewej stronie należy wybrać Project Facets, a następnie zaznaczyć JPA w wersji 2.0, na końcu zatwierdzając przyciskiem OK.Java EE - Eclipse 10

Powyższe czynności spowodowały utworzenie pliku persistance.xml. Można go znaleźć w Project Explorerze w dwóch miejscach:

Java EE - Eclipse 11

Otwieramy persistance.xml i na dole okna, wybieramy zakładkę source, aby przejść do jego edycji. Po modyfikacji plik ten powinien wyglądać następująco:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="MyApplicationPU" transaction-type="JTA">
        <jta-data-source>java:jboss/datasources/MyApplicationDS</jta-data-source>
        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
              <property name="hibernate.hbm2ddl.auto" value="update" />
            <property name="hibernate.show_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

 

Gotowe! Można zająć się pisaniem aplikacji.

Zacznijmy od utworzenia klas encji (Entity Class), które to, służą do odwzorowania obiektów w pamięci stałej. W celu utworzenia tej klasy można się posłużyć kreatorem w następujący sposób:

  • kliknąć prawym przyciskiem myszy w EJB Project (MyApplication-ejb) -> New -> JPA Entity
    Java EE - Eclipse 12
  • w otwartym oknie, jak na załączonym poniżej screenie należy uzupełnić pole Java package oraz Class name odpowiednio wartościami com.myapplication.model oraz User, po czym zatwierdzić przyciskiem Next
    Java EE - Eclipse 13
  • w następnym oknie można zdefiniować pola, które ma zawierać nasza przykładowa klasa. Dodaje się je za pomocą przycisku Add tak jak poniżej. Na koniec zatwierdzamy przyciskiem Finish, co spowoduje wygenerowanie nowej klasy User (do której jeszcze wrócimy).
    Java EE - Eclipse 14
  • zatwierdzamy przyciskiem Finish.
  • W podobny sposób tworzymy „normalną” klasę Address, która będzie osadzona w klasie User:
    package com.myapplication.model;
    
    import java.io.Serializable;
    import java.lang.String;
    import javax.persistence.*;
    
    @Embeddable
    public class Address implements Serializable {
    
        private String street;
        private String city;
        private String zipCode;
        private String country;
        private static final long serialVersionUID = 1L;
    
        public Address() {
            super();
        }
    
        public Address(String street, String city, String zipCode, String country) {
            this.street = street;
            this.city = city;
            this.zipCode = zipCode;
            this.country = country;
        }
    
        public String getStreet() {
            return this.street;
        }
    
        public void setStreet(String street) {
            this.street = street;
        }
    
        public String getCity() {
            return this.city;
        }
    
        public void setCity(String city) {
            this.city = city;
        }
    
        public String getZipCode() {
            return this.zipCode;
        }
    
        public void setZipCode(String zipCode) {
            this.zipCode = zipCode;
        }
    
        public String getCountry() {
            return this.country;
        }
    
        public void setCountry(String country) {
            this.country = country;
        }
    
    }
  • Po utworzeniu klasy Address przejdźmy do kodu klasy User i dodajmy adnotacje wraz z polem referencji do klasy Address oraz getterem i setterem. Cała klasa User powinna mniej więcej wyglądać następująco:
    package com.myapplication.model;
    
    import java.io.Serializable;
    import java.lang.String;
    import javax.persistence.*;
    
    /**
     * Entity implementation class for Entity: User
     * 
     */
    @Entity
    @NamedQueries({ @NamedQuery(name = User.GET_ALL, query = "SELECT u FROM User u") })
    public class User implements Serializable {
    
        public static final String GET_ALL = "get.user.all";
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int id;
        private String firstName;
        private String secondName;
        private String login;
        private String password;
        private String email;
        private static final long serialVersionUID = 1L;
    
        @Transient
        private boolean editable;
    
        public boolean isEditable() {
            return editable;
        }
    
        public void setEditable(boolean editable) {
            this.editable = editable;
        }
    
        @Embedded
        private Address address;
    
        public User() {
            super();
        }
    
        public User(String firstName, String secondName, String login,
                String password, String email, Address address) {
            this.firstName = firstName;
            this.secondName = secondName;
            this.login = login;
            this.password = password;
            this.email = email;
            this.address = address;
        }
    
        public int getId() {
            return this.id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getFirstName() {
            return this.firstName;
        }
    
        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }
    
        public String getSecondName() {
            return this.secondName;
        }
    
        public void setSecondName(String secondName) {
            this.secondName = secondName;
        }
    
        public String getLogin() {
            return this.login;
        }
    
        public void setLogin(String login) {
            this.login = login;
        }
    
        public String getPassword() {
            return this.password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getEmail() {
            return this.email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public Address getAddress() {
            return address;
        }
    
        public void setAddress(Address address) {
            this.address = address;
        }
    
    }

Jeżeli posiadamy już jakieś encje, pora je utrwalić w bazie danych.  Między innymi do tego celu używa się komponenty EJB. W naszym przykładzie będą to bezstanowe komponenty sesyjne (@Stateless). Poniższe kroki przedstawiają w jaki sposób można utworzyć w/w komponenty:

  • Wybieramy projekt ejb, po czym z menu kontekstowego New->Session Bean (EJB 3.x)
    Java EE - Eclipse 16
  • W nowym oknie jako pakiet, w którym powinna znaleźć się klasa wpisujemy com.myapplication.manager, natomiast nazwa nowej klasy to: UserManagerBean. State type pozostawiamy bez zmian czyli Stateless oraz podajemy, aby Eclipse utworzył nam od razu interfejs zdalny (@Remote). Jako nazwę wpisujemy com.myapplication.manager.UserManager. Na koniec jeszcze odhaczamy No-interface View i akceptujemy wprowadzone zmiany, klikając przycisk Finish.
    Java EE - Eclipse 17a

Po utworzeniu szkieletu klas komponentów sesyjnych należy przejść do dodania paru metod.

Ponieważ przykładowa aplikacja będzie aplikacją typu CRUD ang.create, read, update and delete (pol. utwórz, odczytaj, aktualizuj i usuń) dodamy cztery metody:

  • createUser
  • getUser
  • storeUser
  • removeUser

Gotowy interfejs UserManager powinien wyglądać następująco:

package com.myapplication.manager;

import java.util.List;

import javax.ejb.Remote;

import com.myapplication.model.User;

@Remote
public interface UserManager {

    public void createUser(User user);

    public User getUser(int id);

    public List<User> getUsers();

    public void storeUser(User user);

    public void removeUser(User user);

}

, a gotowa klasa komponentu:

package com.myapplication.manager;

import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import com.myapplication.model.User;

/**
 * Session Bean implementation class UserManagerBean
 */
@Stateless
public class UserManagerBean implements UserManager {

    @PersistenceContext(unitName = "MyApplicationPU")
    private EntityManager em;

    /**
     * Default constructor.
     */
    public UserManagerBean() {
        // TODO Auto-generated constructor stub
    }

    @Override
    public void createUser(User user) {
        em.persist(user);
    }

    @Override
    public User getUser(int id) {
        return em.find(User.class, id);
    }

    @Override
    public void storeUser(User user) {
        em.merge(user);
    }

    @Override
    public void removeUser(User user) {
        User u = em.find(User.class, user.getId());
        em.remove(u);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<User> getUsers() {
        Query q = em.createNamedQuery(User.GET_ALL);
        return q.getResultList();
    }
}

Zauważmy, iż w powyższym komponencie został utworzony EntityManager,czyli menadżer encji.

Przejdźmy teraz do projektu Webowego. W pierwszej kolejności trzeba do niego dodać elementy JSF.
Aby to zrobić najlepiej jest:

  • Kliknąć prawym przyciskiem na projekt MyApplication-war i z menu kontekstowego wybrać Properties.
    Java EE - Eclipse 18
  • Z lewej listy wybrać Project Facets i zaznaczyć JavaServer Faces w najnowszej wersji czyli 2.1, po czym przejść do linku Further configuration available…
    Java EE - Eclipse 19
  • W otwartym oknie, które służy do wprowadzenia szczegółowych ustawień dotyczących JSF na samym początku definiujemy bibliotekę, którą ma aplikacja używać. Proponuję z listy Type wybrać User Library oraz kliknąć drugą ikonkę (Download library…) z prawej strony co spowoduje pojawienie się nowego okna umożliwiającego wybór biblioteki.
    Java EE - Eclipse 20Wybieramy do pobrania drugą wersję, czyli JSF 2.1 (Mojarra 2.1.6-FCS) i zatwierdzamy przyciskiem Next. W dalszym kroku trzeba zaakceptować licencję, po czym nastąpi pobranie biblioteki (około 13,2 MB). Nie muszę przypominać, iż w tym czasie potrzebny jest dostęp do internetu…
    Po pobraniu i rozpakowaniu biblioteki Eclipse powróci do poprzedniego okna konfiguracji. Jedyną rzeczą, którą zmieniłem to URL Mapping Patterns, który z /faces/* ustawiłem na *.xhtml.
    Java EE - Eclipse 21a
  • Akceptujemy zmiany przyciskiem OK, następnie Apply w celu zatwierdzenia zmian i na koniec przycisk OK.

Powyższe czynności spowodowały dodanie biblioteki JSF, pliku faces-config.xml oraz kilku wierszy w pliku deskryptorze wdrożenia web.xml.

Przejdźmy w końcu do utworzenia strony aplikacji, wraz z Managed Beanem.
Przed przystąpieniem jednak do pisania kodu należy jeszcze dodać projekt MyApplication do MyApplication-war, w celu umożliwienia odwołania się do znajdujących się w nim klas:

  1. Ponownie wejść do właściwości projektu MyApplication-war
  2. Z lewej strony wybrać Java Build Path oraz zakłądkę Projects i kliknąć przycisk Add… w celu dodania projektu
    Java EE - Eclipse 27
  3. Wybieramy projekt MyApplication-ejb następnie OK i OK.
    Java EE - Eclipse 28

Managed Bean to nic innego jak klasa Javy z pewnymi właściwościami. Tworzy się go następująco:

  • Prawy przycisk myszy na projekcie war, New->Class
    Java EE - Eclipse 25
  • Jako pakiet wpisujemy com.myapplication.web.bean, a nazwa klasy to UserBean
    Java EE - Eclipse 26
  • Poniżej znajduje się gotowa klasa wraz z kodem, obsługującym czynności, które użytkownik może wykonywać na stronie przykładowej aplikacji:
    package com.myapplication.web.bean;
    
    import java.util.List;
    
    import javax.annotation.PostConstruct;
    import javax.ejb.EJB;
    import javax.faces.bean.ManagedBean;
    import javax.faces.bean.SessionScoped;
    
    import com.myapplication.manager.UserManager;
    import com.myapplication.model.Address;
    import com.myapplication.model.User;
    
    @ManagedBean(name = "userBean")
    // lub @Named("user")
    @SessionScoped
    public class UserBean {
    
        private String passwordConfirm;
    
        public String getPasswordConfirm() {
            return passwordConfirm;
        }
    
        public void setPasswordConfirm(String passwordConfirm) {
            this.passwordConfirm = passwordConfirm;
        }
    
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        private List<User> usersList;
    
        @EJB
        UserManager um;
    
        @PostConstruct
        public void init() {
            this.user = new User();
            Address tempAddress = new Address();
            this.user.setAddress(tempAddress);
    
        }
    
        public String addNewUser() {
            if (user.getPassword().equals(getPasswordConfirm())) {
                // Address tmpAddress = new Address(street,city,zipCode,country);
                // User tmpUser = new
                // User(firstName,secondName,login,password,email,tmpAddress);
                um.createUser(user);
            }
            usersList = null;
            user = null;
    
            return null;
        }
    
        public String updateRow(User userToUpdate) {
            System.out.println("test");
            um.storeUser(userToUpdate);
            setUsersList(null);
            return null;
        }
    
        public String deleteRow(User userToDelete) {
            um.removeUser(userToDelete);
            setUsersList(null);
            return null;
        }
    
        public List<User> getUsersList() {
            if (this.usersList == null) {
                return this.usersList = um.getUsers();
            }
            return this.usersList;
        }
    
        public void setUsersList(List<User> usersList) {
            this.usersList = usersList;
        }
    
    }
  • Podobnie jak w poprzednich przykładach tworzymy nowy plik, klikając prawym przyciskiem myszy na projekt, w którym chcemy go utworzyć. W tym przypadku będzie to plik .xhtml, czyli strona wyświetlana w przeglądarce www.
    Java EE - Eclipse 22
  • Jako nazwę podajemy index.xhtml i zatwierdzamy OK.
    Java EE - Eclipse 23
  • Automatycznie zostanie otwarty plik do edycji. Można od razu przełączyć zakładkę na Source.
  • Pierwsze co należy zrobić, aby móc korzystać ze znaczników JSF to dodanie ich deklaracji. W najprostszy sposób, można to zrobić przy użyciu skrótu klawiszowego Ctrl + Space i wyborze Facelets XHTML Page.
  • Po dodaniu formularza do tworzenia nowych użytkowników oraz tabeli zawierającej wszystkich, wcześniej utworzonych użytkowników wraz z możliwością ich edycji oraz usuwania, przykładowy kod przedstawiony jest poniżej:
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml"
    	xmlns:ui="http://java.sun.com/jsf/facelets"
    	xmlns:h="http://java.sun.com/jsf/html"
    	xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
    
    </h:head>
    <h:body>
    	<div>
    		<h:outputText value="Add new User" />
    		<h:form prependId="false">
    			<table>
    				<tr>
    					<td><h:outputText value="FirstName:" /></td>
    					<td><h:inputText id="firstNameId"
    							value="#{userBean.user.firstName}" required="true" /></td>
    					<td><h:message for="firstNameId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="SecondName:" /></td>
    					<td><h:inputText id="secondNameId"
    							value="#{userBean.user.secondName}" required="true" /></td>
    					<td><h:message for="secondNameId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Login:" /></td>
    					<td><h:inputText id="loginId" value="#{userBean.user.login}"
    							required="true" /></td>
    					<td><h:message for="loginId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Password:" /></td>
    					<td><h:inputSecret id="passwordId"
    							value="#{userBean.user.password}" required="true" /></td>
    					<td><h:message for="passwordId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Confirm password:" /></td>
    					<td><h:inputSecret id="passwordConfirmId"
    							value="#{userBean.passwordConfirm}" required="true" /></td>
    					<td><h:message for="passwordConfirmId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="E-mail:" /></td>
    					<td><h:inputText id="emailId" value="#{userBean.user.email}"
    							required="true" /></td>
    					<td><h:message for="emailId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Street" /></td>
    					<td><h:inputText id="streetId"
    							value="#{userBean.user.address.street}" required="true" /></td>
    					<td><h:message for="streetId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="City:" /></td>
    					<td><h:inputText id="cityId"
    							value="#{userBean.user.address.city}" required="true" /></td>
    					<td><h:message for="cityId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Zip code:" /></td>
    					<td><h:inputText id="zipCodeId"
    							value="#{userBean.user.address.zipCode}" required="true" /></td>
    					<td><h:message for="zipCodeId" /></td>
    				</tr>
    				<tr>
    					<td><h:outputText value="Country" /></td>
    					<td><h:inputText id="coutnryId"
    							value="#{userBean.user.address.country}" required="true" /></td>
    					<td><h:message for="coutnryId" /></td>
    				</tr>
    			</table>
    
    			<h:commandButton action="#{userBean.addNewUser}" value="Add new user" />
    
    		</h:form>
    	</div>
    	<div>
    		<h:form>
    			<h:dataTable value="#{userBean.usersList}" var="userItem">
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Edit" />
    					</f:facet>
    					<h:selectBooleanCheckbox value="#{userItem.editable}"
    						onclick="submit()" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="First name" />
    					</f:facet>
    					<h:inputText value="#{userItem.firstName}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.firstName}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Second name" />
    					</f:facet>
    					<h:inputText value="#{userItem.secondName}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.secondName}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Login" />
    					</f:facet>
    					<h:inputText value="#{userItem.login}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.login}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Password" />
    					</f:facet>
    					<h:inputText value="#{userItem.password}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.password}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Email" />
    					</f:facet>
    					<h:inputText value="#{userItem.email}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.email}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Street" />
    					</f:facet>
    					<h:inputText value="#{userItem.address.street}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.address.street}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="City" />
    					</f:facet>
    					<h:inputText value="#{userItem.address.city}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.address.city}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Zip Code" />
    					</f:facet>
    					<h:inputText value="#{userItem.address.zipCode}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.address.zipCode}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    						<h:outputText value="Country" />
    					</f:facet>
    					<h:inputText value="#{userItem.address.country}"
    						rendered="#{userItem.editable}" required="true" />
    					<h:outputText value="#{userItem.address.country}"
    						rendered="#{not userItem.editable}" />
    				</h:column>
    				<h:column>
    					<f:facet name="header">
    
    					</f:facet>
    					<h:commandLink value="delete" action="#{userBean.deleteRow(userItem)}" /><br />
    					<h:commandLink value="update" action="#{userBean.updateRow(userItem)}" />
    				</h:column>
    			</h:dataTable>
    		</h:form>
    	</div>
    </h:body>
    
    </html>

Pozostaje nam już jedynie stworzenie pliku EAR i wgranie go do „deploy folder” (czynnoś ta nazwana jest publikacją projektu). Standardowo na serwerze aplikacji JBoss 7 jest to katalog \standalone\deployments\ .
Można to zrobić, otwierając na zakładce Servers menu kontekstowe i wybierając czynność Clean… .

Java EE - Eclipse 29
Po wykonaniu status Republish zmieni się na Synchronized co oznacza, iż jest wgrana na serwerze najnowsza wersja aplikacji.

Oczywiście jBoss musi być uruchomiony. Można go wystartować w 2 trybach:

  • debug mode (umożliwia debugowanie aplikacji) lub
  • standard mode

Na załączonym poniżej slajdzie wybieram opcje z możliwością debugowania:
Java EE - Eclipse 30
Po uruchomieniu JBoss’a, Eclipse automatycznie przechodzi do wyświetlania logów z serwera, a gdy otrzymamy informację:

[org.jboss.as.server] (DeploymentScanner-threads - 2) JBAS018559: Deployed "MyApplication.ear"

możemy być pewni, że wszystko zostało przeprowadzone pomyślnie i przykładowa aplikacja jest dostępna w przeglądarce pod następującym adresem URL:

http://localhost:8080/MyApplication-war/index.xhtml

Gotowy przykład z dodanym jednym użytkownikiem wygląda następująco:

Java EE - Eclipse 31

 

Uff… mam nadzieje, że objętość tego wpisu nie zraziła Was do przerobienia tego tutoriala, ale jeśli jeszcze tu jesteście oznacza to, że nie było, aż tak źle (a przynajmniej mam taką nadzieję) 🙂

W powyższym wpisie celowo nie wgłębiałem się w szczegółowy opis użytych przeze mnie: komponentów, adnotacji etc., gdyż w miarę możliwości chciałbym je opisać w kolejnych postach.

Za wszelkie komentarze i uwagi, z góry dziękuję.