spiffy

Qu’est-ce que Spiffy ?

Chouette...

• est écrit en Scala
• utilise la fantastique bibliothèque et les acteurs Akka pour évoluer
• utilise l'API servlet 3.0 pour la gestion des requêtes asynchrones
• est modulaire (le remplacement des composants est simple)
• utilise les DSL pour réduire le code là où vous ne le souhaitez pas
• prend en charge les hooks de requête autour des contrôleurs

Spiffy est un framework Web utilisant Scala, Akka (une implémentation d'acteur Scala) et l'API Java Servelet 3.0. Il utilise l'interface asynchrone et vise à fournir un environnement massivement parallèle et évolutif pour les applications Web. Les différents composants de Spiffy sont tous basés sur l'idée qu'ils doivent être des modules minimalistes indépendants qui effectuent de petites quantités de travail très rapidement et transmettent la demande au composant suivant du pipeline. Une fois que le dernier composant a fini de traiter la requête, il signale au conteneur de servlet en « complétant » la requête et en la renvoyant au client.

Exemple rapide

Ajoutez quelques itinéraires :

 // index page, no code, just text
"""^/$""".r -> "Welcome to Spiffy!",

// main news page
new Regex("""^/(news)/$""") -> NewsController(),

// view some news by id
new Regex("""^/(news)/(view)/(d+)/$""") -> NewsController()

Écrivez le contrôleur :

 def receive = {
    
    // handles "news/add/"
    case ControllerMsg(List("news", "save"), req, res, ctx) => {

        // run validation on the request using Spiffy's validation DSL

        var errors:Map[String, Set[String]] = validate (req) (

            "email" as email confirmedBy "email_confirm",
            "email_confirm" as email,
            "title" as (string, 32),
            "body" as string,
            "tag" as string optional
    
        ) match {
            case Some(List(errs,warns)) => { // Problem validating
                errs
            }

            case None => None.toMap // passed validation        
        }
    }

    // handles "/news/"
    case ControllerMsg(List("news"), req, res, ctx) => {

        // load up news and stuff in map then render
        val params = loadNews
        view() ! ViewMsg("news", params, req, res, ctx)
    }

    // handles "/news/view/$newsId/"
    case ControllerMsg(List("news", "view", newsId), req, res, ctx) => {

        // usually you want to load the item, in this example we dont
        // load item and set the params that the view will render
        val news = loadNewsItem(newsId)
        val params:Map[Any,Any] = Map("news" -> news)

        // ask the view to render
        view() ! ViewMsg("newsView", params, req, res, ctx)
    }    
}

Créez ensuite des modèles. Vous pouvez en savoir plus sur cet exemple en consultant NewsController et SpiffyConfig

Pour le moment, pour utiliser Spiffy, vous devez créer le fichier jar (mvn jar:jar) et l'ajouter au chemin de classe de votre application. Vous devez également définir la variable d'environnement suivante (context.xml fera l'affaire) :

 <Environment name="SpiffyConfigObject" value="org.spiffy.config.SpiffyBuiltinConfig" type="java.lang.String"/>

Vous devez remplacer org.spiffy.config.SpiffyBuiltinConfig par un objet qui étend org.spiffy.config.SpiffyConfig et fournit toutes les valeurs nécessaires. Jetez un œil à SpiffyConfig pour un exemple.

Comment Spiffy utilise-t-il les acteurs Scala (Akka) ?

Spiffy s'appuie sur les acteurs d'Akka pour compartimenter et isoler tous ses différents composants. Chaque composant du pipeline Spiffy (à l'exception du filtre initial) est composé d'un pool d'acteurs Akka. Les acteurs Spiffy sont soutenus par des pools d'équilibrage de charge de différents types de répartiteurs.

Comment une requête transite-t-elle dans le framework Spiffy ?

Spiffy est implémenté en tant que filtre. Une fois que le filtre a reçu la requête, il la met en mode asynchrone et l'envoie au routeur. Le routeur décide ensuite quoi faire de la requête en inspectant l'URL de la requête et en l'évaluant par rapport à sa liste de mappages de contrôleurs connus. Un mappage est une expression régulière qui correspond à l'URL demandée et l'attribue au contrôleur correspondant. Si une correspondance réussie est trouvée, le routeur enverra au contrôleur la demande (et tous les objets nécessaires qui doivent être envoyés avec). À ce stade, le travail du routeur est terminé et il est libre de traiter les nouvelles requêtes entrantes. Une fois que le contrôleur a reçu la requête, il exécutera toute la logique dont il a besoin sur la requête et pourra décider de mettre fin à la requête ou de la transmettre à un autre composant de Spiffy (généralement un gestionnaire de vues).

Que sont les hameçons Spiffy et où peuvent-ils être placés ?

Spiffy utilise le concept de hooks pour exécuter une logique qui peut être encapsulée et exécutée avant et après certains composants du pipeline du framework. Les hooks peuvent être exécutés avant et après les contrôleurs et les vues. Un hook qui s'exécutera avant qu'un contrôleur puisse décider de le contourner complètement ou pourrait simplement exécuter une certaine logique comme l'authentification ou modifier la requête elle-même avant que le contrôleur n'ait la possibilité de travailler avec elle. Un hook qui s'exécute après un contrôleur peut également rediriger la demande vers un autre contrôleur, la modifier ou y mettre fin, puis en la renvoyant au client. La même logique est utilisée avant et après les vues où le hook peut arrêter complètement le rendu de la vue ou peut transmettre la sortie rendue à une autre partie du framework qui peut effectuer un travail supplémentaire sur la sortie rendue.

Remarques

• Lors de l'envoi d'un message au ViewHandler (pour Freemarker) à l'aide d'un List(), Freemarker se plaint. Le tableau peut être utilisé à la place.