[JAVA] Introduction à Ratpack (Extra Edition) --Ratpack écrit en Kotlin

Ratpack est construit pour Java et Groovy, mais il fonctionne avec les JVM, bien sûr, avec d'autres langages comme Kotlin et Scala. Voici quelques conseils sur ce que serait d'écrire un Ratpack à Kotlin. Si vous avez de meilleures idées, partagez-les dans les commentaires.

Description de type DSL

Ratpack exploite le DSL de Groovy, il a donc des méthodes qui prennent lambdas comme arguments dans de nombreux endroits. Par exemple, la partie qui définit le gestionnaire sur le serveur peut être décrite comme suit.

RatpackServer.start(spec -> {
    spec.handlers(chain -> {
        chain.get("index.html", ctx -> {
            ctx.render(ctx.file("index.html"));
        });
    });
});

Lorsque Kotlin reçoit un lambda à la fin de l'argument d'une méthode, il peut écrire ce lambda en dehors des parenthèses. Vous pouvez également utiliser ʻit` comme espace réservé pour les arguments lambda.

RatpackServer.start {
    it.handlers {
        it.get("index.html") {
            it.render(it.file("index.html"))
        }
    }
}

Bien qu'il soit inférieur à Groovy, vous pouvez écrire du code avec une apparence de type DSL.

Fonction opérateur

Ratpack utilise une interface fonctionnelle appelée ʻActiondans de nombreuses parties. Il s'agit de l'équivalent Java 8Consumeret est souvent utilisé pour configurer quelque chose. Par exemple, la méthodehandlers ()qui définit le gestionnaire sur le serveur a ʻAction <Chain>comme argument. Nous allons définir le mappage entre l'URL et le gestionnaire dans cette chaîne, mais lorsque le nombre de gestionnaires augmente dans une certaine mesure, nous voudrons diviser cette ʻAction. La division ʻAction peut être combinée en une seule en utilisant la méthode ʻappend () . Cependant, répéter plusieurs fois ʻappend () rend difficile la compréhension. Je voudrais utiliser la notation introductive si possible. Utilisez la [Surcharge des opérateurs] de Kotlin (https://kotlinlang.org/docs/reference/operator-overloading.html#operator-overloading) pour permettre aux opérateurs de se combiner.

operator fun <T> Action<T>.plus(other: Action<in T>): Action<T> = this.append(other)

fun createHandlers() = AccountAction() + HistroyAction() + // ...

Inutile de dire que la surutilisation de la surcharge de l'opérateur est strictement interdite.

Déclaration de «paire» et de destruction

Des méthodes telles que «flatRight» dans «Promise» sont des méthodes relativement courantes et pratiques pour regrouper plusieurs «Promise» ensemble. Le type de retour sera le type Pair, qui est un taple dans Ratpack. Les tapples sont utiles, mais dans les langages de programmation non pris en charge (c'est-à-dire Java), vous devez utiliser des méthodes comme left, right pour obtenir la valeur, qui est parfois un anti-pattern.

Kotlin ne prend pas en charge le tapple lui-même, mais utilise à la place une fonctionnalité appelée Déclaration de destruction pour réaliser un pseudo-tupple. C'est une fonction qui peut être utilisée en divisant chaque componentN () si chaque classe a une méthode componentN () (N est un nombre). Bien sûr, le Pair de Ratpack n'a pas de méthode component1 (), mais en l'implémentant comme une méthode d'extension, il est possible d'effectuer une attribution de pseudo-partition.

operator fun <T> Pair<T, *>.component1(): T = this.left
operator fun <T> Pair<*, T>.component2(): T = this.right

Un tel vieux code fractionnant Pair

authenticator.checkLoggedIn(ctx).flatRight {
    ctx.parse(ReportParameter::class.java)
}.nextOp { pair ->
    val user = pair.left
    val parameter = pair.right
    // (...)
}

Vous pourrez écrire comme ça.

authenticator.checkLoggedIn(ctx).flatRight {
    ctx.parse(ReportParameter::class.java)
}.nextOp { (user, parameter) ->
    // (...)
}

Le point regrettable est que l'EDI ne complète pas et que vous devez écrire vous-même l'instruction ʻimport` de la méthode d'extension.