Java EE 7 Websocket API

Jahas, tuli testailtua hieman upouutta Websocket API:a joka on osa Java EE 7 julkaisua ja jo siis käytössä ja pelaa. Ytimeltään yksinkertainen kapistus; lisä-annotaatioilla voi tehdä serveripulikan joka voi puskea yhdelle tai useammalle asiakkaalle päivityksiä Websocket standardin mukaan. Päädyin yksinkertaiseen testikoodiin:

 

@ServerEndpoint("/chat")
public class ChatSocket {
  @OnMessage
  public String onMessage(String message) {
      try {
        Thread.sleep(5000);  // Wait 5sec to simulate asynch operations
      } catch (InterruptedException ex) {
          ex.printStackTrace();
      }
      return "BACK AT YA:" + message;
  }

}

Client päässä jotain tällaista:

var wsUri = "ws://" + document.location.host + "/WebSocketTest/" + "chat";
var ws = new WebSocket(wsUri);
ws.onmessage = function (evt) { var received_msg = evt.data; alert("Message is received..." + received_msg); };
ws.send("Message to send");

 

Testaillessa menikin sitten hetki ihmetellessä miksei toimi. Onneksi tajusin vaihtaa selainta. Jostain kumman syystä oman koneen Chrome eteni openiin asti, mutta send jäi juntturaan. Firefox pelitti hienosti. Tämä havainto pitää yhtä pessimistisen näkemykseni kanssa siitä miten tulevat web ’standardit’ tulevat toimimaan eri selaimissa ja mobiililaitteissa. Tosin tämäkin varmaan fiksattavissa ja voi olla palvelinpuolenkin oireilua, mutta pääpointti on se että triviaali demo toimii yhdessä, ei toisessa. Hieman hienosäätöä siis vaaditaan vielä.

 

Mutta hauskaa, helppoa tekniikkaa. Tällä voi rakennella chattikanavia, osakekurssi push päivityksiä, tai mitä eventtejä nyt haluaa seuratakaan, erilaisia jaettuja brainstorming whiteboardeja, dashboardeja, sävellysvimpaimia, etc.

 

 

Java EE 7 on valmis

Jep, speksi Java Enterprise Edition versiolle 7, toisella nimellä JSR-342 tuli uunista ulos ja vielä hyvissä ajoin ennen tämän vuoden JavaOne seminaaria. Sovelluspalvelimista esim. JBOSS (Wildfly 😉 ja Glassfish tukevat jo suurinta osaa piirteistä, ja arvatenkin aika rivakasti kaikkia. IBM Websphere pakkaa tulemaan mukaan parin vuoden päästä eli isoilla firmoilla on hetki aikaa hengähtää ja tarkastella tulevaa. Mitä alusta sitten merkitsee kehittäjälle tai arkkitehdille?

IMG_3013

No tästähän piti tulla se suuri pilvipalveluiden standardi, mutta toisin kävi. Maku tässä editiossa on vähän kuin aikanaan EE 6. Kun katselin sitä ensi kertoja tuntui että kyseessä on vain pikkupäivityksiä ja bugifiksauksia. Mutta pienet nerokkaat parannukset ynnäävät aika nopeasti. Myönnettäköön että EE 6 sai aikaan kauhean sotkun CDI:n kanssa mutta monta muuta asiaa meni siellä hyvin ja tuo CDI kuviokin tulee korjautumaan, tässä versiossa jo vähän matkaa. Eli Java EE 7 on enimmäkseen pieniä päivityksiä. Muutama päivitys meni major versioon:

JMS 2.0 on erittäin maukasta tavaraa sanomapalveluiden kanssa paljon pyöriville. Parannuksia, yksinkertaistusta jota todella on kaivattu.

JAX-RS 2.0 tarjoaa RESTful palveluita tekevälle ennen muuta viimeinkin standardoidun ja toimivan asiakaspään rajapinnan, tätä on myöskin kaivattu kovasti. Kylkiäisenä standardirajapinnat Web Socket ja JSON teknologioille, jotka ovat niinikään nykyaikaa.

Aivan uutuutena on myös Batch API, ja Concurrency Utilities API. Eräajoja ja rinnakkaisuutta järeissä servereissä standardien mukaisesti. Need I say more.. 😉

Mutta todelliset makupalat löytyvät vakaiden paljon käytössä olevien teknologioiden päivityksistä. Itse odotan innolla etenkin JSF 2.2 versiota, jonka tulevista ominaisuuksista olenkin jo bloggaillut. Parempaa HTML 5 tukea, page flow malli Springistä lainattuna, helpompia custom komponentteja, ja tietysti EL 3.0 jossa mm. tuki Lambdoille. Hyvä huomata että EE 6 määritteli JSF 2.0 version osaksi, eli EE 7 hyppää 2.1 yli suoraan 2.2 versioon, kaikenlaista maukasta siis tulossa.

Pienempiä päivityksiä ovat EJB 3.2, Servlet 3.1, JPA 2.1, CDI 1.1, Bean Validation 1.1, sekä JASPIC 1.1. Hyvin toimivia osia on vaikeaa enää parantaa ja sen huomaa versionumeroiden lähes huomaamattomista nytkähdyksistä. Asynkronisia kutsuja ja seuraavan version pilvistandardin alkuvalmistelua luvassa. CDI:n korjauksena on lähinnä valmistautua 1) poistamaan päällekkäisyydet 2) laajentamaan mahdollisuuksia ja 3) avaamaan sen käyttö kaikkialle Javaan. CDI on nykyisellään vielä sotku mutta siinä on kasvupotentiaalia, ja väittäisin että 3 vuotta tästä eteenpäin se on Java EE standardin kaikkein tärkein osa. (Nauretaan sitten yhdessä tällekin ennustukselle vuonna 2016).

Ja tietysti, nyt pistettiin valinnaisiksi jo aiemmin pruning listalla olleet muinaisteknologiat kuten Entity Beanit ja JAX-RPC. Tarkoittaa että sovelluspalvelimet todennäköisesti lakaisevat näihin liittyvät tukiosat vähin äänin pois, IBM maailmaa lukuunottamatta. Harmin paikka että viime metreillä standardi cache-välimuistiratkaisuille sai kirvestä, saamme jäädä odottelemaan vielä sitä. Odotellessa kannattaa käyttää ei-standardeja cache ratkaisuja, niillä saa suorituskykyä.

Eli tässä pikapäivitys. Olen menossa JavaOne seminaariin kuuntelemaan miten näitä tosiasiassa hyödynnetään, joten lisää mehukkuutta luvassa. Ja nämä tietysti päivittyvät pikkuhiljaa kaikkiin asianmukaisiin koulutuksiimme. Kiirettä en silti uskoisi olevan, tämä päivitys on aikaa rauhassa valutella paikalleen ja tuo kaikenlaista mukavaa mutta harvalle mitään kriittisen välttämätöntä juuri nyt. Se kuitenkin ankkuroi taas vahvemmin standardipaletin paikkaa yritysarkkitehtuureissa. Näillä saa aikaan tulosta, taas entistä enemmän entistä vähemmällä vaivalla.

Saa nähdä miten käy Java SE 8 version Lambdoineen kaikkineen. Ehtiikö syksyksi? Toivon mukaan, mutta Lambdoista ei tällä kertaa tingitä, eli julkaistaan jahka valmis niiden osalta. Ja onhan JodaTime myös kiva kirjasto 😉

Linkkejä:

Tieturin Java-kurssit (erityisesti suosittelen 5pv Java EE ohjelmointikoulutusta)

Java EE 7 standardi

JSF 2.2 Faces Flow ja HTML5 friendly layout

Odotellessa tulevaa Java EE 7 sekä Java SE 8 standardia olen seuraillut yksittäisten spesifikaatioiden kehitystä. Yksi mielenkiintoinen päivitys on Java EE 7:n tuleva JavaServer Faces 2.2 versio. Se on näennäisesti taas minor update, eli ei arkkitehtuurin uusintaa kuten aikanaan 2.0 päivitys – mutta pienet päivitykset kasaantuvat aika mielenkiintoisesti.

Mitäpä on odotettavissa JSF 2.2 versiossa? Yksi kiintoisa piirre on Wicket-frameworkin tapainen mahdollisuus käyttää HTML5 pohjaa ja id attribuutteja aiemman tag-mallin sijasta. Tässä esimerkki uudesta JSF 2.2 leiskasta tähän tapaan tehtynä:

< !DOCTYPE html>
< html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:jsf="http://java.sun.com/jsf" xmlns:f="http://java.sun.com/jsf/core">
    < head jsf:id="head">
        < title>Putting it all together < /title>
        < script jsf:target="body" jsf:name="js.js"/>
        < link jsf:name="css.css" rel="stylesheet" type="text/css" />
    < /head>
    < body jsf:id="body">
        < form jsf:id="form" jsf:prependId="false">
            < label jsf:for="name">Name < /label>
            < input jsf:id="name" type="text" jsf:value="#{complex.name}">
                < f:ajax execute="@this" render="progress"/>
            < /input>
            < label jsf:for="tel">Tel < /label>
            < input jsf:id="tel" type="tel" jsf:value="#{complex.tel}">
                < f:ajax execute="@this" render="progress"/>
            < /input>

            < label jsf:for="email">Email < /label>
            < input jsf:id="email" type="email" jsf:value="#{complex.email}">
                < f:ajax execute="@this" render="progress"/>
            < /input>

            < label for="progress">Progress < /label>
            < progress jsf:id="progress" max="3">#{complex.progress} of 3 < /progress>

        < /form>
    < /body>
< /html>

Kiintoisaa? Miksei, onhan se. Toinen itseä kiinnostava tutkaan osunut piirre on JSF Faces Flow. Idea on itselle tuttu Spring Web Flow moduulin puolelta – sensijaan että navigointisäännöt naputellaan sivuihin, määritellään sivuilla liikkuminen ja eri vaihtoehdot erilliseen tiedostoon. Tässä ei ole kuitenkaan kyseessä vain navigointi, vaan page flow voi myös sisältää logiikkaa, virhekäsittelyä, jne. Faces Flow on valittu ns ’Big Ticket Feature’:ksi, eli on merkittävä osa JSF alustaa ja sen ympärille rakentuu paljonkin pientä.

Yksi osa on uusi Scope annotaatio, @FlowScoped, joka määrittää luokan elinkaareksi senhetkisen Flown (kääntäisikö tuon virtaukseksi? Aika kömpelö käännös). Tarkoittaa että scope voi olla yli yhden requestin mutta vähemmän kuin session verran. Tätä voisi vertailla hieman @FlashScoped-laajuuteen, mutta viimekädessä elinkaaren määrittää siis määritelty flow, ei se montako kutsua serverille tehdään.

@FlowScoped ottaa flow id parametrin joka määrittää mihin flow-virtaukseen se kuuluu.

Esimerkki @FlowScoped beanistä:

@Named
@FlowScoped(id = "someFlowName")
public class SomBean {
    public String someReturn() {
        return "/somePage.xhtml";
    }
}

Käytössä on oletuksia mitkä helpottavat elämää: flow oletussivu voidaan luoda luomalla kansio jonka nimi on sama kuin flow id, sekä .xhtml tiedosto jonka nimi on edelleen sama kuin flow id, esim:

/someFlowName/someFlowName.xhtml:

<html xmlns="http://www.w3.org/1999/xhtml"
    xmlns:f="http://java.sun.com/jsf/core"
    xmlns:j="http://java.sun.com/jsf/flow"
>
    <f:metadata>
        <j:faces-flow-definition>
            <j:faces-flow-return id="someReturnName">
                <j:navigation-case>
                    <j:from-outcome>#{someBean.someReturn}</j:from-outcome>
                </j:navigation-case>
            </j:faces-flow-return>
        </j:faces-flow-definition>
    </f:metadata>

    <!-- Rest of view -->
</html>

Flow-tiedostojen välillä voi navigoida flow-id:n avulla, eli navigaatiojärjestelmä tunnistaa nyt flow id:n. Flow id voi olla sama kuin tiedostonimi, tai se voidaan määrittää j:faces-flow-definition elementin id-attribuutilla jos tiedostonimeä ei haluta käyttää. Navigointi flow-sivulta toiselle tapahtuu tähän tapaan:

 <h:commandLink value="Enter flow" action="someFlowName" />

No niin, tässähän ei ole mitään uutta. Aiemminkin JSF:ssä on voitu navigoida sivulta toiselle sivunimen perusteella. Uutta onkin se, että flow node (virtaussolmu? :p) voi olla muutakin kuin näkymä, view. Se voi olla myös Switch (EL lause joka evaluoi mikä on seuraava node), Return (virtauksen paluuarvo),  Method Call (vapaavalintaisen metodin suoritus ja navigaatio), tai Faces Flow Call (uuden flow-sarjan käynnistys).

Ja tässä vähän mehukkaampi Faces Flow määritys:

 

<f:metadata>
        <j:faces-flow-definition>

            <j:initializer>#{someBean.init}</j:initializer>
            <j:start-node>startNode</j:start-node>

            <j:switch id="startNode">
                <j:navigation-case>
                    <j:if>#{someBean.someCondition}</j:if>
                    <j:from-outcome>fooView</j:from-outcome>
                </j:navigation-case>
            </j:switch>

            <j:view id="barFlow">
                <j:vdl-document>barFlow.xhtml</j:vdl-document>
            </j:view>
            <j:view id="fooView">
                <j:vdl-document>create-customer.xhtml</j:vdl-document>
            </j:view>

            <j:faces-flow-return id="exit">
                <j:navigation-case>
                    <j:from-outcome>/exit</j:from-outcome>
                </j:navigation-case>
            </j:faces-flow-return>
            <j:faces-flow-return id="error">
                <j:navigation-case>
                    <j:from-outcome>/error</j:from-outcome>
                </j:navigation-case>
            </j:faces-flow-return>

            <j:finalizer>#{someBean.finish}</j:finalizer>

        </j:faces-flow-definition>
    </f:metadata>

 

Joten tällaista tänä vuonna. Vuosi 2013 on Javan kannalta jännä vuosi tulevien standardien johdosta. Spring Framework 4 tulee luonnollisesti sisältämään tuen myös EE 7 ja SE 8 piirteille, se on jo työn alla.

 

Java EE 7 kypsymässä

Odotellessa Java SE 8 versiota mullistuksineen, seuraava mielenkiintoinen päivitys – jo tänä vuonna – on tuleva Java EE 7 ”cloud” standardi – eli JSR-342.

Kiintoisia osia tulee olemaan:

– JPA 2.1 ja multitenancy (JSR-338)

– JAX-RS 2.0 ja viimeinkin client API (JSR-339)

– Servlet 3.1 ja websockets, multitenancy, ja PaaS malli (JSR-340)

– EL 3.0 (JSR-341)

– JMS 2.0 ja viimein yksinkertaistettu API (JSR-343)

– JSF 2.2 ja pikkuparannusten ohella HTML 5 tukea lisää (JSR-344)

– EJB 3.2 pääjuttuina PaaS, Multitenancy tuet (JSR-345)

– CDI 1.1 (JSR-346)

– Bean Validation 1.1 (JSR-349)

– JCACHE – viimein standardi cacheille, YAY!! 😉 Tämä on kova juttu. (JSR-107)

– Java State Management – tilanhallinnan standardointia (JSR-350)

– Batch applications for Java -eräajostandardi osaksi EE:tä (JSR-352)

– Concurrency Utilities for Java – concurrency rajapinnat EE ympäristöön (JSR-236)

– Java API for JSON Processing – No REST:n mukana tulee tietystikin JSON (JSR-353)

Että on sitä jotain mitä odottaa. Pääalustoina tietysti JBOSS, Websphere, Weblogic, Glassfish, Tomee, mutta kiintoisaa tulee olemaan myös Oracle PaaS pilvipalvelu, ja se tuleeko esim. Google App Enginen tai Amazonin puolelta tukea uudelle standardille.