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,

• si vous appelez http://localhost:8888/hello vous obtiendrez {"hello":"world"}
• si vous appelez http://localhost:8888/hello/bob vous obtiendrez {"hello":"bob"}

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>"
  })

• si vous appelez http://localhost:8888/try vous obtiendrez un gros Don’t even think about this!
• Tentez ensuite un http://localhost:8888/login puis à nouveau un http://localhost:8888/try vous obtiendrez un gentil Victory

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 ;)