1. HK2 – 101, developing a module from scratch, step by step tutorial

    Hej alla pojkar och flickor. Innan har det bloggats här om The Hundred Kilobytes Kernel (HK2). För de som har missat HK2 och vad det är så ser jag till att citera en liten förklaring innan jag går vidare:

    ”The java.net project ”Hundred Kilobytes Kernel” (HK2) is a module subsystem coupled with a simple yet powerful component model to build software. It is a great technology to use in any Java software development and can be used in small devices such as phones up to enterprise applications. HK2 is designed to be friendly to existing technologies such as OSGi but it will also provide a path to the implementation of modules (JSR 277) in Java SE 7. HK2 is used as the foundation for GlassFish V3.”

    Now to the action. Jag ska skapa en modul helt från scratch. Du måste ha maven2 för detta. OBS! denna tutorial är väldigt mycket ”for dummies” så du kan säkert hoppa över vissa saker :) .
    down to biz.

    1. I din ”shell”, skriv ”mkdir temp” och sedan ”cd temp”

    2. därefter skriver du ”mvn archetype:create \ -DarchetypeGroupId=org.apache.maven.archetypes \ -DgroupId=com.mycompany.app \ -DartifactId=temp”

    sedan trycker du självklart på din ”return” knapp (dvs ”enter”) och sen väntar den korta tiden som det tar för maven att generera upp ett projekt åt dig.

    3. skriv gedit/notepad/vi för att editera din pom.xml och använd sunt förnuft för att få den att se ut ungefär så här:

    http://www.helloworlds.net/temp/temp/pom.xml

    4. Skapa därefter filerna

    Animal.java = > http://www.helloworlds.net/temp/temp/src/main/java/com/mycompany/app/Animal.java

    Pig.java = > http://www.helloworlds.net/temp/temp/src/main/java/com/mycompany/app/Pig.java

    Start.java = > http://www.helloworlds.net/temp/temp/src/main/java/com/mycompany/app/Start.java

    5. Gå tillbaks till projektets ”rootkatalog” och skriv ”mvn hk2:hk2-compile” följt av ”mvn hk2:run”

    Det kan se ut så här:

    bash-3.00$ mvn hk2:run
    [INFO] Scanning for projects…
    [INFO] Searching repository for plugin with prefix: ‘hk2′.
    [INFO] —————————————————————————-
    [INFO] Building temp
    [INFO] task-segment: [hk2:run]
    [INFO] —————————————————————————-
    [INFO] [hk2:run]
    2007-jul-26 07:27:56 com.sun.enterprise.module.maven.MavenProjectRepository loadModuleDefs
    INFO: Loading modules list from /export/home/ferid/temp/temp/pom.xml
    ModuleStartup phase
    Oink, oink
    [INFO] ————————————————————————
    [INFO] BUILD SUCCESSFUL
    [INFO] ————————————————————————
    [INFO] Total time: 2 seconds
    [INFO] Finished at: Thu Jul 26 07:27:56 CEST 2007
    2007-jul-26 07:27:56 com.sun.enterprise.module.ModuleClassLoader stop
    INFO: ModuleClassLoader stopped com.mycompany.app:temp
    2007-jul-26 07:27:56 com.sun.enterprise.module.ModuleClassLoader finalize
    INFO: ModuleClassLoader gc’ed com.mycompany.app:temp
    2007-jul-26 07:27:56 com.sun.enterprise.module.ModuleClassLoader stop
    INFO: ModuleClassLoader stopped com.mycompany.app:temp
    [INFO] Final Memory: 3M/8M
    [INFO] ————————————————————————
    bash-3.00$

    Nu har vi precis använt oss av samma teknik som Glassfish V3 använder sig av, för att göra en HelloWorld applikation. Rätt coolt tycker jag!

    Vill ni veta mer om hur allt fungerar och hänger ihop, är ni välkomna till nästa JavaForum eller JavaZone där vi i år kör en presentation om HK2.

    tjena!

  2. Ant – XML = GANT = Groovy + Ant

    Vid det har laget har nog dom flesta tröttnat på att skriva sina antscript i XML… Med hjälp av GANT så kan man göra sina script i groovy istället! GANT använder (exekeverar) ANT i sin tur men man skriver alltså sina build.xml filerer som groovy script istället.

    Så här kan det se ut:

    
includeTargets << gant.targets.Clean
cleanPattern << [ '**/*~' ,  '**/*.bak' ]
cleanDirectory << 'build'

target ( 'default' : 'The default target.' ) {
  println ( 'Default' )
  depends ( clean )
  Ant.echo ( message : 'A default message from Ant.' )
  otherStuff ( )
}

target ( otherStuff : 'Other stuff' ) {
  println ( 'OtherStuff' )
  Ant.echo ( message : 'Another message from Ant.' )
  clean ( )
}

  3. Java FX och Bidirectional bindings

    Chris Oliver (mannen bakom Java FX) skrev nyligen på sin blog om ett tillägg till Java FX som han gjort, nämligen bidirectional binding. Nu är Java FX script redan imponerande som det är, men med denna nya funktion så blir det smått magiskt. Resultatet är som om du skulle ha tillgång till pekare likande det du har i C, men din pekare har också logik inbyggd i sig. Följande exempel är saxat från Chris blogginlägg:

    // logical negation
var a = true;
var b = bind not a;
assert b == false;
b = true;
assert a == false; // passes

// arithmetic
var x = 10;
var y = bind -x + 100;
assert y == 90;
y = 40;
assert x == 60; // passes

// sequence elements
var seq = [1, 2, 3];
var elem1 = bind seq[1];
elem1 = 500;
assert seq == [1, 500, 3]; // passes
delete seq[1];
assert elem1 == 3; // passes
insert 0 as first into seq;
assert elem1 == 1; // passes
var value = bind elem1;
value = 999;
assert seq == [0, 999, 3]; // passes

    Smått magiskt ändå. Du behöver alltså inte jobba med listener, callbacks, observer-observable eller liknande patterns för att få en återkoppling mellan din GUI-kod och dataobjekt.

    Nu tror jag inte detta är avgörande för huruvida Java FX kommer bli en hit eller inte, det finns trots allt liknande funktioner i andra scriptspråk. Men jag tror ändå att när folk väl börjar använda Java FX så kommer vi se rätt avancerade GUIn skrivna med väldigt lite kod tack vare detta.

    Chris Olivers blog hittar ni på http://blogs.sun.com/chrisoliver/.

  4. JBoss Seam

    Spring Framework i all ära, men JBoss är ändå den mest använda open-source applikationsservern idag. Vi som använt JBoss sen en tid tillbaka vet också att de tagit fram ett eget ramverk för webb-applikationer, nämligen JBoss Seam. Seam är inte en specialvariant av applikationsservern, utan ett komplett applikationsramverk som på ett väldigt smidigt sätt ”syr” ihop de senaste webb-standarderna , såsom AJAX och JSF, med tekniker såsom EJB 3, Portlets och BPM. Seam har också en implementation av JSR-299 (Web Beans), som syftar till att göra det möjligt att använda dina Enterprise JavaBeans som managed beans i JSF (detta är något som man missade i EJB3 specen).

    Den stora fördelen med JBoss Seam är ändå att man använder hela konceptet med POJOs och annoterar sin kod på alla nivåer, från persistence till användargränssnitt. Då allt bygger på existerande JavaEE standarder (eller blivande sådana) så är det också ett väldigt tryggt ramverk att bygga på då man troligen relativt enkelt kan byta platform och server. Det blir också enklare att öfra in i en stor organisation, där beslutsfattarna gärna ser att man använder lösningar som har en stor leverantör bakom sig, för att minska risken att man inte kommer kunna få support i framtiden. Så kort sagt, om du inte kan eller vill använda Spring Framework (smaken är som baken) så är kanske JBoss Seam något för dig?

    Så, vad är det som är så bra med Seam då? Förutom att den förenar JSF med EJB 3 på ett väldigt trevligt vis (Annotations) så är det minimalt med XML du behöver hantera (ok, det är väl visserligen en smaksak då). Den gör det också möjligt att använda Exceptions tillsammans med JSF, och på så vis kunna göra felhanteringen mycket enklare. Man har även passat på att ta med de senaste JSF-lösningarna, så AJAX finns tillgängligt ”out-of-the-box”. Kort sagt så är Seam väldigt trevligt ramverk för att bygga webbapplikationer utan att behöva röra sig utanför Java EE standarden. Den minimala mängden konfiguration som krävs utanför koden gör det också väldigt enkelt att komma igång med. Eftersom allt är POJOs så kan du också använda JUnit för att testa det utan att behöva dra igång en fullständig JavaEE-container.

    För er som är nyfikna på att testa det hela eller läsa lite mer så kan ni ta en titt på http://www.jboss.com/products/seam.