M33KI ? KĂ©zako ?

La 1Ăšre fois oĂč j’ai trouvĂ© que Java Ă©tait intĂ©ressant pour faire du Web (remettons les choses Ă  leur place, je faisais de l’ASP.Net) c’est en dĂ©couvrant Play!> Framework 1. Pouvoir faire des apps web autonomes (j’utilisais IIS que je trouvais beaucoup plus sympa que Websphere), comprendre rĂ©ellement le MVC (mon Ă©quipe faisait du STRUTS, et comment dire 
), l’Auto-reload !!!, 
 J’ai mĂȘme commis un tuto gĂ©ant avec mon camarade @loic_d : PlayRules. Bref, un nouveau monde s’offrait Ă  moi :)


 jusqu’à l’arrivĂ©e de Play 2 qui mit Ă  genoux mon petit macbook air :(

Je dĂ©cidais donc de parfaire mon Ă©ducation Java par d’autres moyens, je m’amusais donc avec SparkJava : voir l’article N3rd.stack:[java] : faites votre propre stack java pour le web 
 une sacrĂ©e usine, mais qui me valu l’insigne honneur d’ĂȘtre citĂ© par les cast-codeurs (ok, je fais un peu cire-pompes comme ça, mais j’étais vraiment trĂšs fier). Lorsqu’un jour au bistro, @hgomez me parla d’un petit jeune prometteur qui dĂ©veloppait son propre langage : Golo, et que ça allait envoyer du lourd (le petit jeune c’est @jponge). Je me dĂ©pĂȘchais alors de contacter @jponge pour devenir Golo Testeur.

Quasiment dĂšs le dĂ©part, j’ai essayĂ© de voir comment je pouvais tordre la bĂȘte et l’utiliser pour faire des applis web, et aprĂšs moult essais instructifs (et productifs), ce fut la naissance de M33ki.

Bon alors, c’est quoi !?

M33ki est un “micro-web-framework” en Golo avec comme base toujours mon framework fĂ©tiche SparkJava destinĂ© Ă  faire des services REST (mais pas que) et des applications web lĂ©gĂšres qui peuvent mĂȘme tourner sur un RaspberryPI, un ChromeBook “crootĂ©â€, 
 tout en proposant des services intĂ©ressants (MongoDb, Redis, SSE, CORS, WebSocket, Promises, Actors (ok il faut le dire vite ;)) 
 M33ki c’est aussi un formidable terrain de jeu, ainsi qu’un “gros” use case pour dĂ©montrer que l’on peut probablement tout faire avec Golo.

Mes inspirations ont Ă©tĂ© clairement : Play 1, mais aussi Node & Express, Ratpack et d’autres qui sont venus se greffer au fur et Ă  mesure.

Et ça “marche” comment ?

Alors je vous passe l’installation (https://github.com/TypeUnsafe/m33ki# install-m33ki).

Créer un projet M33KI

Dans un terminal, tapez la commande m33ki et validez :

   _____  ________ ________  __   .__
  /     \ \_____  \\_____  \|  | _|__|
 /  \ /  \  _(__  <  _(__  <|  |/ /  |
/    Y    \/       \/       \    <|  |
\____|__  /______  /______  /__|_ \__|
        \/       \/       \/     \/
  WebApp server Golo powered (c) @k33g_org

OS : mac os x
Application name?>

Saisissez le nom de votre application (poney) et choisissez le type de projet (1- Golo Skeleton project) :

Application name?>poney
Creating poney application
1- copy /m33ki/jars to /Users/k33g_org/poney
2- copy /m33ki/libs to /Users/k33g_org/poney

reading configuration file
What kind of application ?
1- Golo Skeleton project
2- Hybrid project (Java + Golo)
number?>1

Remarque : le projet 2 “Hybrid” signifie bien que vous pouvez mixer le code Java et le code Golo, M33ki se dĂ©brouillera pour compiler la partie java automatiquement.

Maintenant vous pouvez aller dans le rĂ©pertoire poney et lancer votre webapp avec la commande ./go.sh (ou go.bat si vous ĂȘtes sous windows) mais attendez un petit peu.

main.golo

Avant de lancer quoique ce soit, ouvrez le fichier poney/main.golo :

module main

import m33ki.spark
import m33ki.hot #  requisite for "hot reloading"

import routes

function main = |args| {

  initialize(): static("/public"): port(8888)

  listenForChange("")

  loadRoutes()

}

# Explications

  • listenForChange("") signifie qu’à chaque fois que vous ferez une modification, votre projet sera re-dĂ©marrĂ©, M33ki Ă©coute Ă  la racine de la Webapp
  • static("/public")signifie que vos “assets” html, js, 
 sont dans le rĂ©pertoire public
  • loadRoutes() charge les routes dĂ©finies dans app/routes/routes.golo

Routes

Toujours dans main.golo, supprimez loadRoutes(), et nous allons Ă©crire nos 1Ăšres routes dans le fichier principal :

Ajouter l’import suivant import m33ki.jackson en en-tĂȘte de fichier, puis dĂ©finissez les 2 routes suivantes :

  GET("/hello", |request, response| {
    response: type("application/json")
    return Json(): toJsonString(map[["hello", "world"]])
  })

  GET("/hello/:name", |request, response| {
    response: type("application/json")
    let name = request: params(":name")
    return Json(): toJsonString(map[["hello", name]])
  })

DĂ©marrez :

cd poney
./go.sh

Maintenant,

c’est simple comme bonjour, vous pouvez bien sĂ»r faire des POST, PUT, DELETE (cf. https://github.com/TypeUnsafe/m33ki# rest-example), mais aussi chaĂźner les closures lors de la requĂȘte, ce qui peut ĂȘtre trĂšs pratique par exemple pour gĂ©rer l’authentification. Essayez ceci (sans arrĂȘter votre Webapp, je vous rappelle que ça redĂ©marre tout seul) :

  GET("/try"
    , |request, response| { #  check authentication
        let session = request: session(true)
        if session: attribute("authenticated") is null {
          return [false, "<h1>Don't even think about this!</h1>"]
        }
      }
    , |request, response| {
        return "<h1>Victory</h1>"
      }
  )

  GET("/login", |request, response| {
    let session = request: session(true)
    session: attribute("authenticated", true)
    return "<h1>Welcome</h1>"
  })

Conclusion

C’était une rapide prĂ©sentation de la “bĂ©bĂȘte”. Vous voyez Golo permet d’aller assez loin, mais on peut faire beaucoup d’autres choses comme ceci :

Jouer avec Redis :

  let bob = humans
    : model(): setId("bob"): setName("Bob Morane")
    : save()

Jouer avec MongoDb :

  humans: model(): setName("Bob Morane"): setAge(38): insert()

  humans: query(
    Qb("age"): lessThan(39): get()
  ): each(|human| -> println("- " + human))

Faire du calcul parallùle : (là c’est encore les balbutiements)

  let actor1 = Actor(executor): delay(500_L)
    : onReceive(|num, self| {
        num: times(|index|-> println("actor1 : " + index))
    })
    : start()

  let actor2 = Actor(executor): delay(300_L)
    : onReceive(|num, self| {
        num: times(|index|-> println("actor2 : " + index))
    })
    : start()

  actor1: tell(15): stop()
  actor2: tell(5): tell(v5) : stop()

Ou mĂȘme :

  let hope = Hope(executor)
    : todo(|iterations| { #  = 500
      let computation = compute()
      return computation
    })
    : done(|computation| {
      println(computation)
    })
    : go(500)

Je le rĂ©pĂšte, c’est de l’expĂ©rimentation (pour partie), et si vous passez par DevoxxFr cette annĂ©e, je vais expliquer comment j’ai pu coder ce genre de choses (et c’est simple) (et reproductible avec d’autres langages de la JVM comme Groovy) : Golo, de la sucrette syntaxique pour vos applications Java.

Last but not least

Il existe un projet “sister” de M33ki : Hi qui est un gĂ©nĂ©rateur de code “à la Yeoman” mais en Golo, et qui sait utiliser Bower et Npm. Comme Yeoman, il utilise un systĂšme de plugins et dispose notamment en standard d’un plugin dĂ©diĂ© Ă  M33ki : hi.gen.m33kig qui permet de gĂ©nĂ©rer les routes CRUD Golo, les modĂšles MongoDb et une partie du front js/html avec Backbone et React, que je n’ai pas encore documentĂ© si ce n’est par ici https://gist.github.com/k33g/9245205 (draft mode).

allez, j’arrĂȘte ;)

blog comments powered by Disqus

Related posts