Consulter la documentation →

Javalin est un framework Web très léger pour Kotlin et Java qui prend en charge les requêtes WebSockets, HTTP2 et asynchrones. Les principaux objectifs de Javalin sont la simplicité, une excellente expérience de développement et une interopérabilité de premier ordre entre Kotlin et Java.

Javalin est plus une bibliothèque qu'un framework. Quelques points clés :

Vous n'avez pas besoin de prolonger quoi que ce soit
Il n'y a pas d'@Annotations
Il n'y a pas de reflet
Il n'y a pas d'autre magie ; juste du code.

informations générales

La page Web du projet est javalin.io (la source est sur javalin/javalin.github.io).
Lire la documentation sur : javalin.io/documentation
Un résumé de la licence peut être trouvé sur TLDR Legal
Questions intéressantes

Communauté

Nous disposons d'un serveur Discord très actif sur lequel vous pouvez obtenir de l'aide rapidement. Nous avons également un Slack (beaucoup moins actif) si vous préférez ça.

Les contributions sont les bienvenues, vous pouvez en savoir plus sur la contribution dans notre guide : CONTRIBUER

Veuillez envisager de parrainer ou de mettre en vedette Javalin si vous souhaitez soutenir le projet.

Démarrage rapide

Ajouter une dépendance

Maven

 
    io.javalin
    javalin
    6.3.0

Graduation

 implémentation("io.javalin:javalin:6.3.0")

Démarrer la programmation (Java)

 import io.javalin.Javalin;public class HelloWorld { public static void main(String[] args) { var app = Javalin.create(/*config*/)
            .get("/", ctx -> ctx.result("Bonjour tout le monde"))
            .start(7070);
    }
}

Démarrer la programmation (Kotlin)

 importer io.javalin.Javalinfun main() { val app = Javalin.create(/*config*/)
        .get("/") { it.result("Hello World") }
        .start(7070)
}

Exemples

Cette section contient quelques exemples, pour la plupart simplement extraits de la documentation. Tous les exemples sont en Kotlin, mais vous pouvez les trouver en Java dans la documentation (ce ne sont que des changements de syntaxe).

Vous pouvez trouver plus d'exemples dans le référentiel javalin-samples.

Structure de l'API et configuration du serveur

 importer io.javalin.Javalinimport io.javalin.apibuilder.ApiBuilder.*fun main() { val app = Javalin.create { config ->
        config.useVirtualThreads = vrai
        config.http.asyncTimeout = 10_000L
        config.staticFiles.add("/public")
        config.staticFiles.enableWebjars()
        config.router.apiBuilder {
            chemin("/utilisateurs") {
                obtenir (UserController :: getAll)
                poster (UserController :: créer)
                chemin("/{IDutilisateur}") {
                    obtenir (UserController :: getOne)
                    patch (UserController :: mise à jour)
                    supprimer (UserController :: supprimer)
                }
                ws("/events", userController::webSocketEvents)
            }
        }
    }.start(7070)
}

WebSockets

 app.ws("/websocket/{chemin}") { ws ->
    ws.onConnect { ctx -> println("Connecté") }
    ws.onMessage { ctx -> val user = ctx.message() // conversion de chaîne json en objet
        ctx.send(user) // convertir en chaîne json et renvoyer
    }
    ws.onClose { ctx -> println("Fermé") }
    ws.onError { ctx -> println("Erreur") }
}

Filtres et mappeurs

 app.before("/some-path/*") { ctx -> ... } // s'exécute avant les requêtes vers /some-path/*app.before { ctx -> ... } // s'exécute avant toutes les requêtesapp .after { ctx -> ... } // s'exécute après toutes les requêtesapp.exception(Exception.class) { e, ctx -> ... } // s'exécute si Exceptionapp.error(404) { ctx -> .. . } // s'exécute si le statut est 404 (après tous les autres gestionnaires)app.wsBefore("/some-path/*") { ws -> ... } // s'exécute avant les événements ws sur /some-path/*app.wsBefore { ws -> .. . } } // s'exécute avant tous les ws eventsapp.wsAfter { ws -> ... } // s'exécute après tous les ws eventsapp.wsException(Exception.class) { e, ctx -> ... } // s'exécute si une exception n'est pas détectée dans ws gestionnaire

Cartographie JSON

 var todos = arrayOf(...)
app.get("/todos") { ctx -> // mappe le tableau de Todos à la chaîne json
    ctx.json(toutes)
}
app.put("/todos") { ctx -> // mappe le corps de la requête (json) au tableau de Todos
    todos = ctx.body>()
    ctx.statut(204)
}

Téléchargements de fichiers

 app.post("/upload") { ctx ->
    ctx.uploadedFiles("files").forEach { uploadedFile -> FileUtil.streamToFile(uploadedFile.content(), "upload/${uploadedFile.filename()}")
    }
}

Plugins

Javalin dispose d'un système de plugins qui vous permet d'ajouter des fonctionnalités à la bibliothèque principale. Vous pouvez trouver une liste de plugins ici.

Installer un plugin est aussi simple que d'ajouter une dépendance à votre projet et de l'enregistrer auprès de Javalin :

 Javalin.create {config ->
    config.registerPlugin(MonPlugin())
}

Certains des plugins les plus populaires sont :

Plugin OpenAPI

Le plugin Javalin OpenAPI vous permet de générer une spécification OpenAPI 3.0 pour votre API au moment de la compilation.

Annotez vos routes avec @OpenApi pour générer la spécification :

 @OpenApi(
    résumé = "Obtenir tous les utilisateurs",
    opérationId = "getAllUsers",
    balises = ["Utilisateur"],
    réponses = [OpenApiResponse("200", [OpenApiContent(Array::class)])],
    chemin = "/utilisateurs",
    méthodes = [HttpMethod.GET]
)fun getAll(ctx : Contexte) {
    ctx.json(UserService.getAll())
}

Des implémentations de Swagger UI et ReDoc UI pour afficher la spécification générée dans votre navigateur sont également disponibles.

Pour plus d'informations, consultez le wiki Javalin OpenAPI.

Plugin SSL

Le plugin Javalin SSL vous permet de configurer facilement SSL pour votre serveur Javalin, prenant en charge une variété de formats tels que PEM, PKCS12, DER, P7B et JKS.

L'activation de SSL sur le port 443 est aussi simple que :

 val plugin = SSLPlugin { conf ->
    conf.pemFromPath("/chemin/vers/cert.pem", "/chemin/vers/key.pem")
}Javalin.create { javalinConfig ->
    javalinConfig.plugins.register(plugin)
}.commencer()