2. Narzędzia wykorzystane w niniejszym dokumencie

W niniejszym dokumencie wykorzystamy następujące narzędzia:

JDK Java 1.5
serwer WWW TOMCAT (http://tomcat.apache.org/),
środowisko programistyczne ECLIPSE (http://www.eclipse.org/) wraz z wtyczką WTP (Web Tools Package).
przeglądarka (IE, NETSCAPE, MOZILLA Firefox, OPERA, ...).

Są to narzędzia bezpłatne. Ogólnie rzecz biorąc, w tworzeniu stron internetowych można wykorzystać wiele narzędzi open source:

`IDE JAVA`	`Jbuilder Foundation`	http://www.borland.com/jbuilder/foundation/index.html
`IDE JAVA`	`Eclipse`	http://www.eclipse.org/
`Bibliothèques JAVA`	`Struts`	http://struts.apache.org/
`Bibliothèques JAVA`	`Spring`	http://www.springframework.org
`SGBD`	`MySQL`	http://www.mysql.com/
	`Postgres`	http://www.postgresql.org/
	`Firebird`	http://firebird.sourceforge.net/
	`Hypersonic`	http://hsqldb.sourceforge.net/
	`SQL Server Express 2005`	http://msdn.microsoft.com/vstudio/express/sql/
	`Oracle Express`	http://www.oracle.com/database/index.html
`Conteneurs de servlets`	`Tomcat`	http://tomcat.apache.org/
	`Resin`	http://www.caucho.com/
	`Jetty`	http://jetty.mortbay.org/jetty/
`Navigateurs`	`Netscape`	http://www.netscape.com/
`Navigateurs`	`Mozilla`	http://www.mozilla.org

2.1. J ava 1.5

Kontener serwletów Tomcat 5.x wymaga wirtualnej maszyny Java 1.5. Należy zatem najpierw zainstalować tę wersję Javy, którą można znaleźć na stronie firmy Sun pod adresem [http://www.sun.com] -> [http://java.sun.com/j2se/1.5.0/download.jsp] (maj 2006):

krok 1:

étape 2 :

krok 3:

Uruchom instalację JDK 1.5 z pobranego pliku.

2.2. Kontener serwletów Tomcat 5

Aby uruchamiać serwlety, potrzebujemy kontenera serwletów. Przedstawiamy tutaj jeden z nich, Tomcat 5.x, dostępny pod adresem http://tomcat.apache.org/. Opisujemy procedurę (maj 2006 r.) jego instalacji. Jeśli poprzednia wersja Tomcata jest już zainstalowana, zaleca się jej wcześniejsze usunięcie.

Aby pobrać produkt, należy skorzystać z powyższego linku [Tomcat 5.x]:

Należy pobrać plik .exe przeznaczony dla platformy Windows. Po pobraniu pliku należy uruchomić instalację serwera Tomcat:

Kliknij [next] ->

Zakceptuj warunki licencji ->

Wprowadź [next] ->

Zaakceptuj proponowany katalog instalacyjny lub zmień go za pomocą [Browse] ->

Ustaw login i hasło administratora serwera Tomcat. Tutaj wprowadzono [admin / admin] ->

Tomcat 5.x wymaga wersji JRE 1.5. Zazwyczaj powinien on sam znaleźć wersję zainstalowaną na komputerze. Powyżej wskazano ścieżkę do pliku JRE 1.5 pobranego w punkcie 2.1. Jeśli nie zostanie znaleziony żaden plik JRE, należy wskazać jego katalog główny za pomocą przycisku [1]. Po wykonaniu tej czynności należy użyć przycisku [Install], aby zainstalować Tomcat 5.x ->

Przycisk [Finish] kończy instalację. Obecność serwera Tomcat jest sygnalizowana ikoną po prawej stronie paska zadań systemu Windows:

Kliknięcie prawym przyciskiem myszy na tę ikonę umożliwia dostęp do poleceń uruchamiania i wyłączania serwera:

Używamy opcji [Stop service], aby teraz zatrzymać serwer WWW:

Zwróć uwagę na zmianę stanu ikony. Ikona ta może zostać usunięta z paska zadań:

Instalacja serwera Tomcat odbyła się w folderze wybranym przez użytkownika, który odtąd będziemy nazywać <tomcat>. Struktura tego folderu dla pobranej wersji Tomcat 5.5.17 wygląda następująco:

Instalacja serwera Tomcat spowodowała dodanie kilku skrótów do menu [Démarrer]. Korzystamy z poniższego linku [Monitor], aby uruchomić narzędzie do zatrzymywania i uruchamiania serwera Tomcat:

Pojawia się wtedy ikona przedstawiona wcześniej:

Monitor Tomcata można uruchomić, klikając dwukrotnie tę ikonę:

Przyciski [Start - Stop - Pause] – Restart pozwalają nam uruchomić, zatrzymać i ponownie uruchomić serwer. Uruchamiamy serwer za pomocą przycisku [Start], a następnie w przeglądarce wpisujemy adres http://localhost:8080. Powinna pojawić się strona podobna do poniższej:

Można skorzystać z poniższych linków, aby sprawdzić, czy Tomcat został poprawnie zainstalowany:

Wszystkie linki na stronie [http://localhost:8080] są interesujące i zachęcamy czytelnika do ich przeglądania. Będziemy mieli okazję powrócić do linków umożliwiających zarządzanie aplikacjami internetowymi wdrożonymi na serwerze:

2.3. Wdrażanie aplikacji internetowej na serwerze Tomcat

Materiały do przeczytania [ref1]: rozdział 1, rozdział 2: 2.3.1, 2.3.2, 2.3.3

2.3.1. Wdrażanie

Aplikacja internetowa musi spełniać określone zasady, aby mogła zostać wdrożona w kontenerze serwletów. Niech <webapp> będzie katalogiem aplikacji internetowej. Aplikacja internetowa składa się z:

`classes`	w folderze <webapp>\WEB-INF\classes
`archives java`	w folderze <webapp>\WEB-INF\lib
`vues, ressources (.jsp, .html, ...)`	w folderze <webapp> lub w podfolderach

Aplikacja internetowa jest konfigurowana za pomocą pliku XML: <webapp>\WEB-INF\web.xml.

Stwórzmy aplikację internetową o następującej strukturze katalogów:

Powyższą strukturę katalogów utworzymy za pomocą Eksploratora Windows. Katalogi [classes] i [lib] są tutaj puste. Katalog [vues] zawiera statyczny plik HTML:

którego zawartość jest następująca:

<html>
    <head>
      <title>Application exemple</title>
  </head>
  <body>
      Application exemple active ....
  </body>
</html>

Po załadowaniu tego pliku w przeglądarce wyświetla się następująca strona:

Kod URL wyświetlany przez przeglądarkę wskazuje, że strona nie została dostarczona przez serwer WWW, lecz została załadowana bezpośrednio przez przeglądarkę. Chcemy teraz, aby była ona dostępna za pośrednictwem serwera WWW Tomcat.

Wróćmy do struktury katalogów <tomcat>:

Konfiguracja aplikacji internetowych wdrożonych na serwerze Tomcat odbywa się za pomocą plików XML umieszczonych w folderze [<tomcat>\conf\Catalina\localhost]:

Pliki XML można utworzyć ręcznie, ponieważ mają prostą strukturę. Zamiast jednak stosować tę metodę, skorzystamy z narzędzi internetowych oferowanych przez serwer Tomcat.

2.3.2. Administracja serwerem Tomcat

Na stronie startowej http://localhost:8080 serwer udostępnia linki umożliwiające jego administrowanie:

Link [Tomcat Administration] umożliwia konfigurację zasobów udostępnianych przez Tomcat wdrożonym w nim aplikacjom internetowym, na przykład puli połączeń z bazą danych. Przejdźmy do tego linku:

Wyświetlona strona informuje nas, że do administrowania serwerem Tomcat 5.x wymagany jest specjalny pakiet o nazwie „admin”. Wróćmy na stronę serwisu Tomcat:

Pobierzmy plik ZIP o nazwie [Administration Web Application], a następnie rozpakujmy go. Jego zawartość jest następująca:

Folder [admin] należy skopiować do folderu [<tomcat>\server\webapps], gdzie <tomcat> to folder, w którym zainstalowano Tomcat 5.x:

Folder [localhost] zawiera plik [admin.xml], który należy skopiować do folderu [<tomcat>\conf\Catalina\localhost]:

Zatrzymajmy, a następnie uruchommy ponownie serwer Tomcat, jeśli był aktywny. Następnie w przeglądarce ponownie wywołajmy stronę startową serwera WWW:

Kliknijmy link [Tomcat Administration]. Pojawi się strona logowania:

Uwaga: w rzeczywistości, aby wyświetlić poniższą stronę, musiałem najpierw ręcznie wpisać adres URL [http://localhost:8080/admin/index.jsp]. Dopiero wtedy powyższy link [Tomcat Administration] zadziałał. Nie wiem, czy było to wynikiem błędu proceduralnego z mojej strony.

W tym miejscu należy ponownie podać dane, które podaliśmy podczas instalacji Tomcata. W naszym przypadku podajemy parę admin / admin. Przycisk [Login] przenosi nas na następną stronę:

Ta strona umożliwia administratorowi serwera Tomcat zdefiniowanie

źródła danych (Data Sources),
informacje niezbędne do wysyłania wiadomości e-mail (Mail Sessions),
dane środowiskowe dostępne dla wszystkich aplikacji (Environment Entries),
zarządzać użytkownikami/administratorami serwera Tomcat (Users),
zarządzać grupami użytkowników (Groups),
definiowanie ról (= co użytkownik może, a czego nie może robić),
definiowanie właściwości aplikacji internetowych wdrożonych przez serwer (Service Catalina)

Kliknijmy powyższy link [Roles]:

Rola pozwala określić, co może, a czego nie może robić użytkownik lub grupa użytkowników. Z rolą wiążą się określone uprawnienia. Każdy użytkownik jest przypisany do jednej lub kilku ról i dysponuje uprawnieniami z nich wynikającymi. Poniższa rola [manager] przyznaje uprawnienia do zarządzania aplikacjami internetowymi wdrożonymi w Tomcat (wdrażanie, uruchamianie, zatrzymywanie, wyładowywanie). Utworzymy użytkownika o nazwie [manager], którego przypiszemy do roli [manager], aby umożliwić mu zarządzanie aplikacjami w Tomcat. W tym celu klikamy link [Users] na stronie administracyjnej:

Widzimy, że istnieje już pewna liczba użytkowników. Korzystamy z opcji [Create New User], aby utworzyć nowego użytkownika:

Przypisujemy użytkownikowi o nazwie „manager” hasło „manager” oraz rolę „manager”. Korzystamy z przycisku [Save], aby zatwierdzić dodanie tego użytkownika. Nowy użytkownik pojawia się na liście użytkowników:

Ten nowy użytkownik zostanie dodany do pliku [<tomcat>\conf\tomcat-users.xml]:

którego zawartość jest następująca:

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="manager" password="manager" fullName="" roles="manager"/>
  <user username="admin" password="admin" roles="admin,manager"/>
</tomcat-users>

wiersz 10: użytkownik [manager], który został utworzony

Innym sposobem dodawania użytkowników jest bezpośrednia edycja tego pliku. Należy tak postąpić zwłaszcza w przypadku, gdy przypadkiem zapomniano hasła administratora „admin” lub „manager”.

2.3.3. Zarządzanie wdrożonymi aplikacjami internetowymi

Wróćmy teraz do strony logowania [http://localhost:8080] i kliknijmy link [Tomcat Manager]:

Pojawia się strona uwierzytelniania. Logujemy się jako manager / manager, c.a.d – użytkownik z rolą [manager], którego właśnie utworzyliśmy. Tylko użytkownik posiadający tę rolę może bowiem skorzystać z tego linku. W wierszu 11 rekordu [tomcat-users.xml] widzimy, że użytkownik [admin] posiada również rolę [manager]. Moglibyśmy zatem skorzystać również z uwierzytelnienia [admin / admin].

Otrzymujemy stronę zawierającą listę aplikacji obecnie wdrożonych w Tomcat:

Możemy dodać nową aplikację za pomocą formularzy znajdujących się na dole strony:

W tym przypadku chcemy wdrożyć w serwerze Tomcat przykładową aplikację, którą stworzyliśmy wcześniej. Robimy to w następujący sposób:

`Context Path`	/przykład	nazwa używana do określenia aplikacji internetowej, która ma zostać wdrożona
`Directory URL`	C:\data\2005-2006\eclipse\dvp-eclipse-tomcat\przykład	folder aplikacji internetowej

Aby uzyskać plik [C:\data\2005-2006\eclipse\dvp-eclipse-tomcat\exemple\vues\exemple.html], poprosimy Tomcat o pliki URL i [http://localhost:8080/exemple/vues/exemple.html]. Kontekst służy zatem do nadania nazwy katalogowi głównemu drzewa katalogów wdrożonej aplikacji internetowej. Używamy przycisku [Deploy], aby przeprowadzić wdrożenie aplikacji. Jeśli wszystko przebiegnie pomyślnie, otrzymamy następującą stronę odpowiedzi:

a nowa aplikacja pojawia się na liście wdrożonych aplikacji:

Omówmy powyższy wiersz z kontekstu /example:

`/exemple`	link do http://localhost:8080/exemple
`Démarrer`	umożliwia uruchomienie aplikacji
`Arrêter`	umożliwia zamknięcie aplikacji
`Recharger`	umożliwia ponowne załadowanie aplikacji. Jest to konieczne na przykład po dodaniu, zmodyfikowaniu lub usunięciu niektórych klas z aplikacji.
`Undeploy`	usunięcie kontekstu [/exemple]. Aplikacja znika z listy dostępnych aplikacji.

Teraz, gdy nasza aplikacja /exemple została wdrożona, możemy przeprowadzić kilka testów. Wywołujemy stronę [exemple.html] za pomocą adresu URL [http://localhost:8080/exemple/vues/exemple.html]:

Innym sposobem wdrożenia aplikacji internetowej na serwerze Tomcat jest umieszczenie informacji, które podaliśmy za pośrednictwem interfejsu internetowego, w pliku [contexte].xml umieszczonym w folderze [<tomcat>\conf\Catalina\localhost], gdzie [contexte] to nazwa aplikacji internetowej.

Wróćmy do interfejsu administracyjnego serwera Tomcat:

Usuńmy aplikację [/exemple] wraz z jej linkiem [Undeploy]:

Aplikacja [/exemple] nie znajduje się już na liście aktywnych aplikacji. Teraz zdefiniujmy następujący plik [exemple.xml]:

1 2	`<Context docBase="C:/data/2005-2006/eclipse/dvp-eclipse-tomcat/exemple"> </Context>`

Plik XML składa się z pojedynczego tagu <Context>, którego atrybut docBase określa katalog zawierający aplikację internetową, która ma zostać wdrożona. Umieśćmy ten plik w katalogu <tomcat>\conf\Catalina\localhost:

W razie potrzeby zatrzymajmy i uruchommy ponownie Tomcat, a następnie wyświetlmy listę aktywnych aplikacji za pomocą menedżera Tomcat:

Aplikacja [/exemple] jest widoczna. W przeglądarce wpiszmy adres URL:

[http://localhost:8080/exemple/vues/exemple.html]:

Tak wdrożoną aplikację internetową można usunąć z listy wdrożonych aplikacji w taki sam sposób jak poprzednio, korzystając z linku [Undeploy]:

W tym przypadku plik [exemple.xml] jest automatycznie usuwany z folderu [<tomcat>\conf\Catalina\localhost].

Wreszcie, aby wdrożyć aplikację internetową w środowisku Tomcat, można również zdefiniować jej kontekst w pliku [<tomcat>\conf\server.xml]. Nie będziemy jednak tutaj rozwijać tego zagadnienia.

2.3.4. Aplikacja internetowa ze stroną główną

Po wywołaniu adresu URL [http://localhost:8080/exemple/] otrzymujemy następującą odpowiedź:

Wynik ten zależy od konfiguracji serwera Tomcat. W poprzednich wersjach otrzymalibyśmy zawartość fizycznego katalogu aplikacji [/exemple]. Dobrze, że obecnie serwer Tomcat domyślnie uniemożliwia takie wyświetlanie.

Można skonfigurować system tak, aby po wywołaniu kontekstu wyświetlana była tzw. strona startowa. W tym celu tworzymy plik [web.xml], który umieszczamy w folderze <przykład>\WEB-INF, gdzie <przykład> to fizyczny folder aplikacji internetowej [/exemple]. Plik ten ma następującą treść:

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

  <display-name>Application Exemple</display-name>
  <description>Application web minimale</description>
    <welcome-file-list>
        <welcome-file>/vues/exemple.html</welcome-file>
    </welcome-file-list>    
</web-app>

wiersze 2–5: tag główny <web-app> z atrybutami skopiowanymi i wklejonymi z pliku [web.xml] aplikacji [/admin] w Tomcat (<tomcat>/server/webapps/admin/WEB-INF/web.xml).
wiersz 7: nazwa wyświetlana aplikacji internetowej. Jest to nazwa dowolna, podlegająca mniejszym ograniczeniom niż nazwa kontekstu aplikacji. Można w niej umieścić na przykład spacje, co nie jest możliwe w przypadku nazwy kontekstu. Nazwa ta jest wyświetlana na przykład przez administratora Tomcata:

wiersz 8: opis aplikacji internetowej. Tekst ten można następnie uzyskać programowo.
wiersze 9–11: lista plików powitalnych. Tag <welcome-file-list> służy do zdefiniowania listy widoków, które mają być wyświetlane, gdy klient żąda kontekstu aplikacji. Widoków może być kilka. Pierwszy znaleziony widok jest wyświetlany klientowi. W tym przypadku mamy tylko jeden: [/vues/exemple.html]. W związku z tym, gdy klient zażąda adresu URL [/exemple], w rzeczywistości otrzyma adres URL [/exemple/vues/exemple.html].

Zapiszmy ten plik [web.xml] w katalogu <przykład>\WEB-INF:

Jeśli Tomcat nadal działa, można wymusić ponowne załadowanie aplikacji internetowej [/exemple] za pomocą linku [Recharger]:

Podczas tej operacji „ponownego ładowania” Tomcat ponownie odczytuje plik [web.xml] zawarty w [<exemple>\WEB-INF], o ile taki plik istnieje. W tym przypadku tak właśnie jest. Jeśli serwer Tomcat został zatrzymany, należy go ponownie uruchomić.

Za pomocą przeglądarki wywołajmy plik URL [http://localhost:8080/exemple/]:

Mechanizm plików hostujących zadziałał.

2.4. Instalacja Eclipse

Eclipse to wielojęzyczne środowisko programistyczne. Jest szeroko stosowane w programowaniu w języku Java. Jest to narzędzie, które można rozszerzać poprzez dodawanie narzędzi zwanych wtyczkami. Istnieje ogromna liczba wtyczek i to właśnie stanowi o sile Eclipse.

Eclipse jest dostępny pod adresem [http://www.eclipse.org/downloads/]:

Chcemy wykorzystać Eclipse do tworzenia aplikacji internetowych w języku Java. Istnieje na ten cel szereg wtyczek. Pomagają one w sprawdzaniu poprawności składni stron JSP, plików XML... oraz umożliwiają testowanie aplikacji internetowej bezpośrednio w środowisku Eclipse. Skorzystamy z jednej z tych wtyczek, o nazwie Web Tools Package (WTP). Standardowa procedura instalacji Eclipse wygląda zazwyczaj następująco:

zainstalować Eclipse
zainstalować potrzebne wtyczki

Wtyczka WTP wymaga z kolei innych wtyczek, co sprawia, że jej instalacja jest dość skomplikowana. Dlatego też strona Eclipse oferuje pakiet zawierający platformę programistyczną Eclipse oraz wtyczkę WTP wraz ze wszystkimi innymi wtyczkami, których ta ostatnia potrzebuje. Pakiet ten jest dostępny na stronie Eclipse (maj 2006 r.) pod adresem [http://download.eclipse.org/webtools/downloads/]:

Kliknijmy powyższy link [1.0.2]:

Pobieramy pakiet [wtp] za pomocą powyższego linku. Uzyskany plik ZIP zawiera następujące elementy:

Wystarczy rozpakować tę zawartość do folderu. Od tej pory będziemy nazywać ten folder <eclipse>. Jego zawartość jest następująca:

[eclipse.exe] to plik wykonywalny, a [eclipse.ini] to jego plik konfiguracyjny. Przyjrzyjmy się jego zawartości:

1
2
3

-vmargs
-Xms40m
-Xmx256m

Argumenty te są używane podczas uruchamiania programu Eclipse w następujący sposób:

eclipse.exe -vmargs -Xms40m -Xmx256m

Ten sam efekt, jaki daje plik .ini, można uzyskać, tworząc skrót uruchamiający Eclipse z tymi samymi argumentami. Wyjaśnijmy je:

-vmargs: wskazuje, że kolejne argumenty są przeznaczone dla wirtualnej maszyny Java, która będzie uruchamiać Eclipse. Eclipse jest bowiem aplikacją Java.
-Xms40m: ?
-Xmx256m: ustala rozmiar pamięci w MB przydzielony dla maszyny wirtualnej Java (JVM), która uruchamia Eclipse. Domyślnie rozmiar ten wynosi 256 MB, jak pokazano tutaj. Jeśli maszyna na to pozwala, zalecane jest 512 MB.

Argumenty te są przekazywane do JVM, który uruchamia Eclipse. JVM jest reprezentowany przez plik [java.exe] lub [javaw.exe]. Jak ten plik jest lokalizowany? W rzeczywistości jest on wyszukiwany na różne sposoby:

w pliku PATH zawartym w pliku OS
w folderze <JAVA_HOME>/jre/bin, gdzie JAVA_HOME jest zmienną systemową określającą katalog główny pliku JDK.
w lokalizacji przekazanej jako argument do Eclipse w postaci -vm <ścieżka>\javaw.exe

To ostatnie rozwiązanie jest preferowane, ponieważ pozostałe dwa są podatne na nieprzewidziane skutki późniejszych instalacji aplikacji, które mogą albo zmienić ścieżkę PATH w OS, albo zmienić zmienną JAVA_HOME.

Tworzymy zatem następujący skrót:

`cible`	<eclipse>\eclipse.exe -vm "C:\Program Files\Java\jre1.5.0_06\bin\javaw.exe" -vmargs -Xms40m -Xmx512m
`Démarrer dans`	folder instalacyjny Eclipse <eclipse>

Po wykonaniu tych czynności uruchommy Eclipse za pomocą tego skrótu. Pojawi się pierwsze okno dialogowe:

[workspace] to obszar roboczy. Przyjmijmy proponowane wartości domyślne. Domyślnie projekty Eclipse będą tworzone w folderze <workspace> określonym w tym oknie dialogowym. Istnieje sposób na obejście tego zachowania. Będziemy to robić systematycznie. Dlatego odpowiedź udzielona w tym oknie dialogowym nie ma znaczenia.

Po zakończeniu tego etapu wyświetla się środowisko programistyczne Eclipse:

Zamykamy widok [Welcome] zgodnie z powyższą sugestią:

Przed utworzeniem projektu Java skonfigurujemy Eclipse tak, aby wskazać JDK jako narzędzie do kompilacji projektów Java. W tym celu wybieramy opcję [Window / Preferences / Java / Installed JREs ]:

Zazwyczaj JRE (Java Runtime Environment), który został użyty do uruchomienia samego Eclipse, powinien znajdować się na liście JRE. Zazwyczaj będzie to jedyna pozycja. Możliwe jest dodanie elementów JRE za pomocą przycisku [Add]. Należy wówczas wskazać katalog główny elementu JRE. Z kolei przycisk [Search] uruchamia wyszukiwanie pliku JREs na dysku. Jest to dobry sposób na sprawdzenie, na jakim etapie jesteśmy z plikami JREs, które zainstalowaliśmy, a następnie zapomnieliśmy odinstalować przy przejściu na nowszą wersję. Powyżej zaznaczony plik JRE jest tym, który zostanie użyty do kompilacji i uruchamiania projektów Java.

JRE, który zostanie wykorzystany w naszych przykładach, to ten, który został zainstalowany w punkcie 2.1 i który posłużył również do uruchomienia Eclipse. Dwukrotne kliknięcie na nim daje dostęp do jego właściwości:

Teraz utwórzmy projekt Java o nazwie [File / New / Project]:

Wybierz [Java Project], a następnie [Next] ->

W [2] wskazujemy pusty folder, w którym zostanie zainstalowany projekt Java. W [1] nadajemy nazwę projektowi. Nie musi on nosić nazwy folderu, jak mogłoby to sugerować powyższe przykład. Po wykonaniu tych czynności używamy przycisku [Finish], aby zakończyć pracę kreatora. Oznacza to akceptację wartości domyślnych proponowanych na kolejnych stronach kreatora.

Otrzymujemy wówczas szkielet projektu Java:

Kliknijmy prawym przyciskiem myszy na projekt [test1], aby utworzyć klasę Java:

w [1], czyli folderze, w którym zostanie utworzona klasa. Eclipse domyślnie proponuje folder bieżącego projektu.
w [2] – pakiet, w którym zostanie umieszczona klasa
w [3] – nazwa klasy
w [4] żądamy wygenerowania metody statycznej [main]

Potwierdzamy działanie kreatora za pomocą [Finish]. Projekt zostaje wówczas wzbogacony o klasę:

Eclipse wygenerowało szkielet klasy. Można go wyświetlić, klikając dwukrotnie powyższy element [Test1.java]:

Modyfikujemy powyższy kod w następujący sposób:

Uruchamiamy program [Test1.java]: [clic droit sur Test1.java -> Run As -> Java Application]

Wynik wykonania programu wyświetla się w oknie [Console]:

2.5. Integracja Tomcat – Eclipse

Aby móc pracować z Tomcatem, pozostając w środowisku Eclipse, musimy zadeklarować ten serwer w konfiguracji Eclipse. W tym celu wybieramy opcję [File / New / Other]. Pojawia się wówczas następujący kreator:

Decydujemy się na utworzenie nowego serwera. Wybieramy powyższą ikonę [Server], a następnie wykonujemy [Next]:

Dodanie serwera powoduje pojawienie się folderu w eksploratorze projektów Eclipse:

Aby zarządzać serwerem Tomcat z poziomu Eclipse, wyświetlamy widok o nazwie [Servers], korzystając z opcji [Window -> Show View -> Other -> Server]:

Wybierz [OK]. Pojawi się wówczas widok [Servers]:

W tym widoku wyświetlają się wszystkie zadeklarowane serwery, w tym przypadku serwer Tomcat 5.5, który właśnie zarejestrowaliśmy. Kliknięcie prawym przyciskiem myszy na nim daje dostęp do poleceń umożliwiających uruchomienie, zatrzymanie i ponowne uruchomienie serwera:

Powyżej uruchamiamy serwer. Podczas jego uruchamiania w widoku [Console] zapisywanych jest kilka logów:

11 mai 2006 15:31:16 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
INFO: The Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: C:\Program Files\Java\jre1.5.0_06\bin;.;C:\WINDOWS\system32;...
11 mai 2006 15:31:16 org.apache.coyote.http11.Http11BaseProtocol init
INFO: Initialisation de Coyote HTTP/1.1 sur http-8080
...
INFO: Server startup in 1641 ms

Zrozumienie tych logów wymaga pewnej wprawy. Na razie nie będziemy się nad tym rozwodzić. Ważne jest jednak, aby sprawdzić, czy nie sygnalizują one błędów ładowania kontekstów. W rzeczywistości po uruchomieniu serwer Tomcat / Eclipse próbuje załadować konteksty aplikacji, którymi zarządza. Załadowanie kontekstu aplikacji wiąże się z wykorzystaniem jej pliku [web.xml] oraz załadowaniem jednej lub kilku klas, które go inicjują. W tym momencie może wystąpić kilka rodzajów błędów:

plik [web.xml] zawiera błędy składniowe. Jest to najczęstszy błąd. Zaleca się korzystanie z narzędzia umożliwiającego sprawdzenie poprawności dokumentu XML podczas jego tworzenia.
nie znaleziono niektórych klas, które należy załadować. Są one wyszukiwane w plikach [WEB-INF/classes] i [WEB-INF/lib]. Zazwyczaj należy sprawdzić obecność niezbędnych klas oraz pisownię tych, które zostały zadeklarowane w pliku [web.xml].

Serwer uruchomiony z poziomu Eclipse nie ma takiej samej konfiguracji jak ten zainstalowany w punkcie 2.2 na stronie 5. Aby się o tym przekonać, wywołajmy adres URL [http://localhost:8080] w przeglądarce:

Ta odpowiedź nie oznacza, że serwer nie działa, ale że żądany zasób / nie jest dostępny. W przypadku serwera Tomcat zintegrowanego z Eclipse zasobami tymi będą projekty internetowe. Omówimy to później. Na razie zatrzymajmy serwer Tomcat:

Poprzedni tryb działania można zmienić. Wróćmy do widoku [Servers] i kliknijmy dwukrotnie na serwer Tomcat, aby uzyskać dostęp do jego właściwości:

Pole wyboru [1] odpowiada za poprzedni tryb działania. Gdy jest zaznaczone, aplikacje internetowe opracowane w środowisku Eclipse nie są deklarowane w plikach konfiguracyjnych powiązanego serwera Tomcat, lecz w oddzielnych plikach konfiguracyjnych. W ten sposób nie mamy do dyspozycji aplikacji zdefiniowanych domyślnie na serwerze Tomcat: [admin] i [manager], które są dwoma przydatnymi aplikacjami. Dlatego odznaczamy pole wyboru [1] i ponownie uruchamiamy serwer Tomcat:

Po wykonaniu tych czynności wywołajmy adres URL [http://localhost:8080] w przeglądarce:

Obserwujemy działanie opisane w punkcie 2.3.3 na stronie 15.

W poprzednich przykładach korzystaliśmy z przeglądarki zewnętrznej względem środowiska Eclipse. Można również skorzystać z przeglądarki wbudowanej w środowisko Eclipse:

Powyżej wybieramy przeglądarkę wbudowaną. Aby uruchomić ją z poziomu Eclipse, można użyć następującej ikony:

Rzeczywiście uruchomiona zostanie przeglądarka wybrana za pomocą opcji [Window -> Web Browser]. W tym przypadku otrzymujemy przeglądarkę wbudowaną:

W razie potrzeby uruchommy Tomcat z poziomu Eclipse i wpiszmy w [1] adres URL [http://localhost:8080]:

Kliknijmy link [Tomcat Manager]:

Wymagana jest para [login / mot de passe], aby uzyskać dostęp do aplikacji [manager]. Zgodnie z konfiguracją serwera Tomcat, którą wykonaliśmy wcześniej, można wpisać [admin / admin] lub [manager / manager]. W ten sposób otrzymujemy listę wdrożonych aplikacji:

Widzimy aplikację [personne], którą utworzyliśmy. Powiązany link [Recharger] przyda nam się później.