10 lutego 2007

requiredMessage i resource-bundle - udoskonalona kontrola komunikatów w JSF 1.2

3 komentarzy
Co nie dotknę, to coś nowego. Po prostu strach cokolwiek dotykać! ;-)

Po przeczytaniu sekcji 3.5 Encyjni obserwatorzy i metody przechwytujące specyfikacji JPA postanowiłem przygotować aplikację internetową, która pomogłaby mi utrwalić przeczytany materiał. Skorzystałem z pomocy NetBeans IDE 5.5.1 i GlassFish v2.

Rozpocząłem od stworzenia projektu i zabrałem się za tworzenie stron JSF. Pierwsza strona umożliwiała podanie nazwy użytkownika w polu h:inputText. Poszło gładko. Zdefiniowałem komponent zarządzany user, który miał przechowywać informację o wprowadzonym identyfikatorze użytkownika. Nie korzystałem z NetBeans Visual Web Pack 5.5, więc wszystko robiłem ręcznie, aż w pewnym momencie, edytując stworzony faces-config.xml dostrzegłem, że jestem w JSF 1.2 (!) Pomyślałem, że jest to dobra pora, aby zapoznać się z kilkoma dobrodziejstwami JSF 1.2, co zaraz przerodziło się w wykorzystanie gdzie się dało Unified EL, tj. tam, gdzie w poprzedniej wersji należało skorzystać z h:outputText teraz można zastąpić prostszymi konstrukcjami znanymi z JSP i JSTL, czyli ${nazwaKomponentuZarządzanego.atrybut}. Kiedy przyszło do przypisania komponentu zarządzanego user do h:inputText zauważyłem atrybut, którego z pewnością nie było w poprzedniej wersji JSF 1.1 - requiredMessage.

Zmiana komunikatów w JSF 1.1 związanych z obsługą błędów kontroli poprawności wprowadzonych danych nie była ani łatwa, ani zaawansowana (aż trudno uwierzyć, że twórcom JSF udało się to połączyć, zazwyczaj jest albo jedno, albo drugie). Zmiana komunikatów błędów polegała na dostarczeniu pliku komunikatów z odpowiednimi identyfikatorami, których wartości były zmodyfikowanymi komunikatami (w tym i tłumaczeniami). Bardziej zaawansowane modyfikacje komunikatów błędów wymagały zastosowania pewnych sztuczek (więcej w artykule Hansa Bergstena Designing and Implementing Web Application Interfaces).

W JSF 1.2 udostępniono atrybut requiredMessage. Wartość atrybutu requiredMessage jest komunikatem błędu, który będzie wyświetlany w przypadku niepodania przez użytkownika obowiązkowej wartości w polu typu UIInput (wymaganie nałożone przez zastosowanie atrybutu required dla kontrolek h:inputText, h:inputSecret, h:inputHidden i h:inputTextArea), bądź identyfikatorem komunikatu w aplikacyjnym pliku komunikatów. Komunikat (egzemplarz klasy FacesMessage) będzie umieszczony w FacesContext zamiast domyślnego.

<h:inputText id="name" value="#{user.name}" required="true" requiredMessage="Nie podano nazwy użytkownika" />

W powyższym przykładzie, jeśli użytkownik nie poda nazwy użytkownika wyświetlony zostanie komunikat Nie podano nazwy użytkownika (oczywiście samo wyświetlenie można zrealizować z pomocą h:message albo h:messages).

Na uwagę zasługuje jednak inna cecha requiredMessage - możliwość wskazania na właściwy komunikat w pliku komunikatów.

<h:inputText id="name" value="#{user.name}" required="true" requiredMessage="#{validationMessages.usernameMissing}" />

W ten sposób, w zależności od aktywnego ustawienia regionalnego (ang. locale), wyświetlony zostanie właściwy komunikat błędu w aktywnym języku. Ale co to jest validationMessages?

Poniżej znajduje się wycinek pliku konfiguracyjnego JSF - faces-config.xml:

<application>
<resource-bundle>
<base-name>pl.jaceklaskowski.ewt.faces.ValidationMessages</base-name>
<var>validationMessages</var>
</resource-bundle>
</application>
Zmienna validationMessages reprezentuje mapę komunikatów (z kluczami będącymi identyfikatorami komunikatów), a pl.jaceklaskowski.ewt.faces.ValidationMessages jest nazwą pliku komunikatów bez rozszerzenia .properties (w formacie java.util.Properties) o zawartości:

usernameMissing=Nie podano nazwy użytkownika!

Specyfikacja JSF 1.2 opisuje atrybut jako współpracujący z f:loadBundle, jednakże nie udało mi się tego powiązać. W dodatku znalazłem wiadomość na forum JavaServer Faces, która wskazywałaby, że taka możliwość nie ma prawa działać - requiredMessage and EL?.

Poza tym podobną funkcjonalność można wykorzystać do komunikatów związanych z mechanizmem konwersji i kontroli poprawności (walidacji) za pomocą atrybutów converterMessage oraz validatorMessage, odpowiednio.

Dobre wprowadzenie do zmian w JSF 1.2 znajduje się w artykule Web Tier to Go With Java EE 5: Summary of New Features in JavaServer Faces 1.2 Technology. Na lekturę specyfikacji JSF 1.2 przyjdzie jeszcze pora ;-)

Ciekawostki języka Java

9 komentarzy
Pracuję z Javą od pierwszych dni jej opublikowania. Ostatnio zdobyłem certyfikat SCJP 5.0 i wydawałoby się, że to wystarczy do zagwarantowania dogłębnej znajomości języka. Ale jak pokazały wydarzenia dnia wczorajszego, niekoniecznie.

Pierwsza ciekawostka dotyczyła dostępu do zmiennych i metod prywatnych (składowych klasy oznaczonych słowem kluczowym private). Skoro prywatnych to wydawałoby się, że sprawa jasna - nikt poza ich klasą macierzystą nie ma prawa ich "dotknąć". Ale, jak się okazało, nie jest to precyzyjna definicja.

Możnaby zadać pytanie, jak bardzo utrzymywana jest prywatność składowych klasy (pól i metod)? Nie sądzę, aby nie znalazła się przynajmniej jedna osoba programująca na codzień w Javie, która nie złapałaby się za głowę, kiedy ujrzałaby działanie poniższego programu. Czy zapytana, potrafiłba odpowiedzieć jaki będzie wynik kompilacji i przyjmując, że kompilacja się zakończy poprawnie, jaki będzie wynik działania poniższego programu? Uwagę powinien przyciągnąć dostęp do prywatnego pola i metody w metodzie statycznej main.
  package accesscontrol;

public class Private {

private int privateMember;

public Private(int privateMember) {
this.privateMember = privateMember;
}

public static void modifyPrivateField(Private p) {
p.privateMember *= 2;
}

private void callPrivateMethod() {
System.out.println("Prywatna metoda wywołana! Na pewno?");
}

public static void main(String[] args) {
Private p = new Private(5);
System.out.println("p.privateMember (przed zmianą) = " + p.privateMember);
modifyPrivateField(p);
System.out.println("p.privateMember (po zmianie) = " + p.privateMember);
p.callPrivateMethod();
}
}
Spróbuj odpowiedzieć na pytania samodzielnie, zanim podam trochę dodatkowych informacji.

Skoro prywatne składowe klasy, to prywatne, tak? Otóż nie! Wszystko zależy od tego, kto dostępuje składowych prywatnych klasy. W Javie (mówi się, że podobnie jak w C++, ale przeciwnie do Smalltalk) dostęp do zmiennych prywatnych jest niemożliwy, za wyjątkiem sytuacji, w której wykonywane operacje są inicjowane przez klasę macierzystą. Dodać do tego należy, że dostęp do prywatnej składowej dowolnego egzemplarza klasy X wewnątrz metod klasy X jest również możliwy (!) Dla mnie taki dostęp był dostępem z zewnątrz, pomimo, że w klasie deklarującej ową prywatną składową.

Wytłumaczono mi to w ten sposób, że prywatne elementy służą ukrywaniu implementacji, wewnętrznej realizacji działania klasy i to ona sama podejmuje decyzje odnośnie prywatnych składowych. Może zatem podjąć decyzję o modyfikacji swoich własnych prywatnych składowych,w tym i dowolnego egzemplarza siebie samej.

Cała literatura nt. temat brzmi w takim stylu (wycinek z podręcznika Javy - The Java Tutorial sekcja Controlling Access to Members of a Class):

The private modifier specifies that the member can only be accessed in its own class.

Jak widać z zaprezentowanego przykładu, interpretacja powyższego wycinka może nie być satysfakcjonująca. Dla mnie nie była. Na szczęście specyfikacja języka Java - The Java Language Specification - w sekcji 6.6.1 Determining Accessibility zawiera precyzyjne wytłumaczenie:

If the member or constructor is declared private, then access is permitted if and only if it occurs within the body of the top level class (§7.6) that encloses the declaration of the member or constructor.

Może ranga dokumentu przekonuje mnie do tego wytłumaczenia, albo faktyczna jego precyzyjność, ale dla mnie wystarczająco tłumaczy zachowanie prywatnych składowych klas i ich widoczności w składowych klasy, nawet jeśli dotykają one egzemplarzy, ale tylko typu takiego samego, do jakiego one same należą.

Można zadać pytanie, a jak będzie w przypadku interfejsów? ;-) Uwaga: kawał!

Druga ciekawostka związana jest z wszechobecnymi adnotacjami, a szczególnie ich wykorzystaniu w tworzeniu aplikacji opartych o Java EE. Przedstawia się ją, a szczególnie ostatnio mnie absorbującą specyfikację EJB3 (wraz z JPA 1.0), jako bezinwazyjną, tzn. wymagania specyfikacji nie wprowadzają do klas żadnych zmian, które uniemożliwiłyby ich użycie poza środowiskiem serwera aplikacyjnego Java EE - zero wymaganych interfejsów, włączania do zadanej hierarchi dziedziczenia, itp.

Pytanie jakie mi zadano podczas ostatniej prezentacji specyfikacji EJB 3.0 dotyczyło obecności adnotacji w klasie, będącej z punktu widzenia serwera aplikacyjnego komponentem EJB (użycie adnotacji @Stateless) i jej uruchomieniu poza serwerem aplikacyjnym (co zdejmuje jej "specjalność").

Adnotacje wymagają importu klas je realizujących, np. @EJB będzie wymagało importu klasy javax.ejb.EJB. Pytanie jakie się pojawia to obecność klasy podczas kompilacji i uruchomienia (można postawić ogólniejszy problem, nie dotykający adotacji, a poruszający jedynie same deklaracje import). W którym momencie, klasa w imporcie będzie wymagana? Podczas kompilacji i uruchamiana, czy wyłącznie podczas kompilacji, a może jednak wyłącznie podczas uruchamiania? Dla zobrazowania problemu przedstawiam klasę, która wykorzystuje adnotację @EJB.
  package annotation;

import javax.ejb.EJB;

public class MissingAnnotationAtRuntime {

@EJB
private Object ejbRef;

public static void main(String[] args) {
System.out.println("Prezentacja programowania z adnotacjami bez nich podczas uruchomienia.");
}
}
Pytanie 1: Czy klasa skompiluje się bez dostępności klasy EJB?

Pytanie 2: Czy klasa może zostać uruchomiona bez dostępności klasy EJB?

Odpowiedź dostarczają poniższe sesje.
  $ java -version
java version "1.5.0_08"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_08-b03)
Java HotSpot(TM) Client VM (build 1.5.0_08-b03, mixed mode)

$ echo $CLASSPATH


$ javac annotation/MissingAnnotationAtRuntime.java
annotation/MissingAnnotationAtRuntime.java:3: package javax.ejb does not exist
import javax.ejb.EJB;
^
annotation/MissingAnnotationAtRuntime.java:7: cannot find symbol
symbol : class EJB
location: class annotation.MissingAnnotationAtRuntime
@EJB
^
2 errors
oraz
  $ echo $CLASSPATH


$ java -cp bin annotation.MissingAnnotationAtRuntime
Prezentacja programowania z adnotacjami bez nich podczas uruchomienia.
Zaskakujące? Dla mnie już nie!

09 lutego 2007

EJB 3.0 korzystając z JBoss AS 4.0.5.GA, JEMS Installer 1.2.0.GA i NetBeans IDE 5.5.1

1 komentarzy
Otwierając dzisiaj skrzynkę pocztową zobaczyłem wiadomość informującą o komentarzu do wpisu JBoss AS 4.0.5 z EJB 3.0 RC9 Patch 1 i NetBeans IDE 5.5.1, gdzie jonsnow napisał o usprawnieniu zestawiania środowiska z wykorzystaniem JEMS Installer.

Nie ukrywam, że zazwyczaj jestem sceptyczny do korzystania z narzędzi automatyzujących instalację, które nie tylko ukrywają faktycznie wykonywane kroki i na dodatek zapisują coś w rejestrach (pracuję na MS Windows), ale jeszcze przeczytałem informację o pewnej konkretnej konfiguracji JBoss AS, rozszerzenia EJB 3.0 i JEMS Installera, która miała prawo działać, co zniechęciło mnie zupełnie. Wiedząc, że JBoss AS 4.0.5 to nie jest serwer aplikacyjny Java EE 5 i daleko mu do niego (poza EJB3 oraz JPA, które serwera i tak nie wymaga) nie zagłębiałem się w ten temat dalej. Podobną sytuację mam w przypadku skorzystania z IBM WebSphere Application Server Version 6.1 Feature Pack for EJB 3, więc po co miałbym zajmować się JBoss AS 4? Poza tym pełniejszą implementację Java EE 5 mam chociażby w GlassFish v2 oraz Apache Geronimo v2. Mimo to, kiedy przeczytałem wiadomość od jonsnow pomyślałem, że mogę to sprawdzić. W końcu nic nie traciłem.

Co się okazało? Po około 30 minutach miałem zestawione kompletne środowisko do tworzenia semi-Java EE 5 aplikacji (semi wynika z niepełności JBoss AS 4.0.5 w realizowaniu Java EE 5 po stronie kontenera servletów - brak chociażby wstrzeliwania zależności, itp.).

Warto to odnotować, bo nie mogłem uwierzyć, że moje przestarzałe stereotypy o oprogramowaniu typu JEMS Installer wzięły kolejny raz górę nad zdrowym rozsądkiem. Wystarczyło poświęcić 15 minut na zapoznanie się z dokumentacją! Tylko, kto chciałby czytać dokumentację?!

Zacząłem od pobrania JEMS Installer 1.2.0.GA (właśnie owe GA było dla mnie kolejnym argumentem za sprawdzeniem jego możliwości). Uruchomienie instalacji było wskazane przez jonsnow, więc kopiuj-wklej (z drobnymi poprawkami dotyczącymi ścieżki instalacji JBoss AS 4) i ENTER.
  C:\>cd apps

C:\apps>java -jar jems-installer-1.2.0.GA.jar -installGroup ejb3 installpath=c:/apps/jboss-4.0.5.GA_ejb3
Obarczony stereotypami, uruchomiłem to w tle, a sam zabrałem się za bardziej wartościowe rzeczy niż przyglądanie się instalacji. Jakież było moje zdziwienie, kiedy dysk przestał intensywnie pracować po około 10-15 minutach! Pomyślałem, że zapewne Installer nie znalazł czegoś i zakończył swoje działanie z błędem myśląc, że zechciałbym mu pomóc. Zajrzałem na konsolę i co widzę:
C:\apps>java -jar jems-installer-1.2.0.GA.jar -installGroup ejb3 installpath=c:/apps/jboss-4.0.5.GA_ejb3
Looking for auto install resource...
/res/jbossauto-install.xml URL: jar:file:/C:/apps/jems-installer-1.2.0.GA.jar!/res/jbossauto-install.xml
PackageListener, install.log=C:\DOCUME~1\JLASKO~1\LOCALS~1\Temp\jems-install.log
[ Starting automated installation ]
creating Logfile: 'IzPack_Logfile_at_1171016018453.txt' in: 'C:\DOCUME~1\JLASKO~1\LOCALS~1\Temp\'
[ Starting to unpack ]
[ Processing package: ejb3-deployer (1/58) ]
[ Processing package: invokers-service (2/58) ]
[ Processing package: jta-service (3/58) ]
[ Processing package: mail-service (4/58) ]
[ Processing package: jboss-cache (5/58) ]
[ Processing package: jbossws5 (6/58) ]
[ Processing package: snmp-adaptor.sar (7/58) ]
[ Processing package: properties-service (8/58) ]
[ Processing package: javamail (9/58) ]
[ Processing package: jmx-console (10/58) ]
[ Processing package: jms-http-invoker (11/58) ]
[ Processing package: usertx-service (12/58) ]
[ Processing package: jboss-local-jdbc.rar (13/58) ]
[ Processing package: ear-deployer (14/58) ]
[ Processing package: security (15/58) ]
[ Processing package: naming (16/58) ]
[ Processing package: hibernate (17/58) ]
[ Processing package: jca-service (18/58) ]
[ Processing package: jboss-aop-jdk50-deployer (19/58) ]
[ Processing package: ejb-timer-service (20/58) ]
[ Processing package: iiop-service.xml (21/58) ]
[ Processing package: jms-socket-invoker (22/58) ]
[ Processing package: scheduler-service (23/58) ]
[ Processing package: web-console-jdk50 (24/58) ]
[ Processing package: jsr77-service (25/58) ]
[ Processing package: jgroups (26/58) ]
[ Processing package: quartz-rar (27/58) ]
[ Processing package: cache-invalidation-service.xml (28/58) ]
[ Processing package: jmx-core (29/58) ]
[ Processing package: bsh-deployer (30/58) ]
[ Processing package: jboss-ha-local-jdbc (31/58) ]
[ Processing package: mail-inflow-adaptor (32/58) ]
[ Processing package: jboss-ds (33/58) ]
[ Processing package: xmlresolver (34/58) ]
[ Processing package: jms-injvm-invoker (35/58) ]
[ Processing package: jsr88-service (36/58) ]
[ Processing package: jboss-xa-jdbc (37/58) ]
[ Processing package: jboss-ha-xa-jdbc (38/58) ]
[ Processing package: docs (39/58) ]
[ Processing package: binding-service (40/58) ]
[ Processing package: minimal (41/58) ]
[ Processing package: dynclassloader-service (42/58) ]
[ Processing package: ejb-deployer (43/58) ]
[ Processing package: uuid-key-generator (44/58) ]
[ Processing package: war-deployer (45/58) ]
[ Processing package: client-deployer-service (46/58) ]
[ Processing package: attribute-persistence-service (47/58) ]
[ Processing package: xmlservice (48/58) ]
[ Processing package: jmx-invoker-service (49/58) ]
[ Processing package: jboss-bean-deployer (50/58) ]
[ Processing package: client (51/58) ]
[ Processing package: jbossretro (52/58) ]
[ Processing package: rmi-http-invoker (53/58) ]
[ Processing package: jms-asf-rar (54/58) ]
[ Processing package: jbossmq-service (55/58) ]
[ Processing package: jdbc-metadata-service (56/58) ]
[ Processing package: default-jms-destintations (57/58) ]
[ Processing package: jboss-remoting (58/58) ]

calltarget:

jbossws-post-install:
[echo] Unpacking wstools to bin...
[unzip] Expanding: C:\apps\jboss-4.0.5.GA_ejb3\client\jbossws-client.jar into C:\apps\jboss-4.0.5.GA_ejb3\bin
[echo] Removing jbossws14 client jars...
[delete] Deleting 4 files from C:\apps\jboss-4.0.5.GA_ejb3\client
[delete] Deleting C:\apps\jboss-4.0.5.GA_ejb3\client\jboss-backport-concurrent.jar
[delete] Deleting C:\apps\jboss-4.0.5.GA_ejb3\client\jbossretro-rt.jar
[delete] Deleting C:\apps\jboss-4.0.5.GA_ejb3\client\jbossws14-client.jar
[delete] Deleting C:\apps\jboss-4.0.5.GA_ejb3\client\namespace.jar
[echo] jbossws done

calltarget:

chmod-bin:
[echo] Updating script executable modes
[echo] bin dir is c:/apps/jboss-4.0.5.GA_ejb3/bin
[ Unpacking finished. ]
creating Logfile: 'IzPack_Logfile_at_1171016018453.txt' in: 'C:\DOCUME~1\JLASKO~1\LOCALS~1\Temp\'
[ Writing the uninstaller data ... ]
[ Automated installation done ]

C:\apps>
Widzę migający kursor na konsoli i zakończoną poprawnie instalację (!) Zaczynało mi się podobać. Jako pierwszy moduł instalowany zobaczyłem ejb3-deployer, więc dawało mi to pewność, że jest lepiej niż początkowo myślałem.

Co mogłem dalej zrobić, aby sprawdzić poprawność instalacji? Uruchomić serwer.
jlaskowski@dev /cygdrive/c/apps/jboss-4.0.5.GA_ejb3
$ ./bin/run.sh
=========================================================================

JBoss Bootstrap Environment

JBOSS_HOME: c:\apps\jboss-4.0.5.GA_ejb3

JAVA: /cygdrive/c/apps/java5/bin/java

JAVA_OPTS: -Dprogram.name=run.sh -server -Xms128m -Xmx512m -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000

CLASSPATH: c:\apps\jboss-4.0.5.GA_ejb3\bin\run.jar;c:\apps\java5\lib\tools.jar

=========================================================================

11:38:51,437 INFO [Server] Starting JBoss (MX MicroKernel)...
11:38:51,437 INFO [Server] Release ID: JBoss [Zion] 4.0.5.GA (build: CVSTag=Branch_4_0 date=200610162339)
11:38:51,437 INFO [Server] Home Dir: C:\apps\jboss-4.0.5.GA_ejb3
11:38:51,437 INFO [Server] Home URL: file:/C:/apps/jboss-4.0.5.GA_ejb3/
11:38:51,437 INFO [Server] Patch URL: null
11:38:51,437 INFO [Server] Server Name: default
11:38:51,437 INFO [Server] Server Home Dir: C:\apps\jboss-4.0.5.GA_ejb3\server\default
11:38:51,437 INFO [Server] Server Home URL: file:/C:/apps/jboss-4.0.5.GA_ejb3/server/default/
11:38:51,437 INFO [Server] Server Log Dir: C:\apps\jboss-4.0.5.GA_ejb3\server\default\log
11:38:51,437 INFO [Server] Server Temp Dir: C:\apps\jboss-4.0.5.GA_ejb3\server\default\tmp
11:38:51,437 INFO [Server] Root Deployment Filename: jboss-service.xml
11:38:51,921 INFO [ServerInfo] Java version: 1.5.0_08,Sun Microsystems Inc.
11:38:51,921 INFO [ServerInfo] Java VM: Java HotSpot(TM) Server VM 1.5.0_08-b03,Sun Microsystems Inc.
11:38:51,921 INFO [ServerInfo] OS-System: Windows XP 5.1,x86
11:38:52,500 INFO [Server] Core system initialized
11:38:55,156 INFO [WebService] Using RMI server codebase: http://dev:8083/
11:38:55,187 INFO [Log4jService$URLWatchTimerTask] Configuring from URL: resource:log4j.xml
11:38:58,406 INFO [SocketServerInvoker] Invoker started for locator: InvokerLocator [socket://9.164.187.15:3873/]
11:39:04,031 INFO [ServiceEndpointManager] WebServices: jbossws-1.0.3.SP1 (date=200609291417)
11:39:08,671 INFO [SnmpAgentService] SNMP agent going active
11:39:09,500 INFO [CorbaNamingService] Naming: [IOR:000000000000002B49444C3A6F6D672E6F72672F436F734E616D696E672F4E616D696E67436F6E746578744578743A312E300000000000020000000000000
8000102000000000D392E3136342E3138372E313500000DC8000000114A426F73732F4E616D696E672F726F6F74000000000000050000000000000008000000004A414300000000010000001C0000000000010001000000010
10001000101090000000105010001000000210000006000000000000000010000000000000024000000200000007E00000000000000010000000D392E3136342E3138372E313500000DC900400000000000000000001004010
8060667810201010100000000000000000000000000000000000000000000002000000004000000000000001F0000000400000003000000010000002000000000000000020000002000000004000000000000001F000000040
00003]
11:39:09,875 INFO [CorbaTransactionService] TransactionFactory: [IOR:000000000000003049444C3A6F72672F6A626F73732F746D2F69696F702F5472616E73616374696F6E466163746F72794578743A312E
000000000200000000000000E8000102000000000D392E3136342E3138372E313500000DC8000000144A426F73732F5472616E73616374696F6E732F46000000050000000000000008000000004A414300000000010000001C
000000000100010000000105010001000101090000000105010001000000210000006000000000000000010000000000000024000000200000007E00000000000000010000000D392E3136342E3138372E313500000DC90040
00000000000000001004010008060667810201010100000000000000000000000000000000000000000000002000000004000000000000001F0000000400000003000000010000002000000000000000020000002000000004
0000000000001F0000000400000003]
11:39:10,593 INFO [Embedded] Catalina naming disabled
11:39:10,687 INFO [ClusterRuleSetFactory] Unable to find a cluster rule set in the classpath. Will load the default rule set.
11:39:10,687 INFO [ClusterRuleSetFactory] Unable to find a cluster rule set in the classpath. Will load the default rule set.
11:39:11,078 INFO [Http11BaseProtocol] Initializing Coyote HTTP/1.1 on http-0.0.0.0-8080
11:39:11,078 INFO [Catalina] Initialization processed in 391 ms
11:39:11,078 INFO [StandardService] Starting service jboss.web
11:39:11,093 INFO [StandardEngine] Starting Servlet Engine: Apache Tomcat/5.5.20
11:39:11,125 INFO [StandardHost] XML validation disabled
11:39:11,140 INFO [Catalina] Server startup in 62 ms
11:39:11,265 INFO [TomcatDeployer] deploy, ctxPath=/invoker, warUrl=.../deploy/http-invoker.sar/invoker.war/
11:39:11,500 INFO [WebappLoader] Dual registration of jndi stream handler: factory already defined
11:39:12,484 INFO [TomcatDeployer] deploy, ctxPath=/, warUrl=.../deploy/jbossweb-tomcat55.sar/ROOT.war/
11:39:12,687 INFO [TomcatDeployer] deploy, ctxPath=/jbossws, warUrl=.../tmp/deploy/tmp255jbossws-context-exp.war/
11:39:13,046 INFO [TomcatDeployer] deploy, ctxPath=/jbossmq-httpil, warUrl=.../deploy/jms/jbossmq-httpil.sar/jbossmq-httpil.war/
11:39:14,656 INFO [TomcatDeployer] deploy, ctxPath=/web-console, warUrl=.../deploy/management/console-mgr.sar/web-console.war/
11:39:15,562 INFO [MailService] Mail Service bound to java:/Mail
11:39:15,750 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/jboss-ha-local-jdbc.rar
11:39:15,812 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/jboss-ha-xa-jdbc.rar
11:39:15,843 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/jboss-local-jdbc.rar
11:39:15,890 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/jboss-xa-jdbc.rar
11:39:16,000 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/jms/jms-ra.rar
11:39:16,031 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/mail-ra.rar
11:39:16,078 INFO [RARDeployment] Required license terms exist, view META-INF/ra.xml in .../deploy/quartz-ra.rar
11:39:16,093 INFO [QuartzResourceAdapter] start quartz!!!
11:39:16,156 INFO [SimpleThreadPool] Job execution threads will use class loader of thread: main
11:39:16,203 INFO [QuartzScheduler] Quartz Scheduler v.1.5.2 created.
11:39:16,218 INFO [RAMJobStore] RAMJobStore initialized.
11:39:16,218 INFO [StdSchedulerFactory] Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
11:39:16,218 INFO [StdSchedulerFactory] Quartz scheduler version: 1.5.2
11:39:16,218 INFO [QuartzScheduler] Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
11:39:16,937 INFO [WrapperDataSourceService] Bound ConnectionManager 'jboss.jca:service=DataSourceBinding,name=DefaultDS' to JNDI name 'java:DefaultDS'
11:39:17,281 INFO [A] Bound to JNDI name: queue/A
11:39:17,281 INFO [B] Bound to JNDI name: queue/B
11:39:17,281 INFO [C] Bound to JNDI name: queue/C
11:39:17,281 INFO [D] Bound to JNDI name: queue/D
11:39:17,281 INFO [ex] Bound to JNDI name: queue/ex
11:39:17,359 INFO [testTopic] Bound to JNDI name: topic/testTopic
11:39:17,359 INFO [securedTopic] Bound to JNDI name: topic/securedTopic
11:39:17,359 INFO [testDurableTopic] Bound to JNDI name: topic/testDurableTopic
11:39:17,390 INFO [testQueue] Bound to JNDI name: queue/testQueue
11:39:17,531 INFO [UILServerILService] JBossMQ UIL service available at : /0.0.0.0:8093
11:39:17,593 INFO [DLQ] Bound to JNDI name: queue/DLQ
11:39:17,718 INFO [ConnectionFactoryBindingService] Bound ConnectionManager 'jboss.jca:service=ConnectionFactoryBinding,name=JmsXA' to JNDI name 'java:JmsXA'
11:39:17,750 INFO [TomcatDeployer] deploy, ctxPath=/jmx-console, warUrl=.../deploy/jmx-console.war/
11:39:18,078 INFO [Http11BaseProtocol] Starting Coyote HTTP/1.1 on http-0.0.0.0-8080
11:39:18,218 INFO [ChannelSocket] JK: ajp13 listening on /0.0.0.0:8009
11:39:18,328 INFO [JkMain] Jk running ID=0 time=0/125 config=null
11:39:18,406 INFO [Server] JBoss (MX MicroKernel) [4.0.5.GA (build: CVSTag=Branch_4_0 date=200610162339)] Started in 26s:969ms
To również zadziałało! No, dobrze pomyślałem, czas sprawdzić uruchomienie przykładowej aplikacji Java EE 5.

W NetBeans IDE 5.5.1 Daily Build (z dnia 31 stycznia 2007) zdefiniowałem nową instancję serwera (zakładka Runtime). JBoss AS działał, więc NetBeans IDE od razu rozpoznał sytuację i pozwolił mi na przejrzenie zainstalowanych aplikacji. Nic nie było. Zabrałem się za stworzenie aplikacji przemysłowej (ang. Enterprise Application) - File->New Project...->Enterprise->Enterprise Application. Zdefiniowałem nazwę dla projektu simple (wierząc, że z projektami typu simple JBoss AS sobie poradzi ;-)) i wybrałem serwer JBoss AS, który właśnie zdefiniowałem. Pozostałe rzeczy pozostawiłem bez zmian. Na węźle simple-ejb wybrałem z menu kontekstowego New->Session Bean....
  package pl.jaceklaskowski.simple.beans;

import javax.ejb.Stateless;

@Stateless
public class NewSessionBean implements NewSessionLocal {

public String powitaj(String kogo) {
return "Witam " + kogo + "!";
}

}
Komponent sesyjny EJB3 już miałem, więc pora do warstwy prezentacji, czyli utworzenie servletu. Dlaczego servletu? Po pierwsze, ponieważ podlega wstrzeliwaniu zależności w Java EE 5, a po drugie jest do tego wizard w NetBeans IDE. Wybrałem menu New->Servlet... z menu kontekstowego na węźle simple-war.

Przypisałem servlet do adresu /powitaj i początkowo mój servlet wyglądał tak:
  package pl.jaceklaskowski.simple.servlet;

import java.io.*;
import javax.ejb.EJB;

import javax.servlet.*;
import javax.servlet.http.*;
import pl.jaceklaskowski.simple.beans.NewSessionLocal;

public class WywolajNewSessionBean extends HttpServlet {

@EJB
private NewSessionLocal newSessionLocal;

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet WywolajNewSessionBean</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>" + newSessionLocal.powitaj(request.getParameter("kogo")) + "</h1>");
out.println("</body>");
out.println("</html>");
out.close();
}

// usunięte, nieistotne dla wpisu, metody servletu
}
Po stworzeniu servletu, wcisnąłem klawisz F6 uruchamiający projekt główny, co w moim przypadku było właśnie projektem simple. Przełączyłem się na konsolę JBoss AS, gdzie pojawiły się wpisy zdarzeń:
12:07:24,750 INFO  [EARDeployer] Init J2EE application: file:/C:/apps/jboss-4.0.5.GA_ejb3/server/default/deploy/simple.ear
12:07:25,187 INFO [Ejb3Deployment] EJB3 deployment time took: 297
12:07:25,234 INFO [JmxKernelAbstraction] installing MBean: jboss.j2ee:ear=simple.ear,jar=simple-ejb.jar,name=NewSessionBean,service=EJB3 with dependencies:
12:07:25,500 INFO [EJBContainer] STARTED EJB: pl.jaceklaskowski.simple.beans.NewSessionBean ejbName: NewSessionBean
12:07:25,562 INFO [EJB3Deployer] Deployed: file:/C:/apps/jboss-4.0.5.GA_ejb3/server/default/tmp/deploy/tmp288simple.ear-contents/simple-ejb.jar
12:07:25,562 INFO [TomcatDeployer] deploy, ctxPath=/simple-war, warUrl=.../tmp/deploy/tmp288simple.ear-contents/simple-war-exp.war/
12:07:25,750 INFO [EARDeployer] Started J2EE application: file:/C:/apps/jboss-4.0.5.GA_ejb3/server/default/deploy/simple.ear
czyli wszystko w porządku. NetBeans uruchomił mi przeglądarkę z aplikacją, więc nadal było w porządku. Po wpisaniu adresu http://localhost:8080/simple-war/powitaj?kogo=Jacek okazało się jednak, że mój entuzjazm do bezawaryjnego zestawienia środowiska zmalał - pojawił się wyjątek! I to jaki - NullPointerException!

Analiza kodu wskazała na...brak wstrzeliwania zależności (DI) w JBoss AS. Przez moment nie mogłem w to uwierzyć. Jak to? Przecież Java EE 5 pozwala, aby servlet korzystał z DI. Może źle wyszukuje w JNDI? Trwało to jakąś chwilę, aż przypomniałem sobie o braku wsparcia dla DI w Tomcat 5, który był kontenerem servletów w JBoss AS.

Na pomoc pośpieszył mi NetBeans IDE z menu kontekstowym w otwartym edytorze z klasą servletu - Enterprise Resources->Call Enterprise Bean. W ten sposób NetBeans IDE dodał mi metodę lookupNewSessionBean, którą wykorzystałem w metodzie servletu:
  package pl.jaceklaskowski.simple.servlet;

import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.servlet.*;
import javax.servlet.http.*;
import pl.jaceklaskowski.simple.beans.NewSessionLocal;

public class WywolajNewSessionBean extends HttpServlet {

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet WywolajNewSessionBean</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>" + lookupNewSessionBean().powitaj(request.getParameter("kogo")) + "</h1>");
out.println("</body>");
out.println("</html>");
out.close();
}

private NewSessionLocal lookupNewSessionBean() {
try {
Context c = new InitialContext();
return (NewSessionLocal) c.lookup("java:comp/env/ejb/NewSessionBean");
} catch(NamingException ne) {
Logger.getLogger(getClass().getName()).log(Level.SEVERE,"exception caught" ,ne);
throw new RuntimeException(ne);
}
}

// usunięte, nieistotne dla wpisu, metody servletu

}
Ponownie wcisnąłem F6, wpisałem adres http://localhost:8080/simple-war/powitaj?kogo=Jacek i...kolejny raz wyjątek!

Tym razem już wiedziałem, że należy zadeklarować zależność w deskryptorze instalacji aplikacji internetowej (WEB-INF/web.xml), ale nie wiedziałem jaka musi być postać. Przypomniałem sobie o artykule na stronach NetBeans IDE o integracji z JBoss AS 4, który planowałem przeczytać - EJB 3.0 Enterprise Beans for the JBoss Application Server. Teraz była najwłaściwsza pora. Odszukałem sekcji o połączeniu servleta z komponentem EJB i poprawiłem metodę lookupNewSessionBean, aby tym razem wyszukiwała komponentu pod adresem simple/NewSessionBean/local. Ostatecznie kod servletu wyglądał tak:
  package pl.jaceklaskowski.simple.servlet;

import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.servlet.*;
import javax.servlet.http.*;
import pl.jaceklaskowski.simple.beans.NewSessionLocal;

public class WywolajNewSessionBean extends HttpServlet {

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet WywolajNewSessionBean</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>" + lookupNewSessionBean().powitaj(request.getParameter("kogo")) + "</h1>");
out.println("</body>");
out.println("</html>");
out.close();
}

private NewSessionLocal lookupNewSessionBean() {
try {
Context c = new InitialContext();
return (NewSessionLocal) c.lookup("simple/NewSessionBean/local");
} catch(NamingException ne) {
Logger.getLogger(getClass().getName()).log(Level.SEVERE,"exception caught" ,ne);
throw new RuntimeException(ne);
}
}

// usunięte, nieistotne dla wpisu, metody servletu
}
Ponownie F6, wpisanie adresu http://localhost:8080/simple-war/powitaj?kogo=Jacek i widzę pomyślnie uruchomioną aplikację!

Warto było! Dzięki jonsnow za komentarz!

08 lutego 2007

Java Persistence - 3.5 Encyjni obserwatorzy i metody przechwytujące

5 komentarzy
To nie było proste - znaleźć polski odpowiednik dla angielskiego listener. Słuchacz? Nasłuchiwacz? Nie bardzo. Ale obserwator? Dlaczego nie! Szczególnie, że mimo, że słuchacz (bliższy listener'owi) jedynie nasłuchuje, a obserwator może kojarzyć się jedynie z obserwowaniem lub oglądaniem, to i tak niesie dokładnie tą samą informację - reagowania na zdarzenia, a właśnie o to mi chodzi w tłumaczeniu. A może powinienem użyć słowa monitor encyjny? Dzisiaj postanowiłem zrelacjonować temat z użyciem słowa obserwator.

Dowolna metoda może przechwytywać zdarzenia związane ze stadiami rozwojowymi encji - metoda przechwytująca zdarzenia rozwojowe, w skrócie metoda przechwytująca (ang. lifecycle callback method).

Metoda przechwytująca może być zdefiniowana w klasie encji, mapowanej klasie bazowej (dla przypomnienia z poprzedniego wpisu z relacją lektury sekcji 2.1.9 o dziedziczeniu: mapowana klasa bazowa - klasa bazowa, która nie jest encją, choć dostarcza trwałego stanu i informacji o mapowaniu - jest bazą dla rozwoju innych bardziej zaawansowanych encji nie dostarczając kompletnej realizacji modelowanego bytu), lub klasa obserwatora (ang. entity listener class) związana z encją albo mapowaną klasą bazową. Klasa obserwatora encyjnego jest klasą, której metody są wywołane w odpowiedzi na zdarzenia rozwojowe encji (ang. entity lifecycle events). Dowolna liczba klas obserwatorów może być przypisana do encji bądź mapowanej klasy bazowej.

Domyślni obserwatorzy encji - obserwatorzy przypisani do wszystkich encji w jednostce utrwalania (ang. persistence unit) - są definiowani w deskryptorze XML.

Metody przechwytujące zdarzenia i klasy obserwatorów encyjnych są zdefiniowane za pomocą adnotacji lub deskryptora XML. Do przypisania klas obserwatorów encyjnych do klasy encji bądź mapowanej klasy bazowej służy adnotacja @EntityListeners. Kolejność wyzwalania obserwatorów wyznaczana jest przez kolejność ich deklaracji w adnotacji @EntityListeners. Deskryptor XML może służyć jako alternatywne miejsce do określania kolejności wyzwalania obserwatorów za pomocą adnotacji lub do zmiany kolejności wyznaczonej za pomocą adnotacji @EntityListeners.

Dowolny podzbiór lub kombinacja adnotacji może być przypisana do klasy encji, mapowanej klasy bazowej, czy klasy obserwatora. Pojedyńcza klasa nie może mieć więcej niż jednej metody przechwytującej dla stadium rozwojowego. Ta sama metoda może być zdefiniowana do przechwytywania wielu zdarzeń rozwojowych.

Dowolna ilość klas encji i mapowanych klas bazowych w hierarchi dziedziczenia może definiować klasy obserwatorów i/lub metody przechwytujące zdarzenia rozwojowe bezpośrednio (na klasie).

Klasa obserwatora encyjnego musi posiadać publiczny i bezparametrowy konstruktor.

Obserwator jest bezstanowy. Nie istnieje pojęcie cykli życiowych obserwatora.

Reguły funkcjonowania obserwatorów:
  • Metody obserwatora mogą rzucać niekontrolowane wyjątki (ang. unchecked/runtime exceptions), których wystąpienie w trakcie aktywnej transakcji, powoduje jej wycofanie.
  • Metody obserwatora mogą korzystać z usług środowiska - JNDI, JDBC, JMS oraz komponentów przemysłowych (ang. enterprise beans)
  • Metody obserwatora w przenośnej aplikacji, w ogólności, nie powinny wywoływać operacji EntityManager oraz Query, korzystać z innych instancji encji (czy to oznacza, że encje nie są traktowane jako komponenty przemysłowe w JPA?!) lub modyfikować relacje
Obserwatorzy encyjni wywołani w środowisku serwera aplikacyjnego współdzielą kontekst przestrzeni nazw JNDI związanej encji, a metody obserwatora są wywołane w kontekście transakcyjnym i bezpieczeństwa wywołującego komponentu w czasie, kiedy metoda została wywołana, np. jeśli zatwierdzenie transakcji nastąpi jako poprawnego wykonania metody biznesowej komponentu sesyjnego oznaczonej atrybutem transakcyjnym RequiresNew, metody obserwatora PostPersist oraz PostRemove są wykonywane w kontekście nazw, transakcyjnym i bezpieczeństwa tego komponentu sesyjnego.

3.5.1 Metody przechwytujące

Metody przechwytujące mogą być zdefiniowane na klasie obserwatora encyjnego i/lub bezpośrednio na klasie encji bądź mapowanej klasy bazowej.

Metody przechwytujące są oznaczone adnotacjami wskazującymi przechwytywane zdarzenia lub są zdefiniowane w deskryptorze XML.

Adnotacje używane do oznaczania metod przechwytujących na klasie encji bądź mapowanej klasie bazowej i na metodach obserwatora są takie same. Sygnatury pojedyńczych metod różnią się jednak (dla przypomnienia: podobnie było z metodami przechwytującymi, wtedy zwanymi metodami zwrotnymi, dla komponentów przemysłowych). Metody przechwytujące zdefiniowane w klasie encji bądź mapowanej klasy bazowej mają następującą sygnaturę:

void <DOWOLNA_NAZWA_METODY>()

, a zdefiniowane poza hierarchią dziedziczenia encji, tj. w dedykowanej klasie obserwatora:

void <DOWOLNA_NAZWA_METODY>(Object)

Parametr wejściowy typu Object jest instancją encji, dla której metoda będzie wywołana. Typ może być zadeklarowany jako właściwy typowi encji.

Metody przechwytujące mogą być public, private, protected lub domyślne, ale nie mogą być static czy final (chyba po to, aby umożliwić ich przysłanianie przez podklasy generowane przez dostawcę JPA).

Następujące adnotacje są dostępne do określenia metod przechwytujących odpowiednich typów:
  • @PrePersist
  • @PostPersist
  • @PreRemove
  • @PostRemove
  • @PreUpdate
  • @PostUpdate
  • @PostLoad
3.5.2 Działanie encyjnych metod przechwytujących

Metody udekorowane @PrePersist i @PreRemove są wywoływane zanim nastąpi wywołanie metod persist i remove dla danej encji, odpowiednio. Instancja encji, dla których wywołano merge, która z kolei spowoduje utworzenie nowej instancji zarządzanej encji wyzwoli metodę udekorowaną @PrePersist dla tej encji, po tym jak stan encji przyłączanej zostanie przekopiowany. Metody @PrePersist i @PreRemove będą kaskadowo wyzwolone na wszystkich powiązanych relacyjnie encjach. Metody @PrePersist oraz @PreRemove zostaną uruchomione podczas wykonania persist, merge i remove.

Metody @PostPersist oraz @PostRemove są wywołane dla encji właśnie utrwalonej bądź usuniętej bezpośrednio w bazie danych (co może nastąpić w momencie wywołania metod persist czy remove, po wywołaniu flush lub ostatecznie podczas zatwierdzania transakcji). Metody przechwytujące będą wywołane kaskadowo dla wszystkich powiązanych relacyjnie encji. Wartości generowanych kluczy głównych są dostępne w metodzie @PostPersist.

Metody @PreUpdate oraz @PostUpdate są wywołane przed i po wykonaniu operacji update bezpośrednio w bazie danych (co może nastąpić w momencie modyfikacji stanu instancji encji, po wywołaniu flush lub ostatecznie podczas zatwierdzania transakcji).
Specyfikacja nie gwarantuje wykonania @PreUpdate i @PostUpdate, kiedy encja jest utrwalona, a następnie zmodyfikowana w jednej transakcji lub kiedy encja jest zmodyfikowana, a następnie usunięta w trakcie jednej transakcji.

Metoda @PostLoad jest wywołana po załadowaniu stanu encji z bazy danych do aktualnego kontekstu utrwalania lub po wykonaniu refresh. Metoda @PostLoad jest wywołana zanim wynik zapytania jest zwrócony lub wykorzystany lub zanim nastąpi nawigacja (przejście) po relacji.

Specyfikacja nie gwarantuje kolejności wykonania metod przechwytujących na instancji encji przed lub po kaskadowym wykonaniu metod na jej relacyjnie powiązanych encjach.

Sekcja 3.5.3 przedstawia ciekawy przykład zaawansowanej encji Account wraz z obserwatorem AlertMonitor. Pierwszy raz spotykam się z tak zaawansowaną klasą encji. Zazwyczaj były to klasy z atrybutami (POJO) i adnotacjami mapującymi. Tym razem specyfikacja prezentuje klasę z obserwatorem z metodą @PostPersist, która przesyła informację o właśnie założonym koncie do systemu monitorującego oraz metodami przechwytującymi @PrePersist (sprawdzenie kwoty wpłaty przed otwarciem konta) i @PostLoad (wyliczającą nietrwały atrybut wskazujący na typ konta) w samej klasie encji.

3.5.4 Wiele metod przechwytujących dla pojedyńczego zdarzenia rozwojowego

Jeśli zdefiniowano wiele metod przechwytujących dla pojedyńczego zdarzenia rozwojowego, kolejność wykonania metod jest następująca:
  • Domyślni obserwatorzy, jeśli istnieją, są wykonani najpierw, w porządku wyznaczonym przez deskryptor XML. Domyślni obserwatorzy związane są ze wszystkimi encjami w jednostce utrwalania chyba, że wyłączono je przez adnotację @ExcludeDefaultListeners lub element exclude-default-listeners w deskryptrze XML.
  • Metody przechwytujące obserwatora zdefinowane dla klasy encji bądź mapowanej klasy bazowej są wywołane w kolejności definicji ich klas w adnotacji @EntityListeners.
  • Jeśli kilka klas encji bądź mapowanych klas bazowych w hierarchii dziedziczenia encji definiuje obserwatorów, obserwatorzy zdefinowani w klasach bazowych są wywołani zanim wywołani zostaną obserwatorzy klas potomnych w kolejności dziedziczenia, aż do samej klasy encji. Adnotacja @ExcludeSuperclassListeners lub element exclude-superclass-listeners może być wykorzystana w klasie encji bądź mapowanej klasy bazowej do wyłączenia wykonania obserwatorów klas bazowych dla encji bądź mapowanej klasy bazowej. Wyłączenie obserwatorów dotyczy klasy, w której znajduje się adnotacja @ExcludeSuperclassListeners (lub odpowiedni wpis w deskryptorze XML) i jej klas potomnych (wyłączeni obserwatorzy mogą być ponownie włączeni/uaktywnieni za pomocą ich deklaracji przez adnotację @EntityListeners bądź entity-listeners). Adnotacja @ExcludeSuperclassListeners (lub exclude-superclass-listeners) nie wyłącza domyślnych obserwatorów (tj. tych zdefiniowanych w deskryptorze XML).
  • Jeśli metoda przechwytująca dla pewnego zdarzenia rozwojowego jest zdefiniowana na klasie encji i/lub klasach bazowych (czy to klas bazowych encyjnych - będącymi również encjami, czy mapowanych klas bazowych), metody przechwytujące na klasie encji i/lub mapowanych klasach bazowych są wywołane po wywołaniu metod przechwytujących dla wcześniejszych klas bazowych (pod względem hierarchii dziedziczenia), tj. metody przechwytujące dla klas wyżej w hierarchii (bliżej typowi Object a nie klasie encji) są wywoływane wcześniej. Klasa ma prawo przesłonić odziedziczoną metodę przechwytującą o tym samym rodzaju przechwytywanego zdarzenia, co sprawi, że przesłonięta metoda nie będzie wywołana. Jednakże, jeśli metoda przesłania odziedziczoną metodę przechwytującą, ale definiuje inne zdarzenie do przechwycenia lub jeśli nie jest metodą przechwytującą, metoda przesłonięta będzie wywołana (ponieważ jest metodą przechwytującą zdarzenia innego rodzaju bądź w drugim przypadku w ogóle jest metodą przesłoniętą podczas, gdy przesłaniająca nie).
  • Tylko poprawne zakończenie wykonania metody przechwytującej spowoduje wykonanie kolejnych metod przechwytujących.
  • Deskryptor XML może służyć do zmiany kolejności wykonywania metod przechwytujących określonym przez adnotacje.
Sekcja 3.5.5 przedstawia przykład, który demonstruje kolejność wykonania metod przechwytujących encji i jej mapowanej klasie bazowej. Próba opisu przykładu spowoduje wyłącznie jego zaciemnienie. Warto zajrzeć do specyfikacji dla zapoznania się z nim.

3.5.6 Wyjątki

Metody przechwytujące mogą zakończyć się niekontrolowanymi wyjątkami. Niekontrolowany wyjątek powoduje wycofanie aktywnej transakcji, w której wykonywana jest metoda przechwytująca. Kolejne metody przechwytujące nie zostaną wywołane po wystąpieniu niekontrolowanego wyjątku.

3.5.7 Deklaracja obserwatorów i metod przechwytujących w deskryptorze XML

Deskryptor XML może być alternatywnym miejscem definiowania klas obserwujących i metod przechwytujących oraz kolejności ich wykonania (nadpisując konfigurację poprzez adnotacje).

Deklaracja metod przechwytujących

Element entity-listener w deskryptorze XML służy do deklaracji metod przechwytujących. Rodzaj zdarzenia definiowany jest przez elementy pre-persist, post-persist, pre-remove, post-remove, pre-update, post-update i post-load.

Co najwyżej jedna metoda obserwatora może być metodą przechwytującą dany rodzaj zdarzenia, bez względu, czy deklaracja następuje poprzez deskryptor XML, adnotacje, czy ich kombinację.

Deklaracja przypisania metod przechwytujących do encji

Podelement entity-listeners elementu persistence-unit-defaults definiuje domyślnych obserwatorów dla danej jednostki utrwalania.

Podelement entity-listeners elementów entity lub mapped-superclass definiuje obserwatorów dla encji lub mapowanej klasie bazowej, odpowiednio (wraz z ich klasami pochodnymi).

Przypisanie obserwatorów do klas encji jest addytywne (sumuje się). Obserwator przypisany do klasy bazowej encji lub mapowanej klasy bazowej jest również przypisany do nich.

Element exclude-superclass-listeners określa, że metody przechwytujące dla klas bazowych nie będą uruchomione dla klasy encji lub mapowanej klasy bazowej i podklas.

Element exclude-default-listeners określa, że domyślni obserwatorzy nie będą uruchomieni dla klasy encji lub mapowanej klasy bazowej i podklas.

Dosłowne wypisanie wyłączonych obserwatorów domyślnych lub klas bazowych dla danej encji lub mapowanej klasy bazowej powoduje, że wymienieni obserwatorzy będą wyłączeni dla tej encji lub mapowanej klasy bazowej i podklas.

Ostateczna kolejność wykonania metod przechwytujących dla pojedyńczego zdarzenia rozwojowego wyznaczana jest zgodnie z w/w regułami (opisanymi wyżej jako 3.5.4 Wiele metod przechwytujących dla pojedyńczego zdarzenia rozwojowego).

To była na prawdę interesująca sekcja! Przykłady były niebanalne i spotkałem się z tymi konstrukcjami po raz pierwszy. Możliwość przechwytywania zdarzeń była możliwa również w komponentach przemysłowych (wtedy nazywałem je biznesowymi). W poprzednich wersjach specyfikacji Java EE (1.4 i wcześniejszych) mechanizm przechwytywania był jedynie dostępny po wdrożeniu rozwiązań AOP (programowanie aspektowe, ang. aspect-oriented programming). Teraz nie trzeba się nimi zajmować (przynajmniej na początku), a jedynie postępować zgodnie z wytycznymi opisanymi w specyfikacji. Znaczne uproszczenie i większa przenośność aplikacji.

Kolejny rozdział to publiczny interfejs klasy Query - 3.6 Query API.

Java Persistence - 3.4 Optymistyczne blokowanie i współbieżność

1 komentarzy
Rozdział 3.4 Optymistyczne blokowanie i współbieżność rozpoczyna się dywagacjami architektonicznymi obsługi wielodostępności do danych w bazach danych. Specyfikacja JPA zakłada użycie optymistycznego blokowania (ang. optimistic locking), tj. konfiguracji bazy danych, z którymi jednostki utrwalania (ang. persistence units) są związane, o poziomie izolacji transakcji read committed (lub analogicznej - ciekawe wyjaśnienia różnych poziomów izolacji można znaleźć w dokumnetacji wybranej bazy danych, ale mnie przypadł do gustu materiał Filipa Sielimowicza Poziomy izolacji transakcji) oraz że zapisy do bazy danych zazwyczaj występują jedynie podczas wywołania metody flush (wprost przez aplikację, bądź zgodnie z ustawieniem trybu zapisu kontekstu utrwalania - synchronizacji kontekstu, cf. FlushModeType). Jeśli transakcja jest aktywna, dostawca JPA ma prawo zapisu zmian encji natychmiast, jednakże ten sposób konfiguracji nie jest w zakresie specyfikacji (domyślnie zapis zmian następuje podczas zatwierdzenia transakcji, nawet korzystając z przedłużonego kontekstu utrwalania, który potrafi przekraczać granice poszczególnych transakcji). Konfiguracja pesymistycznego blokowania (ang. pessimistic locking) może wymagać podniesienia izolacji danych na poziomie konfiguracji bazy danych i również nie jest tematem specyfikacji.

Optymistyczne blokowanie

Optymistyczne blokowanie jest techniką zapewniającą, że modyfikacje w bazie danych odpowiadające stanowi encji są wykonane jedynie, kiedy żadna inna transakcja nie zmodyfikowała danych w międzyczasie, tj. od ostatniego odczytania stanu encji nie nastąpiła modyfikacja jego reprezentacji w bazie danych. Technika optymistycznego blokowania zapewnia, że modyfikacja (w szczególności skasowanie) danych jest spójna ze stanem bazy danych i że zatwierdzone modyfikacje innych transakcji nie są stracone. Transakcja powodująca modyfikację danych nieaktualnych powoduje wystąpienie wyjątku OptimisticLockException, a w rezultacie swoje wycofanie. Przenośne aplikacje, które chcą skorzystać z optymistycznego blokowania dla encji, muszą określić wersjonowany atrybut encji, tj. skorzystać z adnotacji @Version lub skorzystać z odpowiedniej konfiguracji w deskryptorze XML. Zaleca się, aby aplikacje uaktywniły optymistyczne blokowanie (poprzez wersjonowane atrybuty) dla wszystkich encji, które będą używane współbieżnie lub, których stan będzie uwspólniany ze stanu odłączonego (metoda merge). Brak wykorzystania wersjonowanych atrybutów w encjach może prowadzić do niepoprawnego działania aplikacji (niespójny stan encji, nadpisywanie/utrata zmian, etc.) i jednocześnie przenosi odpowiedzialność za zarządzanie spójnością danych bezpośrednio na aplikację.

Wersjonowane atrybuty

Pole lub właściwość (dalej zwane atrybutami) encji udekorowane adnotacją @Version służy dostawcy JPA do wykonywania optymistycznego blokowania. Dostawca korzysta z wersjonowanego atrybutu w trakcie wykonywania operacji wpływających na cykl rozwojowy encji. Wprowadzenie wersjonowanego atrybutu w encji powoduje uaktywnienie obsługi optymistycznego blokowania dla encji. Ustawianie i modyfikacja wartości wersjonowanego atrybutu leży wyłącznie w gestii dostawcy JPA (istnieje jednak odstępstwo od tego wymagania opisane w rozdziale 4.10), jednakże możliwy jest odczyt jego wartości bądź upublicznienie (za pomocą metody odczytującej - getter).

Wersjonowany atrybut jest modyfikowany przez dostawcę JPA podczas każdorazowego zapisu do bazy danych. Wszystkie atrybuty (tj. pola i właściwości) encji nie będące stroną w jakiejkolwiek relacji i wszystkie relacje, której stroną inicjującą jest ta encja, są włączone w mechanizm kontroli wersji (w zasadzie powinienem napisać, że w mechanizm optymistycznego blokowania).

Implementacja operacji włączania encji do kontekstu utrwalania (metoda merge) jest zobowiązana do sprawdzenia wartości wersjonowanego atrybutu i zakończyć się wyjątkiem OptimisticLockException, jeśli wersja dołączanej encji jest nieaktualna, tj. kiedy encja została zmodyfikowana od czasu jej odłączenia (wyjątek może zostać rzucony dopiero podczas operacji flush lub podczas zatwierdzania transakcji, którykolwiek nastąpi pierwszy).

Dostawca JPA korzysta z wersjonowanych atrybutów podczas kontroli optymistycznego blokowania. Możliwe są inne mechanizmy obsługi optymistycznego blokowania, jednakże nie są one wymagane przez specyfikację.

Wyłącznie encje wersjonowane są kontrolowane pod względem optymistycznego blokowania. Spójność grafu zależności encji nie jest gwarantowany (ze względu na technikę optymistycznego blokowania) w przypadku korzystania z encji wersjonowanych i niewersjonowanych, jednakże nie wpływa to na wykonanie operacji (chyba, że wystąpi błąd weryfikacji wersjonowanych atrybutów encji).

Przeglądając dokumentację Javadoc dla adnotacji @Version doszukałem się jeszcze wymagania, że encja może posiadać wyłącznie jednen atrybut wersjonowany (innymi słowy: wyłącznie pojedyńcze pole/właściwość może zostać oznaczone jako wersjonowane). Korzystanie z wielu atrybutów wersjonowanych może powodować nieprzenośność encji. Dodatkowo, atrybut wersjonowany powinien być mapowany do podstawowej tabeli encji, gdyż w przeciwnym przypadku może spowodować nieprzenośność encji.

Wspierane typy atrybutów wersjonowanych to: int, Integer, short, Short, long, Long, Timestamp.

Tryby blokowania

Poza optymistycznym blokowaniem, do zarządzania spójnością danych encji, możliwe jest skorzystanie z metody lock instancji EntityManager.

Wyróżniamy dwa tryby blokad (wartości typu wyliczeniowego LockModeType):
  • READ - blokowanie na odczyt
  • WRITE - blokowanie na zapis
Jeśli transakcja T1 wywołuje lock z blokadą READ na instancji encji wersjonowanej (użycie adnotacji @Version), zarządca encji (EntityManager) musi zapewnić, że nie wystąpią następujące sytuacje:
  • P1 (odczyt niezatwierdzonych danych, ang. dirty read) - transakcja T1 modyfikuje wiersz. Inna transakcja T2 odczytuje dane wiersza wraz z modyfikacjami zanim T1 zostanie zatwierdzona lub wycofana. Transakcja T2 ostatecznie zostanie zatwierdzona (bez względu na wynik działania T1 i momentu zatwierdzenia/wycofania w stosunku do T2).
  • P2 (niepowtarzalny odczyt, ang. non-repeatable read) - transakcja T1 odczytuje wiersz. Inna transakcja T2 modyfikuje lub kasuje wiersza, zanim T1 zostanie zatwierdzona. Obie transakcje zostają zatwierdzone.
Jest to najczęściej zaimplementowane za pomocą nałożenia blokady na wiersz w bazie danych. Możliwe jest nałożenie blokady natychmiast (zakładając, że będzie utrzymywany do czasu zatwierdzenia transakcji) lub z opóźnieniem, do momentu zatwierdzania transakcji (wtedy musi być utrzymywany do czasu zakończenia zatwierdzenia transakcji). Dowolna implementacja jest akceptowalna przez specyfikację.

Dostawca JPA nie jest zobowiązany dostarczać obsługę blokady READ na niewersjonowanych encjach. Brak wsparcia musi zakończyć się wyjątkiem PersistenceException. Wsparcie dla READ musi zawsze zapobiegać wystąpieniu w/w sytuacji (P1 oraz P2). Poleganie na możliwości zakładania blokad READ na niewersjonowanych encjach powoduje nieprzenośność aplikacji.

Jeśli transakcja T1 wywołuje lock z blokadą WRITE na instancji encji wersjonowanej, zarządca encji musi również zapobiec wystąpieniu w/w sytuacji (P1 oraz P2) i obowiązkowo uaktualnić (zmodyfikować) atrybut wersjonowany. Modyfikacja wersji może nastąpić natychmiast, lub z opóźnieniem, w momencie wywołania flush bądź zatwierdzania transakcji. Jeśli encja zostanie skasowana zanim nastąpi uaktualnienie wersji, uaktualnienie zostanie zignorowane (skoro nie ma odpowiadającego jemu wiersza w bazie danych).

Dostawca JPA nie jest zobowiązany dostarczać obsługę blokady WRITE na niewersjonowanych encjach. Brak wsparcia musi zakończyć się wyjątkiem PersistenceException. Wsparcie dla WRITE musi zawsze zapobiegać wystąpieniu w/w sytuacji. Poleganie na możliwości zakładania blokad WRITE na niewersjonowanych encjach powoduje nieprzenośność aplikacji.

Specyfikacja zezwala, aby dla wersjonowanych encji, obsługa blokady READ była realizowana za pomocą mechanizmu WRITE, ale nie na odwrót.

Jeśli wersjonowana encja jest w jakikolwiek sposób zmodyfikowana bądź skasowana, dostawca JPA musi zapewnić, że wymagania związane z blokadą WRITE są spełnione, nawet bez bezpośredniego wywołania metody lock.

Dla zapewnienia przenośności aplikacji, zaleca się wyłącznie korzystanie z metody lock w celu zapewnienia poprawności powtarzanych odczytów dla encji, które nie została zmodyfikowane lub skasowane i nie poleganiu na specyficznych dla dostawcy JPA rozszerzeniach. Jednakże, jeśli dostawca JPA nałożył już pesymistyczne blokady na wybrane wiersze, wywołanie lock z blokadą READ na instancjach encji reprezentujących te wiersze może zostać zignorowane.

OptimisticLockException

Dostawca JPA może opóźnić zapis do bazy danych do momentu zakończenia transakcji, jeśli jest to zgodnie z ustawieniami trybu flush. W takiej sytuacji wymogi optymistycznego blokowania mogą być sprawdzone dopiero podczas zatwierdzania transakcji i spowodować wystąpienie wyjątku OptimisticLockException w pierwszej fazie zatwierdzania transakcji (ang. "before completion"). Aplikacja obsługująca wystąpienie wyjątku OptimisticLockException, powinna najpierw wywołać metodę flush (aby wymusić próbę zapisania modyfikacji do bazy danych) i przy wystąpieniu wyjatku, przechwycić go wykonując czynności porządkujące stan wersjonowanych encji, co ostatecznie zapobiegnie wystąpieniu tego wyjątku podczas zatwierdzaniu transakcji.

Zaleca się, aby dostawca JPA zawarł w wyjątku OptimisticLockException właściwy wyjątek, który spowodował jego wystąpienie. Nie jest to jednak gwarantowane.

W sytuacjach, kiedy wyjątek OptimisticLockException jest opakowany przez inny wyjątek, np. RemoteException, kiedy przekazywany jest do zdalnego klienta, encje, z których korzystają zagnieżdżone wyjątki powinny być Serializable, aby zapis stanu obiektów do strumienia (ang. marshalling) nie zakończył się błędem (implementowanie interfejsu Serializable przez dowolną klasę encyjną można nazwać dobrą praktyką w JPA).

Wyjątek OptimisticLockException zawsze wycofuje transakcję.

Pod koniec podrozdziału 3.4 w sekcji 3.4.4. pojawia się opis potencjalnej sytuacji, w której może wystąpić wyjątek OptimisticLockException. Jednakże nie mam najmniejszego pojęcia, o co autorom w tym końcowym zdaniu chodziło. Poszukuję chętnych wytłumaczenia mi tego wycinka - koniec sekcji 3.4.4 strona 57 (oczywiście najlepszy byłby przykład, który zobrazowałby sytuację):

Refreshing objects or reloading objects in a new transaction context and then retrying the transaction is a potential response to an OptimisticLockException.

Następna sekcja to 3.5 Entity Listeners and Callback Methods.

07 lutego 2007

Java Persistence - 3.3 Żywotność kontekstu utrwalania

0 komentarzy
Udało mi się znaleźć kolejne dobre (lepsze?) tłumaczenie dla słowa lifecycle, czyli po polsku istnienie. Na pierwszy rzut oka nie wydaje się być trafne, ale w niektórych sformułowaniach bardzo dobrze się komponuje i wydaje się być dobrą alternatywą dla cyklu życia. Zresztą w relacji z lektury rozdziału 3.3 Żywotność kontekstu utrwalania skorzystałem z tego skrzętnie.

Żywotność kontekstu utrwalania zarządzanego przez kontener/serwer aplikacyjny (ang. container-managed persistence context) może być ograniczona do transakcji (ang. transaction-scoped persistence context) lub trwać znacznie dłużej (ang. extended persistence context).

Typ wyliczeniowy - javax.persistence.PersistenceContextType - służy do określenia długości życia kontekstu utrwalania zarządzanego przez kontener. Długość życia kontekstu określana jest w momencie utworzenia instancji EntityManager (wprost poprzez konstruktor, poprzez wstrzelenie zależności czy wyszukanie w drzewie JNDI).

Typ wyliczeniowy PersistenceContextType dostarcza dwóch wartości określających rodzaj kontekstu utrwalania:
  • EXTENDED - określa, że żywotność kontekstu jest przedłużona, tj. trwająca dłużej niż pojedyńcza transakcja
  • TRANSACTION - (domyślna) określa, że żywotność kontekstu związana jest z pojedyńczą transakcją
Użycie kontekstu utrwalania zarządzanego przez kontener w trybie przedłużonej żywotności powoduje, że jego istnienie rozpoczyna się w momencie utworzenia instancji EntityManager i kończy podczas jego zamknięcia (wynik operacji close). Tak zdefiniowany kontekst może być związany z wieloma transakcyjnymi i nietransakcyjnymi operacjami instancji EntityManager. Przedłużony kontekst przyłącza się do aktywnej transakcji, kiedy metody EntityManager'a bądź stanowego komponentu sesyjnego (SFSB), z którym kontekst jest związany, są wywołane w jej zasięgu (to podpowiada możliwe zastosowanie przedłużonego kontekstu, gdzie wykonanie metody transakcyjnej nie powinno zatwierdzać modyfikacji do bazy danych przy zakończeniu metody, a tym samym i możliwym zakończeniu transakcji, np. stanowy komponent reprezentujący koszyk).

EntityManager z przedłużonym kontekstem utrwalania utrzymuje referencje instancji encji po zatwierdzeniu transakcji. Instancje encji są nadal zarządzane i mogą podlegać modyfikacją nawet pomiędzy transakcjami. W takim trybie pracy kontekstu encje nie są przeładowywane (odświeżane) przy każdorazowym rozpoczęciu transakcji. Bez względu na istnienie transakcji, nawigacja po polach/właściwościach relacyjnych (korzystanie z encji zależnych, będących w relacji) powoduje powołanie encji zarządzanych (tak jakby transakcja była wciąż aktywna mimo, że nie musi).

Użycie EntityManager z przedłużonym kontekstem utrwalania zarządzanym przez kontener zdejmuje konieczność istnienia aktywnej transakcji podczas wywoływania operacji persist, remove, merge i refresh. Wynik ich działania będzie zapisany w bazie danych w momencie zatwierdzenia transakcji, do której przyłączył się przedłużony kontekst utrwalania.

Żywotność kontekstu utrwalania zarządzanego przez aplikację (lub inaczej związanego z EntityManager'em, który zarządzany jest przez aplikację - ang. application-managed entity manager) jest przedłużona. Po stronie aplikacji leży odpowiedzialność za zarządzanie istnieniem kontekstu utrwalania.

Więcej informacji o przedłużonym kontekście utrwalania znajduje się w sekcji 5.7 (oj, to wieki miną zanim się za niego zabiorę! Autorzy specyfikacji wydaje się, że zdawali sobie z tego sprawę przybliżając temat przedłużonego kontekstu już teraz).

Zatwierdzanie transakcji

Zatwierdzenie transakcji zmienia stan encji zarządzanych w kontekście utrwalania ograniczonym do transakcji na odłączony, a w przedłużonym pozostają zarządzane.

Wycofanie transakcji

Bez względu na rodzaj kontekstu utrwalania, wycofanie transakcji powoduje, że wszystkie encje posiadające trwały stan (tj. posiadają swój odpowiednik w bazie danych) zanim rozpoczęła się wycofywana transakcja oraz encje skasowane staną się odłączone. Stan instancji encji będzie stanem instancji w momencie wycofania transakcji. Zazwyczaj wycofanie transakcji powoduje, że kontekst utrwalania będzie w nieokreślonym stanie (stan atrybutów wersjonujących i stan tworzony automatycznie - generowane klucze główne) mogą być niespójne. Encje, które były poprzednio zarządzane (włączając encje nowe i utrwalone w wycofywanej transakcji) mogą być bezużyteczne (w porównaniu z innymi odłączonymi encjami) i operacja merge na nich może zakończyć się błędem (specyfikacja nie określa stanu nowych encji, jeszcze nie utrwalonych w bazie, a po wycofaniu transakcji - czy są one nadal nowe czy już odłączone).

Krótko, zwięźle i na temat, ale myliłby się ten, kto uważa, że wszystko już zostało na temat przedłużonych kontekstów utrwalania powiedziane. Więcej w sekcji 5.7. Zmierzam ku sekcji 3.4 Optimistic Locking and Concurrency.

06 lutego 2007

IV spotkanie Warszawa JUG za nami - a było wyjątkowo ciekawie!

2 komentarzy
Spotkanie było wyjątkowe - z kilku powodów. Po primo, w końcu udało się przejść do fazy dojrzewania w cyklu życiowym Warszawa JUG i Sebastian Pietrowski podjął się wyzwania i poprowadził prezentację o Ruby on Rails. Jest to pierwsza osoba, która zechciała wesprzeć mnie w poprowadzeniu spotkania i zdjąć ze mnie aureolę prowadzącego. Było lżej, a jeśli dobrze odczytuję wrażenia Seby, to i on się dobrze bawił. Nie ukrywam, że jego spokój i opanowanie w tłumaczeniu konstrukcji Rubiego bardzo pozytywnie wpłynęły na gorące głowy zapaleńców Javowych ;-) Seba zaprosił kilku kolegów - praktyków Ruby (ot, tak dla wsparcia, gdyby się coś wywiązało) - i wywiązała się...ciekawa dyskusja - pojawiło się wiele pytań (i nie tylko dlatego, że udało mi się pytających nagradzać plecakami Javapolis 2006, co to, to nie!). Było na prawdę ciekawie. I po raz pierwszy wystąpiłem w roli prowadzącego spotkanie, a nie prezentację i...podobało mi się. Trochę popatrzyłem, trochę pogadałem, zero stresu, całkowity luz. A tak jeszcze trzeba dłuuugimi wieczorami się przygotowywać. Niektórzy już wiedzą, o czym piszę (prawda Seba? ;-)).

Spotkanie kolejny raz (trzecie z rzędu) przyciągnęło około 50 osób (!) Tym razem miałem sposobnośc policzyć. I byłem bardzo mile zaskoczony, bo na nasze techniczne spotkania zaczęły przychodzić panie. Nie jedna, czy dwie, ale było bodajże ze 4-5. To już 10%. Kolejne osiągnięcie. Zastanawiam się, czy to osoba Seby, Ruby, czy idea Warszawa JUG były tak magnesujące?!

Pora rozejrzeć się za większą salą. Czuje się ruch w inicjatywie i sądzę, że sala jest jedyną przeszkodą, dla której nie jesteśmy już grupą 100-osobową. Uff, 100 osób na spotkaniu, to już musi być nie lada impreza. Jeśli połączymy siły z grupą Ruby, która prężnie działa na Chłodnej, a może Chmielnej (na pewno na ulicy na Ch) to będzie ciekawie. Oni poruszają tematykę bardziej biznesową (tworzenie firm 2-3-osobowych), a my raczej przemy ku głębokim wodom technologicznym. Jak tak dalej pójdzie - wizja konferencji będzie bardziej realna niż dokończenie specyfikacji JPA przez gwiazdką.

Nie mógłbym nie wspomnieć o ekipie z JBoss Inc. W końcu się pojawili! ;-) Prezentacji jeszcze nie było, ale obiecali wesprzeć podczas mojej prezentacji JBoss Seam za 2 tygodnie. Ekipa 3 osobowa + ja = 4 osoby zachwalające Seama. Powinno się udać zaprezentować coś interesującego (a mówi się o znacznie większej liczbie ciekawostek niż 4). Coś mi się jednak zdaje, że należy załatwić salę na ponad 50 osób. Już wielu o nią pytało (o salę i prezentację również), więc trzeba się solidnie przygotować.

A, i na zakończenie, udało mi się zakończyć spotkanie rozmową z p. Jackiem Sroką, który jest doktorantem na MiMUW. Przez całe spotkanie było kilku aktywnych uczestników i dało się zauważyć prym Jacka w tej grupie. Zdecydowanie wpłynął na dynamikę spotkania biorąc aktywny udział w dyskusjach. Okazało się, że istnieje możliwość połączenia sił i skorzystania z dobrodziejst gorących głów studentów MiMUW i prezentacji ich tematów na naszych spotkaniach. Jak najbardziej ciekawa propozycja podniesienia roli naszych spotkań. Skoro ich tematyka prac zaliczeniowych nie odbiega od naszych zainteresowań, dlaczego nie połączyć wysiłków dla dobra wspólnego. Kolejne osiągnięcie.

Po spotkaniu zgłosił się Michał M. (nazwisko znane redakcji), który wyraził chęć poprowadzenia prezentacji o Google Web Toolkit (GWT). Jak tak dalej pójdzie nie będę miał możliwości prezentacji swoich dokonań (a na tapecie są JPA, Apache Geronimo 2, Apache OpenEJB 3, JSF 1.2, itp.)

Następne spotkanie 20 lutego o JBoss Seam. Tym razem moja kolej, więc najwyższa pora zabrać się poważnie za robotę. Do zobaczenia na V spotkaniu Warszawa JUG!