Concrete Logo
Hamburger button

Kotlin no Backend (Parte 2)

  • Blog
  • 16 de Agosto de 2016

Ontem, começamos aqui no Blog uma série sobre o Kotlin no backend, configurando o ambiente e criando uma função main para mostrar a mensagem. Se você ainda não viu, pode clicar aqui. Hoje, vamos criar algo um pouco mais complexo usando o SpringBoot para levantar um serviço REST simples em Jersey.

Início

Vamos utilizar o Gradle para fazer build e gerenciar as dependências do SpringBoot no projeto. Para isso, crie uma pasta, execute o gradle e importe no IntelliJ. Criei a pasta ServicoKotlin, mas fique à vontade para escolher a sua =D

gradle init –type java-library

Ele vai criar a seguinte estrutura:

Com o projeto importado no IntelliJ IDEA, vamos configurar o Gradle para resolver dependências, plugins e o build de nosso projeto.

Abra o arquivo build.gradle, que se encontra na raiz do projeto, e substitua pelo o seguinte conteúdo:

Criando nossas classes

Clique com o botão direito nas pastas java em main.java e test.java e as delete. Também com o botão direito, clique na pasta main, crie o diretório kotlin e marque este como Sources Root. A estrutura deve ficar assim: src/main/kotlin, igual ao que está no sourceSets do script build.gradle.

Crie um pacote à sua escolha (o meu é org.kotlin) e crie um arquivo kotlin dentro com o nome de App. A extensão dos arquivos kotlin é .kt. Neste arquivo vamos criar nossa classe e a função main para o SpringBoot.

Vamos agora detalhar este trecho:

@SpringBootApplication é uma anotação de conveniência, que marca a classe com as seguintes anotações com seus atributos default:

  • @Configuration: anota a classe como uma fonte de definições de beans para o contexto da aplicação;
  • @EnableAutoConfiguration: diz ao SpringBoot para começar a adicionar beans com base nas configurações de classpath e várias configurações de propriedade;
  • @ComponentScan: diz ao Spring para procurar outros componentes, configurações e serviços no pacote atual.

Modificador open na classe é o oposto do final do Java. Em Kotlin, todas as classes e métodos são final por padrão, e para o Spring elas não podem ser final devido ao uso de proxy CGLIB.

Uma função restTemplate com anotação @Bean cria uma instância do RestTemplate como um Bean do Spring.

Uma função objectMapperBuilder sem corpo (sim, em Kotlin isto é possível =D) tem anotação @Bean para registrá-lo no Jackson ObjectMapper.

Em Java, o método main( ) de um aplicativo é convencionalmente definido dentro da classe de aplicação anotada. Isso ocorre porque Java não suporta métodos de nível superior. Em Kotlin, no entanto, nós temos funções top-level. Assim, podemos tornar o principal ponto de entrada do SpringBoot muito mais simples. Com isto, a função main() é definida em uma classe chamada AppKt e não em uma classe App.

A função main() utiliza o método SpringApplication.run() do SpringBoot para iniciar um aplicativo.

O método run() retorna um ApplicationContext e este aplicativo, em seguida, recupera todos os beans que foram criados pela aplicação ou foram adicionados automaticamente graças ao SpringBoot. Note que o método run() recebe dois parâmetros: a classe App::class.java e um *args, que detalharei melhor a seguir:

  • App::class.java: (::) logo após o nome da classe indica que iremos pegar uma referência à classe por reflection. O (.java) indica que queremos uma referência Java e não Kotlin;
  • *args: * operador spread antes do array, insere todo o conteúdo do array no vararg do método run().

Vamos criar agora nossa configuração do Jersey. Crie uma arquivo kotlin com nome de JerseyConfig e configure o Jersey como a seguir:

Vamos aos detalhes:

  • JerseyConfig : ResourceConfig(): herança e implementação de interfaces em Kotlin;
  • init { … }: Bloco inicializador será criado junto com a instância da classe.

Para criar nossa endpoint, crie um pacote chamado api e dentro crie um arquivo kotlin com o nome de JerseyAPI. Veja o exemplo:[

Crie um arquivo chamado application.properties com o conteúdo abaixo dentro da pasta resources do projeto. Aqui diremos ao SpringBoot que o Undertow (WebServer) vai subir na porta configurada.

Execute com um duplo click a task bootRun, na visão de Gradle do IntelliJ IDEA.

Abra um navegador e digite o seguinte na barra de endereços :https://localhost:1010/jersey/ola?nome=Mundo

Veja o resultado:

E aí? Deu certo? Se tiver qualquer dúvida ou quiser dar alguma contribuição, fique à vontade nos comentários. Espero que tenha gostado! Até a próxima.

É desenvolvedor back-end e quer trabalhar com nosso time? Acesse aqui.