Sehen Sie sich die Dokumentation an →

Javalin ist ein sehr leichtes Webframework für Kotlin und Java, das WebSockets, HTTP2 und asynchrone Anfragen unterstützt. Die Hauptziele von Javalin sind Einfachheit, ein großartiges Entwicklererlebnis und erstklassige Interoperabilität zwischen Kotlin und Java.

Javalin ist eher eine Bibliothek als ein Framework. Einige wichtige Punkte:

Sie müssen nichts verlängern
Es gibt keine @Annotations
Es gibt keine Reflexion
Es gibt keine andere Magie; einfach codieren.

allgemeine Informationen

Die Projektwebseite ist javalin.io (die Quelle ist javalin/javalin.github.io).
Lesen Sie die Dokumentation unter: javalin.io/documentation
Eine Zusammenfassung der Lizenz finden Sie bei TLDR Legal
Interessante Themen

Gemeinschaft

Wir haben einen sehr aktiven Discord-Server, auf dem Sie schnell Hilfe erhalten können. Wir haben auch einen (viel weniger aktiven) Slack, wenn Sie das bevorzugen.

Beiträge sind herzlich willkommen. Weitere Informationen zum Mitwirken finden Sie in unserem Leitfaden: BEITRAGEN

Bitte denken Sie darüber nach, Javalin zu sponsern oder in der Hauptrolle zu spielen, wenn Sie das Projekt unterstützen möchten.

Schnellstart

Abhängigkeit hinzufügen

Maven

 
    io.javalin
    javalin
    6.3.0

Gradle

 Implementierung("io.javalin:javalin:6.3.0")

Beginnen Sie mit der Programmierung (Java)

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

Beginnen Sie mit der Programmierung (Kotlin)

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

Beispiele

Dieser Abschnitt enthält einige Beispiele, die größtenteils nur aus den Dokumenten stammen. Alle Beispiele sind in Kotlin, aber Sie können sie in der Dokumentation in Java finden (es handelt sich lediglich um Syntaxänderungen).

Weitere Beispiele finden Sie im javalin-samples-Repository.

API-Struktur und Serverkonfiguration

 import io.javalin.Javalinimport io.javalin.apibuilder.ApiBuilder.*fun main() { val app = Javalin.create { config ->
        config.useVirtualThreads = true
        config.http.asyncTimeout = 10_000L
        config.staticFiles.add("/public")
        config.staticFiles.enableWebjars()
        config.router.apiBuilder {
            path("/users") {
                get(UserController::getAll)
                post(UserController::create)
                path("/{userId}") {
                    get(UserController::getOne)
                    patch(UserController::update)
                    delete(UserController::delete)
                }
                ws("/events", userController::webSocketEvents)
            }
        }
    }.start(7070)
}

WebSockets

 app.ws("/websocket/{path}") { ws ->
    ws.onConnect { ctx -> println("Connected") }
    ws.onMessage { ctx -> val user = ctx.message() // von JSON-String in Objekt konvertieren
        ctx.send(user) // in JSON-String konvertieren und zurücksenden
    }
    ws.onClose { ctx -> println("Closed") }
    ws.onError { ctx -> println("Errored") }
}

Filter und Mapper

 app.before("/some-path/*") { ctx -> ... } // wird vor Anfragen an /some-path/*app.before { ctx -> ... } // wird vor allen Anfragen ausgeführtapp .after { ctx -> ... } // wird nach allen Anfragen ausgeführtapp.Exception(Exception.class) { e, ctx -> ... } // wird ausgeführt, wenn nicht erfasst Exceptionapp.error(404) { ctx -> .. . } // wird ausgeführt, wenn der Status lautet 404 (nach allen anderen Handlern)app.wsBefore("/some-path/*") { ws -> ... } // wird vor ws-Ereignissen auf /some-path/*app.wsBefore { ws -> .. ausgeführt. . } // Läuft vor allen ws-Eventsapp.wsAfter { ws -> ... } // Läuft nach allen ws-Eventsapp.wsException(Exception.class) { e, ctx -> ... } // Läuft, wenn Ausnahme nicht erfasst wird ws-Handler

JSON-Zuordnung

 var todos = arrayOf(...)
app.get("/todos") { ctx -> // Array von Todos dem JSON-String zuordnen
    ctx.json(todos)
}
app.put("/todos") { ctx -> // Request-Body (JSON) dem Todos-Array zuordnen
    todos = ctx.body>()
    ctx.status(204)
}

Datei-Uploads

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

Plugins

Javalin verfügt über ein Plugin-System, mit dem Sie der Kernbibliothek Funktionalität hinzufügen können. Eine Liste der Plugins finden Sie hier.

Die Installation eines Plugins ist so einfach wie das Hinzufügen einer Abhängigkeit zu Ihrem Projekt und die Registrierung bei Javalin:

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

Einige der beliebtesten Plugins sind:

OpenAPI-Plugin

Mit dem Javalin OpenAPI-Plugin können Sie zur Kompilierungszeit eine OpenAPI 3.0-Spezifikation für Ihre API generieren.

Kommentieren Sie Ihre Routen mit @OpenApi um die Spezifikation zu generieren:

 @OpenApi(
    summary = „Alle Benutzer abrufen“,
    operationId = "getAllUsers",
    tags = ["Benutzer"],
    Antworten = [OpenApiResponse("200", [OpenApiContent(Array::class)])],
    path = "/users",
    Methoden = [HttpMethod.GET]
)fun getAll(ctx: Context) {
    ctx.json(UserService.getAll())
}

Swagger UI- und ReDoc UI-Implementierungen zum Anzeigen der generierten Spezifikation in Ihrem Browser sind ebenfalls verfügbar.

Weitere Informationen finden Sie im Javalin OpenAPI Wiki.

SSL-Plugin

Mit dem Javalin SSL-Plugin können Sie ganz einfach SSL für Ihren Javalin-Server konfigurieren und eine Vielzahl von Formaten wie PEM, PKCS12, DER, P7B und JKS unterstützen.

Das Aktivieren von SSL auf dem 443-Port ist so einfach wie:

 val Plugin = SSLPlugin { conf ->
    conf.pemFromPath("/path/to/cert.pem", "/path/to/key.pem")
}Javalin.create { javalinConfig ->
    javalinConfig.plugins.register(plugin)
}.Start()