JavaServer Faces i Spring Framework w parze z Apache Maven i Apache Geronimo
Z Jacek Laskowski - Wiki Projektanta Java EE
Do tej pory dużo rozpisywałem się o Korporacyjnej Javie 5 (Java EE 5) i tym razem...nie będzie inaczej (bo jak nie skorzystać z czegoś, co jest do wzięcia na wyciągnięcie ręki?!). Różnicą będzie wykorzystanie możliwości usług serwera aplikacji i rozszerzenie ich o możliwości Spring Framework. A skąd pomysł na skorzystanie ze Springa? Tym, co skłania do użycia Spring Framework jest jego zaawansowany mechanizm wstrzeliwania zależności (ang. DI - dependency injection), który w korporacyjnej javie jest stosunkowo mocno okrojony, powiedziałbym zawężony do niezbędnego minimum. Skoro siłą Springa jest mechanizm wstrzeliwania zależności, a serwera aplikacji Java EE 5 usługi, jak transakcyjność, utrwalanie danych, bezpieczeństwo, współbieżność, czy możliwość ich rozproszenia, to dlaczegóżby nie połączyć obu, aby mieć doskonalsze środowisko do tworzenia aplikacji korporacyjnych? Zawsze mnie korciło, aby bliżej przyjrzeć się Springowi, więc nadeszła pora upiec dwie pieczenie na jednym ogniu - rozpoznawać Springa w kontekście rozpoznawania kolejnej technologii Java EE 5 - JavaServer Faces (JSF) 1.2. W JSF istnieje pewien wycinek wsparcia dla DI, który oferuje Spring, więc mając zintegrowane oba rozwiązania spodziewam się, że wszelkie braki w JSF zostaną uzupełnione. Pozostaje pytanie o dalsze elementy środowiska, które pomogą w realizacji celu. Do programowania w Javie wykorzystam Eclipse IDE 3.3.1.1 z wtyczką Geronimo Eclipse Plugin, podczas gdy zarządzanie zależnościami aplikacyjnymi pozostawię projektowi, który spisuje się w tej roli bezsprzecznie najlepiej Apache Maven 2. Nie, nie chciałbym tym razem uskuteczniać akrobacji z linii poleceń, więc integrację między Eclipse IDE i Maven oprę na wtyczce M2Eclipse (Tycho). Środowiskiem uruchomieniowym tworzonej aplikacji internetowej będzie Apache Geronimo 2.0.2.
Całe środowisko będzie przyczółkiem do dalszych integracji w celu wykorzystania najlepszych cech poszczególnych projektów i technologii upraszczając proces tworzenia aplikacji korporacyjnych Java EE 5, gdzie głównym rozgrywającym będzie JSF 1.2.
Oprogramowanie
Środowisko składa się z następujących elementów:
- Apache Geronimo 2.0.2
- Eclipse 3.3.1.1
- Geronimo Eclipse Plugin 2.0.0
- Spring Framework 2.5-rc1
- Apache Maven 2.0.7
- M2Eclipse (Tycho)
Kompletny projekt jsf-spring-geronimo-webapp do zaimportowania do Eclipse dostępny jest jako jsf-spring-geronimo-webapp.zip.
Konfiguracja początkowa Eclipse
Rozpoczniemy od zestawienia środowiska Eclipse 3.3.1.1 z wtyczką do Apache Geronimo, do którego dodam wtyczkę M2Eclipse.
Instalacja Eclipse z wtyczką Geronimo
Istnieją dwa sposoby na konfigurację Eclipse do pracy z Geronimo - pobranie Eclipse i dopasowanie do niego odpowiednich wersji wtyczek pomocniczych, a następnie doinstalowanie wtyczki Geronimo lub skorzystanie ze skryptu Anta z pakietu wtyczki (sekcja Prerequisites na stronie Apache Geronimo Development Tools Subproject), który zrobi to za nas (poza zainstalowaniem samej wtyczki Geronimo Eclipse Plugin). Wybieramy drugą opcję.
Skrypt Ant build.xml zakłada, że jest wykonywany z poziomu Apache Maven 2 (dalej zwanym m2) podczas budowania wtyczki ze źródeł, więc wykonanie skryptu explicite będzie tworzyło katalog ${LOCAL_M2_REPO}. Z tego powodu należy uruchomić skrypt ze zmienną LOCAL_M2_REPO wskazującą na katalog roboczy
ant -DLOCAL_M2_REPO=eclipse-geronimo win32
, gdzie w eclipse-geronimo znajdzie się podkatalog eclipse/eclipse z gotowym do uruchomienia Eclipse z potrzebnymi wtyczkami (poza wtyczką Geronimo Eclipse Plugin).
Instalujemy wtyczkę Geronimo Eclipse Plugin zgodnie z instrukcją opisaną na stronie Geronimo Eclipse Plugin Installation Instructions.
Instalacja serwera Geronimo
Podobnie jak w przypadku instalacji wtyczki Geronimo do Eclipse mamy dwa rozwiązania - instalacja manualna polegająca na pobraniu odpowiedniej paczki dystrybucyjnej Geronimo ze strony Apache Geronimo v2.0.2 - Released October 19, 2007 lub skorzystanie z pomocy wtyczki Geronimo w Eclipse, która podczas konfiguracji serwera pozwala na automatyczne pobranie paczki dystrybucyjnej Geronimo i instalację w wybranym katalogu. Wybieram pierwsze podejście - instalację tradycyjną.
Instalacja Geronimo sprowadza się do pobrania wersji dystrybucyjnej Geronimo 2.0.2 i jej rozpakowanie do wybranego katalogu.
Resztę wykonamy z poziomu Eclipse IDE.
Definicja serwera Geronimo w Eclipse
Po poprawnej instalacji wtyczki Geronimo Eclipse Plugin możemy przystapić do utworzenia konfiguracji samego serwera Apache Geronimo 2.0.2 w Eclipse. Wybieramy menu Window > Preferences, a następnie w okienku dialogowym preferencji projektu wybieramy Server > Installed Runtimes.
Wciskamy przycisk Add... i przechodzimy do okienka dialogowego New Server Runtime.
Wybieramy pozycję Apache Geronimo v2.0 i wciskamy przycisk Next >.
Podajemy miejsce instalacji Geronimo, np. C:\geronimo-jetty6-jee5-2.0.2 (opcjonalnie moglibyśmy pobrać serwer z Sieci za pomocą przycisku Download and Install) i wciskamy przycisk Finish.
Zatwierdzamy przyciskiem OK.
Aplikacja internetowa jsf-spring-geronimo-webapp
Utworzenie aplikacji w Eclipse
Tworzymy projekt aplikacji internetowej jsf-spring-geronimo-webapp w Eclipse za pomocą kombinacji klawiszy Ctrl-N, a następnie Web > Dynamic Web Project, gdzie wybieramy Apache Geronimo v2.0 jako serwer aplikacji w Target Runtime oraz JavaServer Faces v1.2 Project w polu Configurations.
Wciskamy przycisk Next >.
Zaznaczamy Geronimo Deployment, dzięki któremu edycja deskryptorów wdrożenia specyficznych dla Geronimo będzie prostsza (dodane zostaną specjalizowane edytory do deskryptorów Geronimo).
Wciskamy przycisk Next > dwukrotnie, aż do panelu Geronimo Deployment Plan, gdzie podamy konfigurację aplikacji na potrzeby Geronimo. Jest to krok opcjonalny, jednakże znacząco upraszcza późniejszą administrację aplikacją i stąd jest zalecany.
- Group Id: pl.jaceklaskowski.jsfspring
- Artifact Id: jsf-spring-geronimo-webapp
- Version: 1.0
- Artifact Type: car
W okienku dialogowym JSF Capabilities definiujemy bibliotekę JSF 1.2, aby Eclipse mógł wesprzeć tworzenie aplikacji z jej pomocą. Zgodnie z wymaganiem specyfikacji Java EE 5 biblioteka realizująca specyfikację JSF 1.2 jest dostarczana przez sam serwer i nie powinna być dystrybuowana w ramach aplikacji.
Definiujemy nową bibliotekę JSF wciskając przycisk New..., gdzie w panelu JSF Library dodajemy odpowiednie biblioteki dostępne w repozytorium Geronimo.
UWAGA: Uzupełniliśmy bibliotekę JSF o dodatkowy geronimo-el_1.0_spec-1.0.jar, gdyż w przeciwnym przypadku, podczas rejestracji Springa w aplikacji internetowej, Eclipse zgłosiłby błąd niedostępności klasy javax.el.ELResolver, na której opiera się integracja Spring Framework z JSF.
Zatwierdzamy zmiany wciskając przycisk Finish.
W oknie JSF Capabilities, gdzie wybrana jest właśnie zdefiniowana biblioteka Apache MyFaces 1.2.0 odznaczamy opcję Deploy.
Wciskamy przycisk Finish.
Podczas otwarcia projektu może pojawić się okienko dialogowe z pytaniem o zatwierdzenie licencji plików wspierających pracę z JSF w Eclipse.
Zatwierdzamy okienko przyciskiem I Agree i przechodzimy do perspektywy Java EE wciskając przycisk Yes w kolejnym oknie dialogowym.
Projekt został utworzony.
Warto zwrócić uwagę na plik geronimo-web.xml (w katalogu WEB-INF), który został stworzony podczas tworzenia projektu z wtyczką Geronimo. Do edycji pliku dostarczony jest specjalizowany edytor - Geronimo Deployment Plan Editor.
Rozszerzenie zależności aplikacji o Spring Framework za pomocą M2Eclipse
W dalszej części skorzystamy z pomocy wtyczki M2Eclipse.
Za pomocą wtyczki M2Eclipse włączamy obsługę zależności projektowych zarządzanych przez m2 - menu kontekstowe Maven > Enable Dependency Management.
Określamy konfigurację dla projektu na potrzeby m2:
- Version: 1.0.0
Wciskamy przycisk Finish.
W wyniku zostanie stworzony plik pom.xml - serce projektu zarządzanego przez m2.
Dodanie zależności Spring będzie wymagało zmodyfikowania pliku pom.xml o definicję dedykowanego repozytorium bibliotek Springa zgodnie z opisem na stronie Maven Artifacts. Wykorzystanie m2 ma tę zaletę, że pozostałe zależności Springa zostaną pobrane poza naszym udziałem (oczywiście zakłada się tutaj dostęp do Internetu podczas budowania aplikacji).
Plik pom.xml powinien ostatecznie wyglądać następująco:
<?xml version="1.0" encoding="UTF-8"?>
<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.jsfspring</groupId>
<artifactId>jsf-spring-geronimo-webapp</artifactId>
<version>1.0.0</version>
<repositories>
<repository>
<id>spring-milestone</id>
<name>Spring Portfolio Milestone Repository</name>
<url>http://s3.amazonaws.com/maven.springframework.org/milestone</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>2.5-rc1</version>
</dependency>
</dependencies>
</project>
Strona domowa aplikacji - powitanie.jsp
Tworzymy stronę domową aplikacji powitanie.jsp, której zawartość powinna być następująca (opieram się o aplikację stworzoną w moim artykule Tworzenie aplikacji z JavaServer Faces, Apache Maven i Apache Geronimo):
<%@ page contentType="text/html; charset=ISO-8859-2"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<f:view>
<f:loadBundle basename="pl.jaceklaskowski.jsfspring.Komunikaty" var="komunikat" />
<head>
<title><h:outputText value="#{komunikat.powitanie}" /></title>
</head>
<body>
<center>
<a href="http://geronimo.apache.org"><h:graphicImage alt="Apache Geronimo 2" url="/images/geronimo.gif" style="border: 0"/></a>
<br>
<h1><h:outputText value="#{komunikat.powitanie}" /></h1>
</center>
</body>
</f:view>
Domyślnie pliki o rozszerzeniu jsp są obsługiwane przez edytor JSP Editor, jednakże Eclipse dostarcza alternatywnego edytora na potrzeby tworzenia aplikacji JSF - Web Page Editor. Otwieramy plik powitanie.jsp w edytorze Web Page Editor, który dostępny jest w menu kontekstowym Open With > Web Page Editor. Jest to jedna z niereklamowanych szeroko możliwości Eclipse w kontekście wsparcia projektów JSF.
Strona pomocnicza aplikacji - index.jsp
Strona pomocnicza aplikacji index.jsp służy do przekierowania użytkownika na stronę domową aplikacji powitanie.jsp poprzez adres związany z obsługą stron JSF - faces/.
<jsp:forward page="faces/powitanie.jsp"/>
Konfiguracja projektu JSF - rozwiązywanie błędów zgłoszonych przez Eclipse
Wprowadzone zmiany spowodują, że Eclipse IDE zgłosi błędy rozwiązywania nazw bibliotek znaczników JSP - taglib oraz kilka ostrzeżeń o nieznajomości innych elementów strony.
Zajmijmy się najpierw błędami.
Wybieramy menu kontekstowe projektu Properties, gdzie dodajemy bibliotekę JSF - Apache MyFaces 1.2.0, którą zdefiniowaliśmy podczas zestawiania projektu (i która zakładałem, że będzie częścią projektu od samego początku).
Następnie wybieramy przycisk Add Library..., a po nim zaznaczamy JSF Libraries
i wciskamy przycisk Next >.
W okienku JSF Library zaznaczamy bibliotekę Apache MyFaces 1.2.0 [implementation].
Wciskamy przycisk Finish.
Kiedy pojawi się błąd o podwojeniu bibliotek usuwamy biblioteki Apache Geronimo v2.0 [Apache Geronimo v2.0] (do czasu znalezienia właściw(sz)ego rozwiązania takie podejście wydaje się najbardziej rozsądne).
Wybieramy Maven2 Dependencies w J2EE Module Dependencies.
Zatwierdzamy zmiany przyciskiem OK.
Ostatecznie rozprawiamy się z błędami wywołując menu kontekstowe Validate.
Pozostałe komunikaty ostrzegawcze rozwiążemy podczas tworzenia aplikacji i możemy je chwilowo zignorować.
Element graficzny aplikacji - geronimo.gif
Tworzymy katalog WebContent/images, w którym umieszczamy plik graficzny geronimo.gif (pobrałem go z głównej strony projektu Apache Geronimo logo. Zapisz go w katalogu WebContent/images jako geronimo.gif).
Plik komunikatów - Komunikaty.properties
Tworzymy pakiet pl.jaceklaskowski.jsfspring,w którym umieszczamy plik komunikatów Komunikaty.properties.
powitanie=JavaServer Faces i Spring Framework w parze z Apache Maven i Apache Geronimo
Ostatecznie rozprawiamy się z ostrzeżeniami zgłoszonymi przez Eclipse zamykając (menu kontekstowe Close Project) i otwierając (menu kontekstowe Open Project) projekt. Jedynym pozostałym ostrzeżeniem będzie informacja o braku dołączenia biblioteki Apache MyFaces 1.2.0 do aplikacji - innymi słowy Eclipse stwierdził, że aplikacja korzysta z biblioteki, która nie trafi do jej katalogu WEB-INF/lib, co jest świadomym krokiem, gdyż biblioteki JSF będą dostarczone przez Geronimo.
Uruchomienie aplikacji (bez Spring Framework)
Sprawdźmy działanie naszej aplikacji uruchamiając ją na Geronimo.
Wybieramy menu kontekstowe Run As > Run on Server.
Wybieramy Apache Geronimo v2.0 Server oraz zaznaczamy opcję Always use this server when running this project
i wciskamy przycisk Finish.
Kiedy pojawi się Started przy Geronimo
otwieramy przeglądarkę z adresem http://localhost:8080/jsf-spring-geronimo-webapp/, który uruchomi aplikację.
Wszystko działa zgodnie z oczekiwaniami. Zatrzymajmy Geronimo za pomocą menu Stop i kontynujemy rozwój aplikacji.
Konfiguracja Spring Framework w aplikacji
Modyfikacje pliku konfiguracyjnego aplikacji internetowej - web.xml
Rozpoczynamy od modyfikacji pliku web.xml - serca aplikacji internetowej przez dodanie klasy aktywującej kontekst Springa org.springframework.web.context.ContextLoaderListener podczas startu aplikacji w sekcji listener. Przy okazji zmniejszamy listę plików akceptowanych jako początkowe w aplikacji w sekcji welcome-file-list.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<display-name>jsf-spring-geronimo-webapp</display-name>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
</web-app>
Modyfikacje pliku konfiguracyjnego JSF - faces-config.xml
Kolejnym krokiem rozszerzającym aplikację JSF o możliwości Springa jest modyfikacja pliku faces-config.xml o dodanie komponentu rozwiązującego nazwy zadeklarowane w jego konfiguracji - org.springframework.web.jsf.el.DelegatingFacesELResolver w sekcji el-resolver.
<?xml version="1.0" encoding="UTF-8"?>
<faces-config 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 http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd"
version="1.2">
<application>
<el-resolver>org.springframework.web.jsf.el.DelegatingFacesELResolver</el-resolver>
</application>
</faces-config>
Utworzenie ziarna Spring Framework - ziarnoSpringowe
Klasa ziarna - pl.jaceklaskowski.jsfspring.ZiarnoSpringowe
Dla celów demonstracyjnych stwórzmy ziarno - ziarnoSpringowe - zdefiniowane na poziomie Springa, które będzie reprezentowane przez klasę pl.jaceklaskowski.jsfspring.ZiarnoSpringowe (z braku lepszego pomysłu poprzestajemy przy tak wyrafinowanej nazwie).
package pl.jaceklaskowski.jsfspring;
public class ZiarnoSpringowe {
public String getPozdrowienia() {
return "Pozdrowienia od ziarna ze Spring Framework";
}
}
Klasa jest wystarczająco prosta, aby nie silić się na przydługie elaboraty o jej znaczeniu. Dla naszych potrzeb w zupełności wystarczy.
Konfiguracja ziarna w applicationContext.xml
Pozostaje zdefiniować ziarno ziarnoSpringowe w pliku konfiguracyjnym Springa applicationContext.xml, który domyślnie poszukiwany jest w katalogu WEB-INF.
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"> <bean name="ziarnoSpringowe" class="pl.jaceklaskowski.jsfspring.ZiarnoSpringowe" /> </beans>
Dodanie ziarna do strony index.jsp
Na koniec skorzystamy z ziarna ziarnoSpringowe na stronie powitanie.jsp. Zmodyfikujmy stronę o kontrolkę h:outputText wyświetlającą powitanie (a dokładniej wywołujacą metodę getPozdrowienia() ziarna ziarnoSpringowe).
<%@ page contentType="text/html; charset=ISO-8859-2"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<f:view>
<f:loadBundle basename="pl.jaceklaskowski.jsfspring.Komunikaty" var="komunikat" />
<head>
<title><h:outputText value="#{komunikat.powitanie}" /></title>
</head>
<body>
<center>
<a href="http://geronimo.apache.org"><h:graphicImage alt="Apache Geronimo 2" url="/images/geronimo.gif" style="border: 0"/></a>
<br>
<h1><h:outputText value="#{komunikat.powitanie}" /></h1>
<br>
<h1><h:outputText value="#{ziarnoSpringowe.pozdrowienia}"/></h1>
</center>
</body>
</f:view>
Uruchomienie aplikacji JSF ze Spring Framework
Nadeszła chwila prawdy, w której przekonamy się, czy nasza aplikacja internetową z JSF i Spring Framework jsf-spring-geronimo-webapp zostanie poprawnie uruchomiona na Geronimo.
Uruchamiamy aplikację na Geronimo za pomocą menu Run As > Run on Server. Otwieramy przeglądarkę z adresem http://localhost:8080/jsf-spring-geronimo-webapp/, wstrzymujemy oddech i...
Działa! Tym samym utworzyliśmy platformę do dalszego zgłębiania tajemnic JavaServer Faces 1.2 i Spring Framework 2.5. Pozostaje zapoznać się z dokumentacją i wdrożyć co ciekawsze elementy do naszej aplikacji.
Literatura uzupełniająca
Na rozgrzewkę polecam artykuł Wiktora Gworka - Integracja JSF + Facelets + Spring + JPA + Tomahawk, w którym znalazłem kilka naprowadzających podpowiedzi.
Bardzo pomocnym, szczególnie, kiedy zaczałem powątpiewać w możliwości Eclipse wspierania projektów JSF, był artykuł WTP Tutorials - JavaServer Faces Tools Tutorial.
Pewnych podpowiedzi odnośnie konfiguracji aplikacji JSF korzystającej ze Springa dostarczył artykuł Sample Application using JSF, Spring 2.0, and Java Persistence APIs.
Dokładny opis konfiguracji Spring Framework 2.5 z JSF znajduje się w dokumentacji Chapter 15. Integrating with other web frameworks.
