Ver la documentación →

Javalin es un marco web muy liviano para Kotlin y Java que admite WebSockets, HTTP2 y solicitudes asíncronas. Los principales objetivos de Javalin son la simplicidad, una excelente experiencia para el desarrollador y una interoperabilidad de primera clase entre Kotlin y Java.

Javalin es más una biblioteca que un marco. Algunos puntos clave:

No necesitas extender nada.
No hay @Annotaciones
no hay reflejo
No hay otra magia; solo código.

información general

La página web del proyecto es javalin.io (la fuente está en javalin/javalin.github.io).
Lea la documentación en: javalin.io/documentation
Puede encontrar un resumen de la licencia en TLDR Legal.
Temas interesantes

Comunidad

Tenemos un servidor de Discord muy activo donde puedes obtener ayuda rápidamente. También tenemos un Slack (mucho menos activo) si lo prefieres.

Las contribuciones son bienvenidas, puedes leer más sobre cómo contribuir en nuestra guía: CONTRIBUCIÓN

Considere patrocinar o protagonizar Javalin si desea apoyar el proyecto.

Inicio rápido

Agregar dependencia

experto

 
    io.javalin
    javalin
    6.3.0

Gradle

 implementación("io.javalin:javalin:6.3.0")

Iniciar programación (Java)

 importar io.javalin.Javalin; clase pública Hola Mundo { public static void main(String[] args) { var app = Javalin.create(/*config*/)
            .get("/", ctx -> ctx.result("Hola mundo"))
            .start(7070);
    }
}

Iniciar programación (Kotlin)

 importar io.javalin.Javalinfun main() { val aplicación = Javalin.create(/*config*/)
        .get("/") { it.result("Hola mundo") }
        .inicio(7070)
}

Ejemplos

Esta sección contiene algunos ejemplos, en su mayoría extraídos de los documentos. Todos los ejemplos están en Kotlin, pero puedes encontrarlos en Java en la documentación (son solo cambios de sintaxis).

Puede encontrar más ejemplos en el repositorio javalin-samples.

Estructura de API y configuración del servidor.

 importar io.javalin.Javalinimport io.javalin.apibuilder.ApiBuilder.*fun main() { val app = Javalin.create { config ->
        config.useVirtualThreads = verdadero
        config.http.asyncTimeout = 10_000L
        config.staticFiles.add("/público")
        config.staticFiles.enableWebjars()
        config.router.apiBuilder {
            ruta("/usuarios") {
                get(ControladorUsuario::getAll)
                publicar(Controlador de usuario::crear)
                ruta("/{userId}") {
                    get(Controlador de usuario::getOne)
                    parche(Controlador de usuario::actualizar)
                    eliminar(Controlador de usuario::eliminar)
                }
                ws("/eventos", userController::webSocketEvents)
            }
        }
    }.inicio(7070)
}

WebSockets

 app.ws("/websocket/{ruta}") { ws ->
    ws.onConnect { ctx -> println("Conectado") }
    ws.onMessage { ctx -> val usuario = ctx.message() // convertir de cadena json a objeto
        ctx.send(usuario) // convertir a cadena json y enviar de vuelta
    }
    ws.onClose { ctx -> println("Cerrado") }
    ws.onError { ctx -> println("Error") }
}

Filtros y mapeadores

 app.before("/some-path/*") { ctx -> ... } // se ejecuta antes de las solicitudes a /some-path/*app.before { ctx -> ... } // se ejecuta antes de todas las solicitudesapp .after { ctx -> ... } // se ejecuta después de todas las solicitudesapp.exception(Exception.class) { e, ctx -> ... } // se ejecuta si no se detecta Exceptionapp.error(404) { ctx -> .. } // se ejecuta si el estado es 404 (después de todos los demás controladores)app.wsBefore("/some-path/*") { ws -> ... } // se ejecuta antes de los eventos de ws en /some-path/*app.wsBefore { ws -> . .. } // se ejecuta antes de todos los ws eventsapp.wsAfter { ws -> ... } // se ejecuta después de todos los ws eventsapp.wsException(Exception.class) { e, ctx -> ... } // se ejecuta si no se detecta la excepción en el controlador ws

mapeo JSON

 var todos = matrizDe(...)
app.get("/todos") { ctx -> // asigna la matriz de Todos a json-string
    ctx.json(todos)
}
app.put("/todos") { ctx -> // asigna el cuerpo de la solicitud (json) a la matriz de Todos
    todos = ctx.body>()
    ctx.estado(204)
}

Cargas de archivos

 aplicación.post("/cargar") { ctx ->
    ctx.uploadedFiles("archivos").forEach { uploadedFile -> FileUtil.streamToFile(uploadedFile.content(), "upload/${uploadedFile.filename()}")
    }
}

Complementos

Javalin tiene un sistema de complementos que le permite agregar funcionalidad a la biblioteca principal. Puede encontrar una lista de complementos aquí.

Instalar un complemento es tan fácil como agregar una dependencia a su proyecto y registrarlo en Javalin:

 Javalin.create {configuración ->
    config.registerPlugin(MiPlugin())
}

Algunos de los complementos más populares son:

Complemento OpenAPI

El complemento Javalin OpenAPI le permite generar una especificación OpenAPI 3.0 para su API en el momento de la compilación.

Anota tus rutas con @OpenApi para generar la especificación:

 @OpenApi(
    resumen = "Obtener todos los usuarios",
    OperationId = "getAllUsers",
    etiquetas = ["Usuario"],
    respuestas = [OpenApiResponse("200", [OpenApiContent(Array::clase)])],
    ruta = "/usuarios",
    métodos = [HttpMethod.GET]
)divertido getAll(ctx: Contexto) {
    ctx.json(UserService.getAll())
}

También están disponibles las implementaciones de Swagger UI y ReDoc UI para ver la especificación generada en su navegador.

Para obtener más información, consulte la Wiki Javalin OpenAPI.

Complemento SSL

El complemento Javalin SSL le permite configurar SSL fácilmente para su servidor Javalin, admitiendo una variedad de formatos como PEM, PKCS12, DER, P7B y JKS.

Habilitar SSL en el puerto 443 es tan fácil como:

 complemento val = SSLPlugin { conf ->
    conf.pemFromPath("/ruta/a/cert.pem", "/ruta/a/key.pem")
}Javalin.create { javalinConfig ->
    javalinConfig.plugins.register(complemento)
}.comenzar()