Veja a documentação →

Javalin é uma estrutura web muito leve para Kotlin e Java que suporta WebSockets, HTTP2 e solicitações assíncronas. Os principais objetivos do Javalin são simplicidade, ótima experiência de desenvolvedor e interoperabilidade de primeira classe entre Kotlin e Java.

Javalin é mais uma biblioteca do que um framework. Alguns pontos-chave:

Você não precisa estender nada
Não há @Annotations
Não há reflexão
Não existe outra magia; apenas código.

informações gerais

A página do projeto é javalin.io (a fonte está em javalin/javalin.github.io).
Leia a documentação em: javalin.io/documentation
Um resumo da licença pode ser encontrado em TLDR Legal
Questões interessantes

Comunidade

Temos um servidor Discord muito ativo onde você pode obter ajuda rapidamente. Também temos um Slack (muito menos ativo), se você preferir.

Contribuições são muito bem-vindas, você pode ler mais sobre como contribuir em nosso guia: CONTRIBUINDO

Por favor, considere patrocinar ou estrelar Javalin se quiser apoiar o projeto.

Início rápido

Adicionar dependência

Maven

 
    io.javalin
    javalin
    6.3.0

Gradle

 implementação("io.javalin:javalin:6.3.0")

Iniciar a programação (Java)

 importar io.javalin.Javalin;public class HelloWorld { public static void main(String[] args) { var app = Javalin.create(/*config*/)
            .get("/", ctx -> ctx.result("Olá Mundo"))
            .iniciar(7070);
    }
}

Comece a programar (Kotlin)

 importar io.javalin.Javalinfun main() { val app = Javalin.create(/*config*/)
        .get("/") { it.result("Olá Mundo") }
        .iniciar(7070)
}

Exemplos

Esta seção contém alguns exemplos, a maioria extraídos apenas dos documentos. Todos os exemplos estão em Kotlin, mas você pode encontrá-los em Java na documentação (são apenas alterações de sintaxe).

Você pode encontrar mais exemplos no repositório javalin-samples.

Estrutura da API e configuração do servidor

 importar io.javalin.Javalinimport io.javalin.apibuilder.ApiBuilder.*fun main() { val app = Javalin.create { config ->
        config.useVirtualThreads = verdadeiro
        config.http.asyncTimeout = 10_000L
        config.staticFiles.add("/public")
        config.staticFiles.enableWebjars()
        config.router.apiBuilder {
            caminho("/usuários") {
                get(UserController::getAll)
                postar(UserController::criar)
                caminho("/{userId}") {
                    get(UserController::getOne)
                    patch(UserController::atualização)
                    excluir(UserController::delete)
                }
                ws("/eventos", userController::webSocketEvents)
            }
        }
    }.start(7070)
}

WebSockets

 app.ws("/websocket/{caminho}") { ws ->
    ws.onConnect { ctx -> println("Conectado") }
    ws.onMessage { ctx -> val user = ctx.message() // converte de string json em objeto
        ctx.send(user) // converte para string json e envia de volta
    }
    ws.onClose { ctx -> println("Fechado") }
    ws.onError { ctx -> println("Erro") }
}

Filtros e mapeadores

 app.before("/some-path/*") { ctx -> ... } // é executado antes de solicitações para /some-path/*app.before { ctx -> ... } // é executado antes de todas as solicitaçõesapp .after { ctx -> ... } // executa após todas as solicitaçõesapp.exception(Exception.class) { e, ctx -> ... } // executa se não for detectado Exceptionapp.error(404) { ctx -> .. .} // é executado se o status for 404 (depois de todos os outros manipuladores)app.wsBefore("/some-path/*") { ws -> ... } // é executado antes dos eventos ws em /some-path/*app.wsBefore { ws -> .. .} } // é executado antes de todos os ws eventsapp.wsAfter { ws -> ... } // é executado depois de todos os ws eventsapp.wsException(Exception.class) { e, ctx -> ... } // é executado se a exceção não for detectada em manipulador de ws

Mapeamento JSON

 var todos = arrayOf(...)
app.get("/todos") { ctx -> // mapeia array de Todos para json-string
    ctx.json(todos)
}
app.put("/todos") { ctx -> // mapeia o corpo da solicitação (json) para o array de Todos
    todos = ctx.body>()
    ctx.status(204)
}

Uploads de arquivos

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

Plug-ins

Javalin possui um sistema de plugins que permite adicionar funcionalidades à biblioteca principal. Você pode encontrar uma lista de plug-ins aqui.

Instalar um plugin é tão fácil quanto adicionar uma dependência ao seu projeto e registrá-lo no Javalin:

 Javalin.create { configuração ->
    config.registerPlugin(MeuPlugin())
}

Alguns dos plug-ins mais populares são:

Plug-in OpenAPI

O plugin Javalin OpenAPI permite gerar uma especificação OpenAPI 3.0 para sua API em tempo de compilação.

Anote suas rotas com @OpenApi para gerar a especificação:

 @OpenApi(
    summary = "Obter todos os usuários",
    operaçãoId = "getAllUsers",
    tags = ["Usuário"],
    respostas = [OpenApiResponse("200", [OpenApiContent(Array::class)])],
    caminho = "/usuários",
    métodos = [HttpMethod.GET]
)fun getAll(ctx: Contexto) {
    ctx.json(UserService.getAll())
}

Implementações Swagger UI e ReDoc UI para visualizar a especificação gerada em seu navegador também estão disponíveis.

Para obter mais informações, consulte o Wiki Javalin OpenAPI.

Plug-in SSL

O plugin Javalin SSL permite configurar facilmente SSL para seu servidor Javalin, suportando uma variedade de formatos como PEM, PKCS12, DER, P7B e JKS.

Habilitar SSL na porta 443 é tão fácil quanto:

 val plugin = SSLPlugin {conf ->
    conf.pemFromPath("/caminho/para/cert.pem", "/caminho/para/key.pem")
}Javalin.create {javalinConfig ->
    javalinConfig.plugins.register(plugin)
}.começar()