Tekst źródłowy

[http://code.google.com/webtoolkit Google Web Toolkit (GWT)] zdaje się być niebagatelnym rozwiązaniem do tworzenia aplikacji internetowej. Jest to nadzwyczaj ciekawy projekt do tworzenia aplikacji uruchamianych w przeglądarce w Javie. Do niedawna to część serwerowa aplikacji była główną częścią z punktu widzenia projektanta rozwiązania, gdzie strona kliencka (uruchamiania w przeglądarce) była generowana dynamicznie po wykonaniu serii operacji na serwerze. Z GWT sprawa jest całkowicie odmienna - to strona kliencka dyktuje warunki stronie serwerowej i jest główną częścią aplikacji korzystając z części serwerowej jako zestawu usług i sprowadzając rolę serwera do roli drugoplanowej (niektórzy przyrównują rolę serwera do terminala). Część kliencka wymaga znajomości JavaScript, CSS, HTML i DHTML, co dla programisty rozeznanego w technologiach serwerowych może sprawić nie lada wyzwanie. Szczęśliwie GWT sprowadza tworzenie całej aplikacji - części klienckiej i serwerowej - do wspólnego mianownika, tj. do języka Java. Tworzenie części klienckiej w GWT to tworzenie interfejsu użytkownika podobne do biblioteki JFC/Swing, a to zazwyczaj znane jest większości programistów Java. Korzystając z możliwości GWT programista strony serwerowej z łatwością może podjąć się wyzwania stworzenia bardzo zaawansowanego interfejsu użytkownika z pomocą GWT wykorzystując usługi serwera aplikacyjnego Java EE. Jedną z usług serwera Java EE jest Java Persistence API (JPA), która mimo, że należy do specyfikacji Enterprise JavaBeans 3.0, może być również uruchomiona poza serwerem, w trybie zarządzanym przez aplikację.

W tym artykule przedstawię sposób integracji GWT z JPA. Zaprezentowane zostanie działanie mechanizmu serializacji GWT, GWT RPC oraz obsługa zdarzeń i kontrolki graficzne GWT. Projekt zarządzany będzie przez Apache Maven 2 i uruchamiany na kontenerze servletów Jetty 6 wraz z Apache Derby. Jako projekt pomocniczny zostanie wykorzystany Dozer.

Rola poszczególnych projektów składowych w aplikacji Rejestr Osobowy:
* [http://code.google.com/webtoolkit/ GWT] - tworzenie zaawansowanego interfejsu użytkownika uruchamianego jako JavaScript w przeglądarce programując w Javie
* [http://java.sun.com/javaee/technologies/persistence.jsp JPA] - mechanizm trwałości danych
* [http://maven.apache.org Apache Maven 2] - narzędzie zarządzające projektem, m.in. budowanie, uruchamianie, testowanie, przygotowanie wersji dystrybucyjnej, itp.
* [http://incubator.apache.org/openjpa Apache OpenJPA] - dostawca JPA
* [http://db.apache.org/derby/ Apache Derby] - relacyjna baza danych
* [http://dozer.sourceforge.net/ Dozer] - mapowanie stanu egzemplarza pewnego typu do innego
* [http://jetty.mortbay.org/ Jetty] - kontener servletów, w którym będzie uruchomiona pełna aplikacja

Aplikacja będzie dostarczała funkcjonalność wyszukiwania osób i prezentacji ich danych. Użytkownik ma do dyspozycji panel wyszukiwania i wyników. Wprowadzając pojedyńcze litery nazwiska, aplikacja wywołuje usługę zdalną opartą o mechanizm GWT RPC do pobrania danych z bazy danych Apache Derby za pomocą JPA. Zdalna usługa udostępnia dwie funkcjonalności - pobranie ilości dostępnych osób o nazwisku rozpoczynającym się podanym ciągiem znaków oraz samo pobranie osób do wyświetlenia.

Gotowy projekt do uruchomienia (cała struktura projektu wraz z niezbędnymi elementami składowymi opisanymi poniżej) można pobrać jako [http://www.JacekLaskowski.pl/aplikacje/gwt-rejestrosobowy.zip gwt-rejestrosobowy.zip]. Wystarczy jedynie wykonać polecenie ''mvn clean jetty:run-exploded''.

== Utworzenie projektu aplikacji internetowej z GWT - Rejestr Osobowy ==

Realizacja projektu oparta jest o środowisko opisane w artykule - [[Tworzenie aplikacji z Google Web Toolkit i Apache Maven 2]]. Rozpoczynamy od stworzenia projektu przy pomocy M2 i zdefiniowaniu koniecznych zależności GWT.

Rozpoczynamy w wybranym przez siebie katalogu, np. C:\.

 $ mvn archetype:create -DarchetypeArtifactId=maven-archetype-webapp -DarchetypeVersion=1.0 -DgroupId=pl.jaceklaskowski.gwt.rejestrosobowy -DartifactId=gwt-rejestrosobowy
 [INFO] Scanning for projects...
 [INFO] Searching repository for plugin with prefix: 'archetype'.
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building Maven Default Project
 [INFO]    task-segment: [archetype:create] (aggregator-style)
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] Archetype created in dir: c:\gwt-rejestrosobowy
 [INFO] ------------------------------------------------------------------------
 [INFO] BUILD SUCCESSFUL
 [INFO] ------------------------------------------------------------------------
 [INFO] Total time: 1 second
 [INFO] Finished at: Sun May 13 15:42:15 CEST 2007
 [INFO] Final Memory: 5M/254M
 [INFO] ------------------------------------------------------------------------

Przechodzimy do katalogu '''gwt-rejestrosobowy'''. 

 $ cd gwt-rejestrosobowy/

Kolejne polecenia wydawane będą właśnie z tego katalogu, który reprezentuje nasz projekt aplikacji internetowej.

Zmiany w projekcie najlepiej wykonywać jest za pomocą zintegrowanego środowiska programistycznego (ang. IDE - integrated development environment). Dowolne IDE może być wykorzystane w projekcie, jednakże należy się zdecydować które. Skorzystamy z Eclipse IDE 3.3m7. 

Wykonujemy polecenie '''mvn eclipse:eclipse''', aby utworzyć pliku projektu do importu projektu do Eclipse.

 $ mvn eclipse:eclipse
 [INFO] Scanning for projects...
 [INFO] Searching repository for plugin with prefix: 'eclipse'.
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building gwt-rejestrosobowy Maven Webapp
 [INFO]    task-segment: [eclipse:eclipse]
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] ------------------------------------------------------------------------
 [INFO] BUILD SUCCESSFUL
 [INFO] ------------------------------------------------------------------------
 [INFO] Total time: 1 second
 [INFO] Finished at: Sun May 13 15:46:47 CEST 2007
 [INFO] Final Memory: 3M/254M
 [INFO] ------------------------------------------------------------------------ 

Komunikat ''BUILD SUCCESSFUL'' wskazuje na poprawnie wykonane polecenie. Uruchamiamy Eclipse IDE i importujemy projekt (''File > Import > Existing Projects into Workspace'').

'''UWAGA''': Może się zdarzyć, że po imporcie pojawi się komunikat ostrzegawczy - ''Unbound classpath variable: M2_REPO/com/google/gwt/gwt-servlet/1.3.3/gwt-servlet-1.3.3.jar in project gwt-witajswiecie'' - co oznacza brak definicji zmiennej M2_REPO w wybranej przestrzeni roboczej. Mimo, że Eclipse zgłasza to jako komunikat ostrzegawczy, jest to znaczący błąd, gdyż brak biblioteki '''gwt-servlet-1.3.3.jar''' nie pozwoli na tworzenie klas korzystających z GWT. Naprawiamy błąd poprzez ''Window > Preferences... > Java > Build Path > Classpath Variables > New...''. Dodajemy M2_REPO ze wskazaniem na lokalne repozytorium M2, potwierdzamy ponowne przebudowanie projektu i voila - projekt jest czysty, bez jakichkolwiek komunikatów ostrzegawczych, gotowy do dalszego rozwoju.

Modyfikujemy pom.xml o definicje repozytoriów, konfigurację wtyczek, przede wszystkim '''maven-googlewebtoolkit2-plugin''' oraz deklarację zależności projektowych.

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>pl.jaceklaskowski.gwt.rejestrosobowy</groupId>
   <artifactId>gwt-rejestrosobowy</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Rejestr Osobowy GWT</name>
   <url>http://www.JacekLaskowski.pl</url>
   <repositories>
     <repository>
       <id>gwt-maven</id>
       <url>http://gwt-maven.googlecode.com/svn/trunk/mavenrepo/</url>
     </repository>
   </repositories>
   <pluginRepositories>
     <pluginRepository>
       <id>gwt-maven</id>
       <url>http://gwt-maven.googlecode.com/svn/trunk/mavenrepo/</url>
     </pluginRepository>
   </pluginRepositories>
   <dependencies>
     <dependency>
       <groupId>com.google.gwt</groupId>
       <artifactId>gwt-user</artifactId>
       <version>1.3.3</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>com.google.gwt</groupId>
       <artifactId>gwt-servlet</artifactId>
       <version>1.3.3</version>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.1</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
   <build>
     <finalName>gwt-rejestrosobowy</finalName>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.0</version>
         <configuration>
           <source>1.5</source>
           <target>1.5</target>
         </configuration>
       </plugin>
       <plugin>
         <groupId>com.totsp.gwt</groupId>
         <artifactId>maven-googlewebtoolkit2-plugin</artifactId>
         <version>1.5.3-SNAPSHOT</version>
         <configuration>
           <runTarget>pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT/RejestrOsobowyGWT.html</runTarget>
           <compileTarget>
             <param>pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT</param>
           </compileTarget>
           <gwtHome>c:/apps/gwt</gwtHome>
         </configuration>
         <executions>
           <execution>
             <goals>
               <goal>mergewebxml</goal>
               <goal>compile</goal>
             </goals>
           </execution>
         </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-war-plugin</artifactId>
         <version>2.0.2</version>
         <configuration>
           <webXml>target/web.xml</webXml>
         </configuration>
       </plugin>
     </plugins>
   </build>
 </project>

Po zmianie zależności ponownie generujemy pliki projektu dla wybranego środowiska programistycznego IDE.

 $ mvn eclipse:eclipse
 [INFO] Scanning for projects...
 [INFO] Searching repository for plugin with prefix: 'eclipse'.
 [INFO] artifact org.apache.maven.plugins:maven-eclipse-plugin: checking for updates from gwt-maven
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building Rejestr Osobowy GWT
 [INFO]    task-segment: [eclipse:eclipse]
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] ------------------------------------------------------------------------
 [INFO] BUILD SUCCESSFUL
 [INFO] ------------------------------------------------------------------------
 [INFO] Total time: 2 seconds
 [INFO] Finished at: Sun May 13 16:26:26 CEST 2007
 [INFO] Final Memory: 4M/254M
 [INFO] ------------------------------------------------------------------------

Z ''BUILD SUCCESSFUL'' możemy być pewni, że wszystko jest poprawnie zestawione.

== Utworzenie usługi zdalnej aplikacji - Rejestr ==

Kolejnym krokiem jest stworzenie usługi zdalnej zgodnie z procedurą opisaną w moim poprzednim wpisie o GWT RPC - [http://jlaskowski.blogspot.com/2007/05/gwt-rpc-raz-jeszcze-requestbuilder-oraz.html GWT RPC raz jeszcze, RequestBuilder oraz Timer]. Dodatkowo skorzystamy z rad opisanych w artykule [http://www.ibm.com/developerworks/edu/os-dw-os-ag-gwt1.html Build an Ajax-enabled application using the Google Web Toolkit and Apache Geronimo, Part 1: Run compiled Google Web Toolkit applications on Geronimo], który "idzie" dalej z tematem uruchamiając projekt GWT w środowisku serwera aplikacyjnego Java EE - [http://geronimo.apache.org Apache Geronimo].

=== Interfejs usługi - Rejestr ===

Interfejs usługi Rejestr przedstawia się następująco:

 package pl.jaceklaskowski.gwt.rejestrosobowy.client;
 
 import java.util.List;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.user.client.rpc.RemoteService;
 import com.google.gwt.user.client.rpc.ServiceDefTarget;
 
 public interface Rejestr extends RemoteService {
 
     /**
      * @gwt.typeArgs <pl.jaceklaskowski.gwt.rejestrosobowy.client.Osoba>
      */
     public List getOsoby(String nazwisko);
 
     public long getIloscOsob(String nazwisko);
 
     public static class App {
         private static RejestrAsync ourInstance = null;
 
         public static synchronized RejestrAsync getInstance() {
             if (ourInstance == null) {
                 ourInstance = (RejestrAsync) GWT.create(Rejestr.class);
                 ((ServiceDefTarget) ourInstance).setServiceEntryPoint(GWT.getModuleBaseURL() + "services/rejestr");
             }
             return ourInstance;
         }
     }
 }

'''UWAGA''': Tymczasowo ignorujemy komunikaty błędów związane z brakiem klas w projekcie. Naprawimy to w kolejnych krokach.

Usługa udostępnia dwie metody - '''getOsoby''' oraz '''getIloscOsob'''. Pierwsza z nich - getOsoby - służy do pobrania użytkowników spełniających zadane kryteria wyszukiwania (w naszym przykładzie będzie to posiadanie nazwiska, które rozpoczyna się podanym wzorcem), a druga - getIloscOsob - zwraca ilość osób, które zostaną zwrócone przez metodę getOsoby. Posiadanie dwóch metod jest podyktowane wydajnością dostarczanej funkcjonalności,  w której użytkownik ma możliwość wprowadzania części nazwiska i będzie informowany na bieżąco o ilości dostępnych osób spełniających kryterium, a po wciśnięciu przycisku ENTER bądź wybraniu przycisku ''Wyszukaj'' będzie wyświetlona tabela z danymi wyszukanych osób. Gdyby przesyłać informację o ilości osobach w postaci egzemplarzy możliwych do wyszukiwania osób znacząco wydłużyłoby czas reakcji aplikacji.

Interfejs usługi musi rozszerzania interfejsu GWT - [http://code.google.com/webtoolkit/documentation/com.google.gwt.user.client.rpc.RemoteService.html RemoteService]. Jest to obowiązkowy interfejs każdej usługi zdalnej w GWT RPC.

Na uwagę zasługuje adnotacja GWT - '''@gwt.typeArgs''', który informuje o typie przechowywanym w kolekcji List. Ze względu na ograniczenia GWT odnośnie wersji Java 1.4.2 i poprzednich, z której GWT korzysta, typy generyczne nie są dostępne i jest to jedyny sposób poinstruowania GWT o typie w celu optymalizacji działania. Więcej informacji o adnotacji gwt.typeArgs znajduje się w dokumentacji GWT - [http://code.google.com/webtoolkit/documentation/com.google.gwt.doc.DeveloperGuide.RemoteProcedureCalls.SerializableTypes.html Serializable Types].

Plik interfejsu - '''Rejestr.java''' - umieszczamy w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/client'''.

=== "Transportowa" klasa serializowalna - Osoba ===

W części klienckiej aplikacji modelujemy byt osoba w postaci klasy '''Osoba'''. Klasa będzie przechowywała dane przesyłane z części klienckiej do serwerowej.

 package pl.jaceklaskowski.gwt.rejestrosobowy.client;
 
 import com.google.gwt.user.client.rpc.IsSerializable;
 
 public class Osoba implements IsSerializable {
 
     private String identyfikator;
     private String imie;
     private String nazwisko;
 
     public String getIdentyfikator() {
         return identyfikator;
     }
 
     public void setIdentyfikator(String identyfikator) {
         this.identyfikator = identyfikator;
     }
 
     public String getImie() {
         return imie;
     }
 
     public void setImie(String imie) {
         this.imie = imie;
     }
 
     public String getNazwisko() {
         return nazwisko;
     }
 
     public void setNazwisko(String nazwisko) {
         this.nazwisko = nazwisko;
     }
 
     public String toString() {
         StringBuffer sb = new StringBuffer();
         sb.append(this.identyfikator);
         sb.append(" - ");
         sb.append(this.imie);
         sb.append(" ");
         sb.append(this.nazwisko);
         return sb.toString();
     }
 }

Klasa, która uczestniczy w transporcie danych między usługą zdalną a częścią kliencką aplikacji musi być serializowalna w sensie GWT. Jednym z istotnych elementów w mechaniźmie GWT RPC jest mechanizm '''serializacji''', czyli zamiany postaci obiektowej egzemplarza na postać strumienia bajtów i na odwrót. Jest to mechanizm, który można wykorzystać do zapisywania stanu egzemplarza na dysk czy przesłać strumień bajtów do zdalnego klienta uruchomionego na oddzielnej wirtualnej maszynie. W Javie służy do tego interfejs [http://java.sun.com/j2se/1.5.0/docs/api/java/io/Serializable.html java.io.Serializable] podczas, gdy GWT dostarcza własnej klasy realizującej tę funkcjonalność - [http://code.google.com/webtoolkit/documentation/com.google.gwt.user.client.rpc.IsSerializable.html IsSerializable]. Istnieje wiele powodów, dla których twórcy GWT zdecydowali się odejść od wspierania Serializable na rzecz IsSerializable i dociekliwi mogą znaleźć cały elaborat na ten temat w wątku [http://groups.google.com/group/Google-Web-Toolkit-Contributors/browse_thread/thread/cc1531ac5e6fdc5c/d34d156b928ff08b?#d34d156b928ff08b Treat java.io.Serializable as being equivalent to IsSerializable].

Interfejs IsSerializable pełni pierwszoplanową rolę w realizacji funkcjonalności serializacji w GWT RPC. Przesyłanie stanu obiektów z serwera (usługa) do klienta (przeglądarka z uruchomioną aplikacją GWT jako JavaScript) wymaga protokołu wymiany informacji między uczestnikami konwersacji i IsSerializable jest jego częścią jako interfejs-znacznik. Jedynie serializowalne typy mogą uczestniczyć w komunikacji GWT RPC. Do typów serializowalnych należą:
* typy proste
* odpowiedniki obiektowe typów prostych wraz z String oraz Date
* tablice tych typów
* klasy, które są typu IsSerializable (implementują typ IsSerializable, a skoro interfejs nie ma żadnych metod poza implements nic nie jest wymagane) i wszystkie pola nie będące transient są serializowalne  
* klasy, które posiadają przynajmniej jedną podklasę serializowalną

Plik klasy - '''Osoba.java''' - należy umieścić w katalogu '''src/main/java/pl/jaceklaskowski/gwt/witajswiecie/client'''.

=== Realizacja interfejsu usługi - RejestrImpl ===

Kolejnym krokiem w tworzeniu zdalnej usługi w GWT jest utworzenie realizacji interfejsu usługi - '''RejestrImpl'''. Jest to moment skorzystania z funkcjonalności JPA - zarządzania danymi trwałymi przechowywanymi w bazie danych. JPA będzie wykorzystane w trybie zarządzanym przez aplikację, w którym aplikacja bierze na siebie obowiązek zarządzania życiem zarządcy trwałości zastępując serwer aplikacyjny. Jako dostawcę JPA wybrany jest projekt [http://incubator.apache.org/openjpa Apache OpenJPA]. Wykorzystujemy M2, więc wybór dostawcy sprowadza się do zadeklarowania zależności w '''pom.xml'''. 

UWAGA: Po zmianie zależności projektu w pom.xml może być koniecznie ponowne utworzenie plików projektu, np. poleceniem mvn eclipse:eclipse, gdyż dodajemy zależność na poziomie M2, co w zależności od IDE może nie implikować automatycznego uaktualnienia projektu.

Klasa realizująca interfejs usługi jest jednocześnie servletem, więc możemy skorzystać ze wszystkich dobrodziejst płynących z tego, m.in. z przestrzeni application oraz metod init i destroy do zarządzania fabryką zarządcy trwałości. 

 package pl.jaceklaskowski.gwt.rejestrosobowy.server;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.Query;
 import javax.servlet.ServletException;
 
 import net.sf.dozer.util.mapping.DozerBeanMapper;
 import pl.jaceklaskowski.gwt.rejestrosobowy.client.Osoba;
 import pl.jaceklaskowski.gwt.rejestrosobowy.client.Rejestr;
 import pl.jaceklaskowski.gwt.rejestrosobowy.server.entity.OsobaEncja;
 
 import com.google.gwt.user.client.rpc.InvocationException;
 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
 
 public class RejestrImpl extends RemoteServiceServlet implements Rejestr {
 
     EntityManagerFactory emf = null;
     DozerBeanMapper mapper = null;
 
     public void init() throws ServletException {
         super.init();
         mapper = new DozerBeanMapper();
         emf = (EntityManagerFactory) getServletContext().getAttribute("entityManagerFactory");
     }
 
     public long getIloscOsob(String nazwisko) {
         EntityManager em = null;
         try {
             em = emf.createEntityManager();
             Query query = em.createNamedQuery("podajIloscOsobPoNazwisku");
             query.setParameter("nazwisko", nazwisko);
             return ((Long) query.getSingleResult()).longValue();
         } catch (Exception e) {
             throw new InvocationException("Wystąpił wyjątek podczas wykonania zdalnej usługi", e);
         } finally {
             if (em != null) {
                 em.close();
             }
         }
     }
 
     public List getOsoby(String nazwisko) {
         EntityManager em = null;
         try {
             em = emf.createEntityManager();
             Query query = em.createNamedQuery("znajdzOsobyPoNazwisku");
             query.setParameter("nazwisko", nazwisko);
             List<OsobaEncja> osobaEncje = (List<OsobaEncja>) query.getResultList();
             // kopiujemy dane z JPA do struktury dla GWT
             List<Osoba> osoby = null;
             if (osobaEncje != null) {
                 osoby = new ArrayList<Osoba>();
                 for (OsobaEncja encja : osobaEncje) {
                     osoby.add((Osoba) mapper.map(encja, Osoba.class));
                 }
             }
             return osoby;
         } catch (Exception e) {
             throw new InvocationException("Wystąpił wyjątek podczas wykonania zdalnej usługi", e);
         } finally {
             if (em != null) {
                 em.close();
             }
         }
     }
 
     public void destroy() {
         super.destroy();
         emf.close();
     }
 }

'''UWAGA''': Tymczasowo ignorujemy błędy związane z niedostępnością typów.

W metodzie '''getOsoby''' następuje przekopiowanie danych ze struktury serwerowej - klasa OsobaEncja - do struktury klienckiej - klasa Osoba. Jest to spowodowane przede wszystkim ograniczeniami jakie nakłada GWT w związku ze wspieraną wersją Java 1.4.2 i poprzedniej po stronie klienta. Interfejs Serializable nie jest dostępny w środowisku GWT - [http://code.google.com/webtoolkit/documentation/jre.html JRE Emulation Library] oraz funkcjonalność adnotacji. Mimo, że zastosujemy deskryptor XML do definicji mapowania encji - orm.xml, aby m.in. obejść to ograniczenie, wydaje się, że panuje ogólne przekonanie o słuszności stosowania osobnych klas między częściami kliencką i serwerową. Do kopiowania danych z jednej klasy do drugiej wykorzystujemy projekt [http://dozer.sourceforge.net Dozer], który w naszym zastosowaniu nie wymaga żadnej konfiguracji, gdyż typy są identyczne składniowo.

Plik klasy - '''RejestrImpl.java''' - umieszczamy w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/server'''.

Nie jest to konieczny krok, ale aby zapobiec komunikatom ostrzegawczym o niedostępności konfiguracji zapisywania zdarzeń przez Dozer podczas uruchomienia aplikacji, utworzymy plik konfiguracyjny dla [http://logging.apache.org/log4j Apache log4j] - '''log4j.properties'''. log4j jest projektem upraszczającym zapisywanie komunikatów (nie mylić z JMS!) przez aplikacje wykorzystywanym przez Dozer.

 log4j.rootLogger = debug, stdout
 log4j.category.net.sf.dozer = debug, stdout
 
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 log4j.appender.stdout.Target=System.out
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

Plik - '''log4j.properties''' - umieszczamy w katalogu '''src/main/resources'''.

=== Interfejs asynchroniczny usługi zdalnej - RejestrAsync ===

Tworząc usługę zdalną w GWT RPC koniecznie należy utworzyć interfejs asynchroniczny usługi zdalnej - '''RejestrAsync'''.

 package pl.jaceklaskowski.gwt.rejestrosobowy.client;
 
 import com.google.gwt.user.client.rpc.AsyncCallback;
 
 public interface RejestrAsync {
 
     public void getOsoby(String nazwisko, AsyncCallback callback);
 
     public void getIloscOsob(String nazwisko, AsyncCallback callback);
 
 }

Różnicą między interfejsem asynchronicznym, a odpowiadającym mu interfejsem usługi jest modyfikacja sygnatury metod interfejsu usługi Rejestr tak, aby metody zwracały typ void oraz ostatnim parametrem wejściowym był egzemplarz typu [http://code.google.com/webtoolkit/documentation/com.google.gwt.user.client.rpc.AsyncCallback.html AsyncCallback].

Plik interfejsu - '''RejestrAsync.java''' - umieszczamy w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/client'''.

== Utworzenie modułu - RejestrOsobowyGWT ==

=== Punkt początkowy modułu - RejestrOsobowyGWT ===

Głównym elementem każdej aplikacji GWT jest punkt początkowy modułu (ang. ''entry-point''). W naszym module zdefiniujemy pojedyńczy punkt początkowy - '''RejestrOsobowyGWT'''. Punkt będzie realizowany przez klasę '''pl.jaceklaskowski.gwt.rejestrosobowy.client.RejestrOsobowyGWT'''.

 package pl.jaceklaskowski.gwt.rejestrosobowy.client;
 
 import java.util.List;
 
 import com.google.gwt.core.client.EntryPoint;
 import com.google.gwt.user.client.Window;
 import com.google.gwt.user.client.rpc.AsyncCallback;
 import com.google.gwt.user.client.ui.Button;
 import com.google.gwt.user.client.ui.ClickListener;
 import com.google.gwt.user.client.ui.FlexTable;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.KeyboardListenerAdapter;
 import com.google.gwt.user.client.ui.Label;
 import com.google.gwt.user.client.ui.RootPanel;
 import com.google.gwt.user.client.ui.TextBox;
 import com.google.gwt.user.client.ui.Widget;
 
 public class RejestrOsobowyGWT implements EntryPoint {
     public void onModuleLoad() {
 
         final Button przyciskSzukaj = new Button("Szukaj");
         final Label wyszukanoLabel = new Label();
         final TextBox nazwiskoTextBox = new TextBox();
         final FlexTable daneTable = new FlexTable();
 
         nazwiskoTextBox.addKeyboardListener(new KeyboardListenerAdapter() {
 
             public void onKeyUp(Widget sender, char keyCode, int modifiers) {
                 // przechwytywanie zdarzenia kasowania znaku bądź podobnych
                 wykonajZdalneGetIloscOsob(sender, (char) 0, modifiers);
             }
 
             public void onKeyPress(Widget sender, char keyCode, int modifiers) {
                 wykonajZdalneGetIloscOsob(sender, keyCode, modifiers);
             }
 
             private void wykonajZdalneGetIloscOsob(Widget sender, char keyCode, int modifiers) {
 
                 // cyfry niedozwolone w nazwisku
                 if (Character.isDigit(keyCode)) {
                     nazwiskoTextBox.cancelKey();
                     return;
                 }
 
                 // znaki specjalne, np. DELETE (kasowanie znaku) niedołączane, wyłącznie litery
                 StringBuffer wyszukiwanyWzorzecNazwiska = new StringBuffer(nazwiskoTextBox.getText());
                 if (Character.isLetter(keyCode)) {
                     wyszukiwanyWzorzecNazwiska.insert(nazwiskoTextBox.getCursorPos(), keyCode);
                 }
                 wyszukiwanyWzorzecNazwiska.append("%");
 
                 RejestrAsync rejestr = Rejestr.App.getInstance();
                 rejestr.getIloscOsob(wyszukiwanyWzorzecNazwiska.toString(), new AsyncCallback() {
                     public void onSuccess(Object result) {
                         wyszukanoLabel.setText(((Long) result).toString());
                     }
 
                     public void onFailure(Throwable caught) {
                         Window.alert(caught.toString());
                         wyszukanoLabel.setText(caught.toString());
                         caught.printStackTrace();
                     }
                 });
                 wyszukanoLabel.setText("Pobieram dane...");
             }
         });
 
         nazwiskoTextBox.addKeyboardListener(new KeyboardListenerAdapter() {
             public void onKeyPress(Widget sender, char keyCode, int modifiers) {
                 if (keyCode == '\r') {
                     przyciskSzukaj.click();
                 }
             }
         });
         przyciskSzukaj.addClickListener(new ClickListener() {
             public void onClick(Widget sender) {
                 RejestrAsync remoteService = Rejestr.App.getInstance();
                 remoteService.getOsoby(nazwiskoTextBox.getText() + "%", new AsyncCallback() {
                     public void onSuccess(Object result) {
                         List osobyLista = (List) result;
                         if (osobyLista == null || osobyLista.size() == 0) {
                             daneTable.setVisible(false);
                             return;
                         }
 
                         // usuń wiersze poza nagłówkiem
                         int iloscWierszy = daneTable.getRowCount();
                         if (iloscWierszy > 1) {
                             do {
                                 daneTable.removeRow(iloscWierszy - 1); // wiersze liczone są od 0
                                 iloscWierszy--;
                             } while (iloscWierszy != 1);
                         }
 
                         int rozmiarDanych = osobyLista.size();
                         for (int i = 0; i < rozmiarDanych; i++) {
                             Osoba osoba = (Osoba) osobyLista.get(i);
                             // wypełnij tabelę pamiętając, że pierwszy (zerowy) wiersz jest dla nagłówka
                             daneTable.setText(i + 1, 0, osoba.getIdentyfikator());
                             daneTable.setText(i + 1, 1, osoba.getImie());
                             daneTable.setText(i + 1, 2, osoba.getNazwisko());
                         }
                         daneTable.setVisible(true);
                     }
 
                     public void onFailure(Throwable caught) {
                         Window.alert(caught.toString());
                         caught.printStackTrace();
                     }
                 });
             }
         });
 
         // początkowo ukryj, ponieważ nie ma danych do wyświetlenia
         daneTable.setBorderWidth(1);
         daneTable.setText(0, 0, "Identyfikator");
         daneTable.setText(0, 1, "Imię");
         daneTable.setText(0, 2, "Nazwisko");
         daneTable.setVisible(false);
 
         HorizontalPanel przestrzenWyszukiwania = new HorizontalPanel();
         przestrzenWyszukiwania.add(new Label("Nazwisko: "));
         przestrzenWyszukiwania.add(nazwiskoTextBox);
         przestrzenWyszukiwania.add(przyciskSzukaj);
         RootPanel.get("przestrzenWyszukiwania").add(przestrzenWyszukiwania);
 
         HorizontalPanel poleWyszukano = new HorizontalPanel();
         poleWyszukano.add(new Label("Osób możliwych do wyszukania: "));
         poleWyszukano.add(wyszukanoLabel);
         RootPanel.get("poleWyszukano").add(poleWyszukano);
 
         RootPanel.get("dane").add(daneTable);
     }
 }

Plik klasy punktu początkowego - '''RejestrOsobowyGWT.java''' - umieszczamy w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/client'''.

=== Część publiczna modułu - RejestrOsobowyGWT.html oraz RejestrOsobowyGWT.css ===

Jak każda aplikacja internetowa tak i nasza posiada stronę początkową - '''RejestrOsobowyGWT.html''', która uruchamia całą infrastrukturę GWT.

 &lt;!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"&gt;
 &lt;html&gt;
   &lt;head&gt;
     &lt;title&gt;Rejestr osobowy GWT&lt;/title&gt;
     &lt;meta http-equiv="content-type" content="text/html; charset=UTF-8"&gt;
     
     &lt;link rel=stylesheet href="RejestrOsobowyGWT.css" /&gt;
     
     &lt;!--                                   --&gt;
     &lt;!--  Łącznik między stroną HTML a GWT --&gt;
     &lt;!--                                   --&gt;
     &lt;meta name='gwt:module' content='pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT'&gt;
   &lt;/head&gt;
   &lt;body&gt;
     &lt;script language="javascript" src="gwt.js"&gt;&lt;/script&gt;
     
     &lt;iframe id="__gwt_historyFrame" style="width: 0; height: 0; border: 0"&gt;&lt;/iframe&gt;
     
     &lt;h1&gt;Rejestr osobowy GWT&lt;/h1&gt;
     &lt;div id="rejestr"&gt;
       &lt;span id="przestrzenWyszukiwania"&gt;&lt;/span&gt;
     &lt;/div&gt;
     &lt;div&gt;
       &lt;span id="poleWyszukano"&gt;&lt;/span&gt;
     &lt;/div&gt;
     &lt;div id="przestrzenInformacyjna"&gt;
       &lt;span id="dane"&gt;&lt;/span&gt;
     &lt;/div&gt;    
   &lt;/body&gt;
 &lt;/html&gt;

Plik strony początkowej modułu - '''RejestrOsobowyGWT.html''' - umieszczamy w katalogu '''src/main/webapp/pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT'''

Konwencją w tworzeniu aplikacji GWT jest umieszczanie pliku styli obok pliku strony początkowej. Oczywiście plik styli nie jest niczym niezwykłym w sensie tworzenia aplikacji internetowych z JavaScript, HTML i CSS, więc jego położenie może być dowolne. W szczególności plik może nie istnieć w ogóle.

 body {
     background-color: white;
     color: black;
     font-family: Arial, sans-serif;
     font-size: small;
     margin: 8px;
 }

Plik styli modułu - '''RejestrOsobowyGWT.css''' - umieszczamy w katalogu '''src/main/webapp/pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT'''

=== Konfiguracja modułu - RejestrOsobowyGWT.gwt.xml ===

Plik '''RejestrOsobowyGWT.gwt.xml''' jest konfiguracją modułu GWT, który poza definicją punktu początkowego aplikacji GWT, określa również jakie usługi zdalne są udostępniane.

 <module>
 
   <inherits name='com.google.gwt.user.User' />
 
   <entry-point class='pl.jaceklaskowski.gwt.rejestrosobowy.client.RejestrOsobowyGWT' />
 
   <servlet path="/services/rejestr" class="pl.jaceklaskowski.gwt.rejestrosobowy.server.RejestrImpl" />
 
 </module>

Jedyną usługą w module jest ''rejestr'' dostępną pod adresem ''/services/rejestr'' (atrybut ''path''), która realizowana jest przez klasę ''pl.jaceklaskowski.gwt.rejestrosobowy.server.RejestrImpl'' (atrybut '''class''').

Plik konfiguracji modułu - '''RejestrOsobowyGWT.gwt.xml''' - umieszczamy w katalogu '''src/main/resources/pl/jaceklaskowski/gwt/rejestrosobowy'''.

== Warstwa zarządzania danymi oparta o Java Persistence ==

=== Klasa encji Osoba - OsobaEncja ===

Rozdzielając warstwę GWT (przeglądarka) od warstwy serwerowej aplikacji utworzymy klasę '''OsobaEncja''', która będzie obiektem trwałym - encją - zarządzaną przez Java Persistence (JPA).

 package pl.jaceklaskowski.gwt.rejestrosobowy.server.entity;
 
 import java.io.Serializable;
 
 public class OsobaEncja implements Serializable {
     private String identyfikator;
     private String imie;
     private String nazwisko;
 
     // zabronione tworzenie osob bez imienia i nazwiska
     // JPA poradzi sobie z private
     private OsobaEncja() {
     }
 
     public OsobaEncja(String imie, String nazwisko) {
         super();
         this.imie = imie;
         this.nazwisko = nazwisko;
     }
 
     public String getIdentyfikator() {
         return identyfikator;
     }
 
     public void setIdentyfikator(String identyfikator) {
         this.identyfikator = identyfikator;
     }
 
     public String getImie() {
         return imie;
     }
 
     public void setImie(String imie) {
         this.imie = imie;
     }
 
     public String getNazwisko() {
         return nazwisko;
     }
 
     public void setNazwisko(String nazwisko) {
         this.nazwisko = nazwisko;
     }
 
     public String toString() {
         StringBuffer sb = new StringBuffer();
         sb.append(this.identyfikator);
         sb.append(" - ");
         sb.append(this.imie);
         sb.append(" ");
         sb.append(this.nazwisko);
         return sb.toString();
     }
 }

Jest to klasa identyczna składniowo z klasą wykorzystywaną po stronie przeglądarki w GWT - Osoba. W ten sposób oddzielamy warstwy GWT i JPA umożliwiając ich dalszy samodzielny rozwój bez konieczności modyfikacji obu warstw, jeśli będzie konieczne zmodyfikowanie którejkolwiek z klas. Kopiowaniem danych z warstwy JPA do GWT zajmuje się projekt [http://dozer.sourceforge.net/ Dozer].

Plik klasy - '''OsobaEncja.java''' - należy umieścić w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/server/entity'''.

=== Konfiguracja encji - orm.xml ===

Chcąc pozostawić możliwość skorzystania z pojedyńczego obiektu, który byłby przesyłany z serwera do przeglądarki i z powrotem tak, aby zapobiec sytuacji korzystania z identycznego obiektu składniowo w GWT i JPA, skorzystamy z możliwości definicji encji przy pomocy deskryptora XML - '''orm.xml'''.

 <?xml version="1.0" encoding="UTF-8" ?>
 <entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
   version="1.0">
   <description>Mapowanie JPA dla aplikacji Rejestr</description>
   <package>pl.jaceklaskowski.gwt.rejestrosobowy.server.entity</package>
   <entity class="OsobaEncja" name="Osoba" metadata-complete="false">
     <description>Encja Osoba</description>
     <named-query name="znajdzOsobyPoNazwisku">
       <query>SELECT o FROM Osoba o WHERE o.nazwisko LIKE :nazwisko</query>
     </named-query>
     <named-query name="podajIloscOsobPoNazwisku">
       <query>SELECT COUNT(o) FROM Osoba o WHERE o.nazwisko LIKE :nazwisko</query>
     </named-query>
     <attributes>
       <id name="identyfikator">
         <generated-value />
       </id>
       <basic name="imie" />
       <basic name="nazwisko" />
     </attributes>
   </entity>
 </entity-mappings>

Plik orm.xml jest alternatywnym sposobem definiowania encji w JPA poza mechanizmem adnotacji. Poza uciążliwością utrzymywania dwóch plików - klasy encji oraz orm.xml - wszystkie możliwości adnotacji są dostępne w orm.xml. Korzystając z orm.xml mamy możliwość zaniechania korzystania z adnotacji, które nie są rozumiane przez GWT i które powodowałyby komplikację, gdybyśmy chcieli jednak skorzystać z tej samej klasy w obu warstwach GWT i JPA.

Deskryptor XML definiuje dwa nazwane zapytania JPA - elementy named-query - oraz atrybuty encji. Wszystkie aspekty wydajnościowe pozostawiamy dostawcy JPA i stąd polegamy na ustawieniach domyślnych (jedna z głównym zalet nowej specyfikacji EJB 3.0 - przede wszystkim wartości domyślne nazwana w JPA konfiguracją przez nadpisywanie lub konfiguracją w wyjątkowych sytuacjach - ang. ''configuration by exception'').

Plik - '''orm.xml''' - umieszczamy w katalogu '''src/main/resources/META-INF'''.

=== Konfiguracja dostawcy JPA - persistence.xml ===

Wybór dostawcy JPA jest już bez znaczenia na samą architekturę aplikacji, podobnie jak w przypadku JDBC przy wyborze sterownika bazodanowego. Dostawca JPA jest właśnie sterownikiem JPA i jako taki może być zamieniany bez konieczności reorganizacji aplikacji.

Mimo tego konieczny jest wybór dostawcy JPA. Tym razem stawiamy na [http://incubator.apache.org/openjpa Apache OpenJPA]. Deklaracja dostawcy JPA odbywa się poprzez plik '''persistence.xml''', który konfiguruje usługę.

 <?xml version="1.0" encoding="UTF-8"?>
 <persistence version="1.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_1_0.xsd">
   <persistence-unit name="rejestr" transaction-type="RESOURCE_LOCAL">
     <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
     <properties>
       <property name="openjpa.ConnectionDriverName" value="org.apache.derby.jdbc.EmbeddedDriver" />
       <property name="openjpa.ConnectionURL" value="jdbc:derby:target/derbyDB;create=true" />
       <property name="openjpa.ConnectionUserName" value="app" />
       <property name="openjpa.ConnectionPassword" value="app" />
       <property name="openjpa.jdbc.DBDictionary" value="derby" />
       <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(SchemaAction='add,deleteTableContents')" />
       <property name="openjpa.Log" value="DefaultLevel=TRACE,SQL=TRACE" />
       <!-- Breaks maven-surefire-plugin with TestNG -->
       <property name="openjpa.QueryCompilationCache" value="false" />
     </properties>
   </persistence-unit>
 </persistence>

W pliku definiujemy obowiązkową nazwę dla jednostki trwałej (atrybut '''name''' elementu '''persistence-unit'''), za pomocą której dostaniemy się do trwałych danych.

Plik - '''persistence.xml''' - umieszczamy w katalogu '''src/main/resources/META-INF'''.

== Aplikacja internetowa - gwt-rejestrosobowy ==

=== Konfiguracja aplikacji internetowej - web.xml ===

Konfiguracja aplikacji internetowej jest realizowana za pomocą deskryptora '''web.xml'''. Jest on wymagany w naszym projekcie wyłącznie dla celów demonstracyjnych (utworzeniem pliku web.xml z usługą zdalną, która jest de facto servletem zajmuje się również wtyczka maven-googlewebtoolkit2-plugin), aby istniały dane osób do wyświetlenia w aplikacji. W pliku rejestrujemy klasę nasłuchującą - '''WypelnijBazeDanych''' - za pomocą elementu '''listener''', która zasili danymi bazę danych.

 <?xml version="1.0" encoding="UTF-8"?>
 
 <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee web-app_2_5.xsd" version="2.5">
   <display-name>Rejestr Osobowy GWT</display-name>
   <listener>
     <listener-class>pl.jaceklaskowski.gwt.rejestrosobowy.server.servlet.WypelnijBazeDanych</listener-class>
   </listener>
 </web-app>

Plik - '''web.xml''' - umieszczamy w katalogu '''src/main/webapp/WEB-INF'''.

=== Klasa nasłuchująca zdarzeń uruchomienia aplikacji - WypelnijBazeDanych ===

Na potrzeby aplikacji demonstrującej integrację GWT z JPA stworzymy klasę nasłuchującą zdarzeń uruchomienia aplikacji internetowej. Przy jej pomocy utworzymy przykładowe dane dla demonstracji poprawnego działania aplikacji.

 package pl.jaceklaskowski.gwt.rejestrosobowy.server.servlet;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
 import javax.persistence.Persistence;
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 
 import pl.jaceklaskowski.gwt.rejestrosobowy.server.entity.OsobaEncja;
 
 public class WypelnijBazeDanych implements ServletContextListener {
 
     EntityManagerFactory emf = null;
 
     public void contextDestroyed(ServletContextEvent evt) {
         emf.close();
     }
 
     public void contextInitialized(ServletContextEvent evt) {
         emf = Persistence.createEntityManagerFactory("rejestr");
         evt.getServletContext().setAttribute("entityManagerFactory", emf);
 
         EntityManager em = emf.createEntityManager();
         em.getTransaction().begin();
         OsobaEncja agata = new OsobaEncja("Agata", "Laskowska");
         OsobaEncja jacek = new OsobaEncja("Jacek", "Laskowski");
         OsobaEncja iweta = new OsobaEncja("Iweta", "Laskowska");
         OsobaEncja patryk = new OsobaEncja("Patryk", "Laskowski");
 
         em.persist(agata);
         em.persist(jacek);
         em.persist(iweta);
         em.persist(patryk);
 
         em.getTransaction().commit();
         em.close();
     }
 
 }

'''UWAGA''': Tymczasowo ignorujemy błędy związane z niedostępnością wymaganych typów.

Plik - '''WypelnijBazeDanych.java''' - umieszczamy w katalogu '''src/main/java/pl/jaceklaskowski/gwt/rejestrosobowy/server/servlet'''.

== Konfiguracja projektu - pom.xml ==

Wszystkie zależności projektu są umieszczane w konfiguracji projektu - '''pom.xml'''. Jest to centralne miejsce konfiguracji projektu zarządzanego przez Apache Maven 2. Dotychczasowe błędy związane z brakiem typów były związane z brakującymi wpisami w pom.xml. Nadeszła pora nadrabić straty.

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>pl.jaceklaskowski.gwt.rejestrosobowy</groupId>
   <artifactId>gwt-rejestrosobowy</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Rejestr Osobowy GWT</name>
   <url>http://www.JacekLaskowski.pl</url>
   <repositories>
     <repository>
       <id>gwt-maven</id>
       <url>http://gwt-maven.googlecode.com/svn/trunk/mavenrepo</url>
     </repository>
     <repository>
       <id>apache-snapshots</id>
       <name>Apache Snapshots Repository</name>
       <url>http://people.apache.org/maven-snapshot-repository</url>
       <layout>default</layout>
       <snapshots>
         <enabled>true</enabled>
         <updatePolicy>daily</updatePolicy>
         <checksumPolicy>ignore</checksumPolicy>
       </snapshots>
       <releases>
         <enabled>false</enabled>
       </releases>
     </repository>
   </repositories>
   <pluginRepositories>
     <pluginRepository>
       <id>gwt-maven</id>
       <url>http://gwt-maven.googlecode.com/svn/trunk/mavenrepo</url>
     </pluginRepository>
   </pluginRepositories>
   <build>
     <finalName>${pom.artifactId}</finalName>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-antrun-plugin</artifactId>
         <executions>
           <execution>
             <id>openjpa.PCEnhancer</id>
             <phase>process-classes</phase>
             <configuration>
               <tasks>
                 <java classname="org.apache.openjpa.enhance.PCEnhancer" classpathref="maven.runtime.classpath"
                   dir="target/classes" fork="true" failonerror="true" />
               </tasks>
             </configuration>
             <goals>
               <goal>run</goal>
             </goals>
           </execution>
         </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.0</version>
         <configuration>
           <source>1.5</source>
           <target>1.5</target>
         </configuration>
       </plugin>
       <plugin>
         <groupId>com.totsp.gwt</groupId>
         <artifactId>maven-googlewebtoolkit2-plugin</artifactId>
         <version>1.5.3-SNAPSHOT</version>
         <configuration>
           <runTarget>pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT/RejestrOsobowyGWT.html</runTarget>
           <compileTarget>
             <param>pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT</param>
           </compileTarget>
           <gwtHome>c:/apps/gwt</gwtHome>
         </configuration>
         <executions>
           <execution>
             <goals>
               <goal>mergewebxml</goal>
               <goal>compile</goal>
             </goals>
           </execution>
         </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-war-plugin</artifactId>
         <version>2.0.2</version>
         <configuration>
           <webXml>target/web.xml</webXml>
         </configuration>
       </plugin>
       <plugin>
         <groupId>org.mortbay.jetty</groupId>
         <artifactId>maven-jetty-plugin</artifactId>
       </plugin>
     </plugins>
   </build>
   <dependencies>
     <dependency>
       <groupId>com.google.gwt</groupId>
       <artifactId>gwt-user</artifactId>
       <version>1.3.3</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>com.google.gwt</groupId>
       <artifactId>gwt-servlet</artifactId>
       <version>1.3.3</version>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.1</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.apache.openjpa</groupId>
       <artifactId>openjpa-all</artifactId>
       <version>0.9.8-incubating-SNAPSHOT</version>
     </dependency>
     <dependency>
       <groupId>net.sf.dozer</groupId>
       <artifactId>dozer</artifactId>
       <version>3.3.1</version>
     </dependency>
     <dependency>
       <groupId>org.apache.derby</groupId>
       <artifactId>derby</artifactId>
       <version>10.2.2.0</version>
     </dependency>
     <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.14</version>
     </dependency>
   </dependencies>
 </project>

Po zmianie zależności ponownie generujemy pliki projektu dla wybranego środowiska programistycznego IDE - '''mvn eclipse:eclipse'''.

== Budowanie i uruchomienie aplikacji ==

Projekt zarządzany jest przez M2, więc wszystkie polecenia wydawane w projekcie są wykonywane z poziomu M2. Nie inaczej będzie i w przypadku uruchomienia aplikacji. Korzystanie z M2 zawsze przynosi dużo uproszczeń w zestawianiu kompletnego środowiska programistycznego. Może zdumiewać prostota uruchomienia aplikacji na serwerze aplikacji - [http://tomcat.apache.org Apache Tomcat] bądź [http://jetty.mortbay.org Jetty] - bez konieczności wstępnej ich konfiguracji. Dla dalszego uproszczenia procesu uruchomienia aplikacji wybieramy serwer Jetty, gdyż wtyczka dla M2 - [http://jetty.mortbay.org/maven-plugin/index.html maven-jetty-plugin] - wydaje się być bardziej zaawansowana w funkcjonalności zarządzania aplikacjami na serwerze. Wybór serwera produkcyjnego pozostawiamy na inny czas, polegając tym razem na jedynym, istotnym kryterium - łatwości konfiguracji i uruchomienia.

Zanim przejdziemy do uruchomienia (semi)produkcyjnego na Jetty sprawdźmy uruchomienie aplikacji w dedykowanym środowisku uruchomieniowym GWT w trybie bez kompilacji do JavaScript (ang. ''GWT hosted mode''). Wydajemy polecenie '''mvn clean gwt:gwt'''.

 $ mvn clean gwt:gwt
 [INFO] Scanning for projects...
 [INFO] Searching repository for plugin with prefix: 'gwt'.
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building Rejestr Osobowy GWT
 [INFO]    task-segment: [clean, gwt:gwt]
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] Running GWT with command: c:\apps\java5\jre\bin\java ...com.google.gwt.dev.GWTShell...

W tym momencie uruchomi się środowisko GWT i można przetestować funkcjonalność aplikacji.

::[[Grafika:gwt-rejestrosobowy-hostedmode.png]]

Zamykamy środowisko uruchomieniowe GWT i przechodzimy do wykonania kolejnego etapu w życiu naszej aplikacji - uruchomienia aplikacji w ramach serwera Jetty, co sprowadza się do pojedyńczego polecenia '''mvn clean jetty:run-exploded'''.

 $ mvn clean jetty:run-exploded
 [INFO] Scanning for projects...
 [INFO] Searching repository for plugin with prefix: 'jetty'.
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building Rejestr Osobowy GWT
 [INFO]    task-segment: [clean, jetty:run-exploded]
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] [jetty:run-exploded]
 [INFO] Configuring Jetty for project: Rejestr Osobowy GWT
 2007-05-13 23:51:08.906::INFO:  Logging to STDERR via org.mortbay.log.StdErrLog
 [INFO] Context path = /gwt-rejestrosobowy
 [INFO] Tmp directory = c:\gwt-rejestrosobowy\target\work
 [INFO] Web defaults =  jetty default
 [INFO] Starting jetty 6.1.0pre0 ...
 2007-05-13 23:51:08.968::INFO:  jetty-6.1.0pre0
 ...
 2007-05-13 23:51:14.000::INFO:  Started SelectChannelConnector @ 0.0.0.0:8080
 [INFO] Started Jetty Server

W tym momencie mamy możliwość uruchomienia aplikacji w przeglądarce otwierając stronę pod adresem http://localhost:8080/gwt-rejestrosobowy/pl.jaceklaskowski.gwt.rejestrosobowy.RejestrOsobowyGWT/RejestrOsobowyGWT.html.

::[[Grafika:gwt-rejestrosobowy.PNG]]

Zatrzymanie serwera i zamknięcie aplikacji to wciśnięcie kombinacji klawiszy Ctrl-C na konsoli, gdzie uruchomiono polecenie mvn clean jetty:run-exploded.

Przygotowanie wersji dystrybucyjnej aplikacji to wydanie polecenia '''mvn clean package''', które utworzy plik '''gwt-rejestrosobowy.war''' w katalogu '''target''' projektu.

 $ mvn clean package
 [INFO] Scanning for projects...
 [INFO] ----------------------------------------------------------------------------
 [INFO] Building Rejestr Osobowy GWT
 [INFO]    task-segment: [clean, package]
 [INFO] ----------------------------------------------------------------------------
 ...
 [INFO] Building war: c:\gwt-rejestrosobowy\target\gwt-rejestrosobowy.war
 [INFO] ------------------------------------------------------------------------
 [INFO] BUILD SUCCESSFUL
 [INFO] ------------------------------------------------------------------------
 [INFO] Total time: 17 seconds
 [INFO] Finished at: Sun May 13 23:57:48 CEST 2007
 [INFO] Final Memory: 13M/254M
 [INFO] ------------------------------------------------------------------------