Założenia konferencji to m.in:

• udział wielu prelegentów światowej sławy
• prezentacje w języku angielskim
• czas trwania to 2 dni po 2 sesje
• niski koszt uczestnictwa
• lokalizacja zmienna w kolejnych edycjach

Co w programie? Tematyką konferencji mają być języki dynamicznie typowane (m.in. Groovy, Ruby) oraz wymiana doświadczeń w zakresie nowoczesnych metodyk tworzenia oprogramowania oraz projektowania architektury złożonych rozproszonych systemów informatycznych. Dla każdego coś dobrego!

Konferencja potrwa dwa dni, więc będzie sporo okazji do spotkań oraz wymiamy zdań ze specjalistami, wśród nich Guillaume Laforge, Charles Nutter, Scott Davis i wielu innych. Oczywiście nie zabraknie także stałych bywalców: Jacka Laskowskiego oraz Waldemara Kota. Wszystko wskazuje zatem na to, że to wydarzenie przejdzie do pamięci wszystkich sympatyków języka Java a także wpisze się w rozkład jazdy javowych konferencji zwłaszcza, że organizatorzy planują organizować ją co roku w innych miastach a nawet krajach.

Póki co dokładna cena uczestnictwa na konferencji nie jest znana gdyż zależy od ilości zgłoszeń, ale jest szacowana na zbliżoną do 80 €.

Więcej aktualnych informacji można znaleźć na stronie konferencji: GeeCON 2009.

Jak wiadomo, w przypadku nowych technologii zawsze najtrudniejszy jest ten ‘pierwszy krok’:

• jak skonfigurować środowisko?
• jak stworzyć szkielet projektu?
• jak to wszystko spiąć żeby dobrze działało?

Na wszystkie powyższe pytania i problemy jest jednak prosta i szybka odpowiedź: Exadel Flamingo.

Na problemy – Flamingo

Flamingo to zestaw bibliotek i komend służących jako pomoc w wygenerowaniu i konfiguracji szkieletu aplikacji typu RIA. Obsługa generatora Flamingo jest bardzo prosta. Polega na odpowiedzi na kilka pytań zadawanych w formie wizarda – na ich podstawie jest generowany odpowiedni projekt. Flamingo bazuje na Mavenie i każdy wygenerowany projekt jest w tej konwencji. Dzięki temu bardzo prosto można odnaleźć się w projekcie – oczywiście dla ludzi znających tą konwencję, ale chyba w dzisiejszych czasach znajomość Mavena jest raczej powszechna ;-)

Wygenerowany kod szkieletu posiada pełne wsparcie i jest skonfigurowany do pracy pomiędzy Flexem lub JavąFX a JBoss Seamem lub Springiem. Każdy znajdzie więc coś dla siebie, gdyż Seam to raczej podstawowa sprawa jeżeli chodzi o aplikacje EJB3, a Spring – to już klasyka. Wybór jest więc zatem ograniczony do najbardziej popularnych aktualnie technologii i oznacza, że w ogromnej większości przypadków takiego ograniczenia nie trzeba sztucznie obchodzić.

Wygenerowany szkielet jest naprawdę kompletny, Flamingo zajmuje się tutaj wszystkim:

• generuje odpowiednie klasy (klasę) odpowiedzialne za (bardzo prosty) model danych
• generuje warstwy aplikacji, włączając w to serwisy oraz DAO oraz konfiguruje całą komunikację, począwszy od interfejsu użytkownika a kończąc na bazie danych
• generuje strukturę aplikacji webowej, z wszystkimi wymaganymi plikami
• generuje podstronę logowania, przez co mechanizm autoryzacji jest już gotowy do rozszerzenia
• generuje szkielet do testów oraz podstawowy test

Jak to działa?

Odpalmy zatem Flamingo – robimy to poprzez uruchomienie konsoli i wpisaniu ‘flamingo create project’ (binaria flamingo muszą być dostępne). Famingo zacznie ściągać wszystkie biblioteki, o ile ich już nie posiadamy w naszym lokalnym repozytorium Mavenowym i następnie uruchamia konsolowego wizarda. Nie będę opisywał kolejnych pytań, bo są raczej oczywiste – zamieszczę tylko zrzut z mojej konsoli:

Please choose the type of application to generate (flamingo-seam, flamingo-spring):[flamingo-spring]
flamingo-spring
Please enter the location in which your new application will be created (i.e. c:/java/development):
S:/_Projects/Java/J2EE
Enter the project name (e.g. myproject):
Flex
Please enter the root package name for your project (e.g. com.mydomain.myproject): [pl.j2ee.flamingo]
pl.j2ee.flex
Will this project have Flex or JavaFX user interface? (flex, javafx): [flex]
flex
Will this project use Hessian or AMF protocol? (amf, hessian): [amf]
amf
What kind of database are you using? (hsql, mysql, oracle, postgres, mssql, db2, sybase, none): [hsql]
hsql
Enter the JDBC URL for your database (e.g. jdbc:hsqldb:.): [jdbc:hsqldb:flex]
jdbc:hsqldb:flex
Enter database username: [sa]
sa
Enter database password: []

Do you want to update the database schema each time you deploy? (y, n): [y]
y
Enter the entity class name (Flex source files to view and modify entities will be generated as well):
Department
-------------------------------------------------------------------------------------
    G e n e r a t i n g   A n d r o M D A   P o w e r e d   A p p l i c a t i o n
-------------------------------------------------------------------------------------
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flamingoproject.properties'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flex/pom.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flex/src/main/flex/pl/j2ee/flex/view/DepartmentManager.mxml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flex/src/main/flex/pl/j2ee/flex/vo/Department.as'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flex/src/main/flex/main.mxml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/flex/src/main/resources/services-config.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/pom.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/readme.txt'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/pom.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/Department.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/DepartmentDAO.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/DepartmentDAOImpl.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/service/DepartmentService.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/service/ILoginService.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/java/pl/j2ee/flex/service/LoginService.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/resources/applicationContext-test.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/resources/applicationContext.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/resources/hibernate.cfg.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/webapp/index.html'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/main/webapp/WEB-INF/web.xml'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/test/java/pl/j2ee/flex/dao/DepartmentDAOTest.java'
    Output: 'file:/S:/_Projects/Java/J2EE/Flex/web/src/test/java/pl/j2ee/flex/DataSourceTestCase.java'
-------------------------------------------------------------------------------------
    New application generated to --> 'file:/S:/_Projects/Java/J2EE/Flex/'
-------------------------------------------------------------------------------------
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1 minute 24 seconds
[INFO] Finished at: Fri Nov 28 14:36:08 CET 2008
[INFO] Final Memory: 10M/20M
[INFO] --------------------------------------------------------------

No, i tyle :-) Proste, prawda?

Wygenerowany kod

Przechodzimy teraz do folderu gdzie wygenerował się nasz szkielet. Po wejściu do niego możemy zbudować cały projekt – poprzez ‘mvn clean install’. Po chwili – naszym oczom ukazuje się jakże pożądany komunikat: „Build Successful” (na konsoli widać także przeprowadzony test zapisu naszej klasy modelowej – także mechanizm testowania działa poprawnie). Świetnie, mamy coś co działa i się buduje, ale co tak naprawdę wygenerowaliśmy? Spróbujmy zatem zdeplyować naszą aplikację. Po wrzuceniu wara do Tomcata niestety okazuje się, że nie ma róży bez ognia – konsola krzyczy że nie mamy wymaganej biblioteki do HSQL. Przechodzimy zatem do odpowiedniego pliku POM (w web) i po jego otworzeniu – widzimy co jest nie tak. Usuwamy zbędną linijkę ‘<scope>test</scope>’ dla dependency HSQLDB, zapisujemy zmiany i ponownie budujemy projekt (‘mvn clean install’). Ponownie wrzucamy wara do tomcata i już – aplikacja wstała poprawnie!

Nie pozostaje nic innego jak teraz przejść do przeglądarki i zobaczyć nasze dzieło. Po uruchomieniu odpowiedniego adresu naszym oczom ukazuje się piękna strona we flashu, która żąda od nas danych do zalogowania. Dane te nie są istotne, to i tak jest stub – metoda do autoryzacji zawsze zwraca ‘true’ ;-) Po poprawnym zalogowaniu przechodzimy do jedynej dostępnej strony – listy obiektów domenowych (w moim przypadku ‘Department’). Mamy tutaj możliwość przeglądania wszystkich wpisów oraz funkcjonalności dodania nowego, edycji oraz usunięcia istniejącego. Sama lista oferuje jeszcze możliwość sortowania wyników. Ostatnią funkcjonalnością jest jeszcze oferowana przez guzik ‘Logout’ opcja wylogowania się z systemu. I to by było na tyle!

To działa!

Jak widać z powyższego tekstu – wystarczy ściągnąć Flamingo, rozpakować, odpalić wizarda i mamy już gotowy szkielet aplikacji RIA. Należy przy tym podkreślić, że w całym procesie od momentu pomysłu o szkielecie aplikacji flexowej do jej uruchomienia ani razu nie potrzebowalismy uruchomić żadnego IDE. Niesamowite! Co więcej, wygenerowany szkielet ten jest kompletny i tak naprawdę jest już w pełni działającą aplikacją o minimalnej funkcjonalności, przedstawiającą funkcjonalności bardziej na zasadzie ‘how to’. Wystarczy zaimplementować poprawne logowanie oraz rozszerzyć model dziedziny – i mamy w bardzo przystępny sposób pokazaną drogę w świat RIA.

Java postanowiła nie pozostawać w tyle, i stąd pomysł technologii JavaFX, która nie dość, że w znakomity sposób ułatwia tworzenie aplikacji z kontrolkami Swinga, to jeszcze daje możliwość perfekcyjnego łączenia Swinga z elementami graficznymi z technologii Java2D oraz – docelowo – Java3D.

Pierwszy kontakt z JavąFX miałem jeszcze w kwietniu, kiedy to miałem za zadanie rozpoznać tą technologię z zamiarem potencjalnego wykorzystania w mocno opartej na GUI aplikacji. Wtedy była ona jeszcze w fazie rozwoju – zaawansowanej, ale jednak rozwoju. Oczywiście, tak jak człowiek uczy się przez całe życie, tak technologie nigdy nie przestają się rozwijać, jednak w tym przypadku oznaczało to typową wersję beta, gdzie nie wszystko jeszcze działało, nie wszystko było udokumentowane, a niektóre operacje miały nieprzewidziane skutki.  Ale już wtedy, muszę przyznać, JavaFX nieźle rokowała. Działała bardzo dobrze, wyglądała świetnie i była łatwa w obsłudze.

Co to jest?

JavaFX jest technologią do tworzenia bogatych wizualnie aplikacji internetowych (RIA – Rich Internet Application), przeznaczona nie tylko pod wiele systemów operacyjnych, ale też – docelowo – na wszystkie urządzenia z ekranem („bring Java to all the screens of your life” brzmi hasło reklamowe). W tej chwili już jest dostępna wersja JavyFX na komputery (JavaFX Desktop), w 2009 roku ma być udostępniona wersja na urządzenia mobilne (JavaFX Mobile) a w 2010 planowane jest wdrożenie platformy TV (JavaFX TV).

Aplikacje te pisane są w języku JavaFX Script - podobnym składniowo do JavaScripta, w pełni zorientowanym obiektowo (obiekty opisywane w formacie JSON). Język daje możliwości powiązania (binding) właściwości różnych obiektów między sobą albo z wartościami zmiennych oraz zawiera mnóstwo efektów graficznych, statycznych oraz ruchomych (animowanych). Wszystko to pozwala na tworzenie zaawansowanych i bardzo efektownych interfejsów graficznych dla aplikacji – ten prosty programik prezentuje jednocześnie efekty graficzne (przezroczystość), jak i animację obiektów – oraz pozwala na utworzenie prostych aplikacji – takich, które nie kryją za sobą na tyle skomplikowanej warstwy biznesowej, żeby trzeba do tego było angażować cały model MVC, jak np. ten prosty analizator amerykańskiego rynku akcji.

Ale na szczęście JavaFX ma także zastosowanie tylko jako warstwa wizualna – kod w JavaFX Scripcie może zostać dołączony jako część projektu, napisanego w Javie, służąca tylko do jego wizualizacji, a pod spodem mogą znajdować się dowolnie skomplikowane funkcjonalności.

Dystrybucja

Na stronie www.javafx.com można pobrać specjalną wersję NetBeansa 6.1, która jest dostosowana do pisania w niej aplikacji JavaFX (oczywiście, posiadacze „zwykłego” NetBeansa 6.1 mogą bez problemu sobie JavaFX SDK doinstalować, w menu Tools -> Plugins, zakładka Available Plugins). SDK dostarcza kilku użytecznych narzędzi, ułatwiających poruszanie się po języku JavaFX Script, takich, jak biblioteka obiektów i właściwości albo podręczny podgląd projektowanej aplikacji.

Podobny podgląd dostępny jest także w webowej (tzn. dostępnej przez Java Web Start) aplikacji JavaFXPad – w dolnej części okna mamy edytor kodu, gdzie możemy wkleić dowolny kod JavaFX Scripta, w górnej – podgląd aplikacji w czasie rzeczywistym.

Możliwości

Na stronach projektu znajduje się kilka przykładów aplikacji, prezentujących możliwości technologii, np. symulacja dymu albo losowe generowanie fraktali. Ale większą bibliotekę przykładów można znaleźć na stronach Wiki projektu – zawarte tam są przykłady kodu do konkretnych zastosowań (np. połączenie z bazą danych czy wyświetlenie aplikacji na pełnym ekranie albo zawarcie jej na stronie WWW), oraz bardzo ciekawe dema – z tych ostatnich na szczególną uwagę zasługuje SVG Translator – program ten przerabia obraz w formacie SVG (Scalable Vector Graphics – wolny i otwarty uniwersalny format opisu dwuwymiarowej grafiki wektorowej) na – uwaga – kod w JavaFX Scripcie, który, uruchomiony, wygeneruje dokładnie taki sam obraz.

JavaFX w materiałach promocyjnych na stronie głównej obiecuje bardzo wiele, ale powyższe przykłady pokazują, że w owe obietnice można wierzyć – gdy już pojawi się finalna wersja JavaFX 1.0, będzie to wydarzenie, które śmiało będzie mogło być nazwane początkiem nowej ery.

Przykład

W ramach mojego rozpoznawania JavaFX naskrobałem taki prosty program, który prezentuje jednocześnie kilka istotnych cech tej technologii:

• Bezszwowe (seamless) połączenie elementów graficznych i kontrolek Swingowych
• Powiązanie (binding) między właściwościami obiektów (wartość na suwaku z kątem odchylenia strzałki)
• Animacja – spróbujcie kliknąć przyciski „Zero” i „Random”
• Wreszcie i całe pole aplikacji można przesuwać w dowolne miejsce ekranu (czego akurat nie można przetestować w JavaFXPadzie, tylko po skompilowaniu programu np. w NetBeansie)

import javafx.ui.*;
import javafx.ui.canvas.*;
import javafx.ui.filter.*;
import java.lang.Math;

class Wind {
  attribute angle:Number;
  attribute sAngle:Number;
  attribute tAngle:Number;
  public operation setAngle(nAngle:Number);
  public operation zero();
  public operation random();
}

operation Wind.setAngle(nAngle) {
  tAngle = nAngle;
  sAngle = angle;
  angle = [sAngle..tAngle] dur Math.abs(tAngle-sAngle)*2 linear;
}

operation Wind.zero() {
  setAngle(0);
}

operation Wind.random() {
  setAngle((Math.random()*360).intValue());
}

class Windsign extends CompositeNode {
  attribute wind:Wind;
}

function Windsign.composeNode() =
  Group {
    var x = 50
    var y = 50transform: bind translate(x, y),
    onMouseDragged: operation(e) {
      x += e.localDragTranslation.x;
      y += e.localDragTranslation.y;
    }
    toolTipText: "You can totally drag me around!",
    content: [
      Circle {
        cursor: HAND,
        cx: 50,
        cy: 50,
        radius: 50,
        fill: cyan,
        stroke: blue,
        strokeWidth: 2,
      },
      Polygon {
        points: [50,0,
          55,98,
          50,95,
          45,98]
        fill: darkblue
        transform: bind rotate(wind.angle,50,50)
      }
    ]
  };
  Frame{
    var wind = Wind {}
    var ws = Windsign { wind:wind }
    title:"Windsign"
    background: white
    visible:true
    content:
      BorderPanel {
        top: FlowPanel {
          background: white,
          content: [
            Slider {
              min: 0,
              max: 360,
              minorTickSpacing: 15,
              majorTickSpacing: 45,
              paintTicks: true,
              value: bind wind.angle,
            },
            Button {
              text: "Zero",
              action: operation() {
                wind.zero();
              }
            },
            Button {
              text: "Random",
              action: operation() {
                wind.random();
              }
            }
          ]
        }
        center: Canvas {
          background: white
          content:ws
        }
      }
    }

Kod zamieszczony powyżej można przekleić do okna edycji w programie JavaFXPad.

Źródła

• http://www.javafx.com/ – bogata graficznie (utworzona w tej technologii) strona domowa projektu
• http://java.sun.com/developer/technicalArticles/javafx/ – zbiór artykułów i tuto riali do JavyFX
• http://java.sun.com/javafx/reference/ – dokumentacja, pliki do pobierania i przykłady
• http://jfx.wikia.com/wiki/Planet_JFX_Wiki – strona Wiki projektu JavaFX