Kotlin Spring WebFlux Annotation-Based RestAPIs - with SpringBoot 2

Reactive programming is about non-blocking applications. And Spring Framework 5 includes a new spring-webflux module, supports Reactive Streams for communicating backpressure across async components and libraries. So in the tutorial, JavaSampleApproach will guide you through the steps for creating a Kotlin Spring WebFlux Annotation-Based RestAPIs with SpringBoot 2.

Contents

I. Technologies
II. Spring WebFlux
III. Practice
IV. Sourcecode

I. Technologies

– Java: 1.8
– Maven: 3.5.2
– Spring Tool Suite: Version 3.9.0.RELEASE
– Spring Boot: 2.0.0.M7
– Kotlin 1.1.61
– Spring Boot Starter Webflux
– Postman client

II. Spring WebFlux

Spring Framework 5.0 supports WebFlux with fully asynchronous and non-blocking and does NOT require the Servlet API(Unlike Spring MVC).

Spring WebFlux supports 2 distinct programming models:
– Annotation-based with @RestController
– Functional with Java 8 lambda style

In the tutorial, we will introduce WebFlux with Annotation-based and Kotlin language.
For starting with WebFlux, SpringBoot supports a collection dependency: spring-boot-starter-webflux.

Kotlin sample code:

import reactor.core.publisher.Flux;

import reactor.core.publisher.Mono;

@RestController

@RequestMapping(value="/api/customer")

class RestControllerAPIs {

@GetMapping

fun getAll(): Flux<Customer> {

return Flux.fromIterable(ArrayList(custStores.values));

}

@GetMapping("/{id}")

fun getCustomer(@PathVariable id: Long): Mono<Customer> {

return Mono.justOrEmpty(custStores.get(id))

}

...

}

– reactor.core.publisher.Flux: is a standard Publisher representing a reactive sequence of 0..N items, optionally terminated by either a success signal or an error.
– reactor.core.publisher.Mono: Mono is a specialized Publisher that emits at most single-valued-or-empty result.

III. Practice

In the tutorial, We create a Kotlin SpringBoot 2 project as below:

Kotlin Spring WebFlux AnnotationBased RestAPIs - project structure

Step to do:
– Create Kotlin SpringBoot project
– Create data models
– Implement Spring WebFlux APIs
– Run and check results

1. Create Kotlin SpringBoot project

Using SpringToolSuite, create a Kotlin SpringBoot 2 project with Reactive Web dependency spring-boot-starter-webflux:

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

</parent>

<kotlin.compiler.incremental>true</kotlin.compiler.incremental>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

<java.version>1.8</java.version>

</properties>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-webflux</artifactId>

</dependency>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-stdlib-jre8</artifactId>

</dependency>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-reflect</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<groupId>io.projectreactor</groupId>

<artifactId>reactor-test</artifactId>

</dependency>

</dependencies>

<build>

<sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>

<testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

<artifactId>kotlin-maven-plugin</artifactId>

<groupId>org.jetbrains.kotlin</groupId>

<plugin>spring</plugin>

</compilerPlugins>

</configuration>

<groupId>org.jetbrains.kotlin</groupId>

<artifactId>kotlin-maven-allopen</artifactId>

<version>${kotlin.version}</version>

</dependency>

</dependencies>

</plugin>

</plugins>

</build>

<id>spring-snapshots</id>

<name>Spring Snapshots</name>

<url>https://repo.spring.io/snapshot</url>

</snapshots>

</repository>

<id>spring-milestones</id>

<name>Spring Milestones</name>

<url>https://repo.spring.io/milestone</url>

<enabled>false</enabled>

</snapshots>

</repository>

</repositories>

<id>spring-snapshots</id>

<name>Spring Snapshots</name>

<url>https://repo.spring.io/snapshot</url>

</snapshots>

</pluginRepository>

<id>spring-milestones</id>

<name>Spring Milestones</name>

<url>https://repo.spring.io/milestone</url>

<enabled>false</enabled>

</snapshots>

</pluginRepository>

</pluginRepositories>

2. Create data models

– Create Address data model:

package com.javasampleapproach.webflux.model

data class Address(

var street : String? = null,

var postcode : String? = null

){}

– Create Customer data model:

package com.javasampleapproach.webflux.model

data class Customer(

var id: Long = -1,

var firstName: String? = null,

var lastName: String? = null,

var age: Int? = null,

var address: Address = Address()) {

}

3. Implement Spring WebFlux APIs

package com.javasampleapproach.webflux.controller

import javax.annotation.PostConstruct

import org.slf4j.Logger

import org.slf4j.LoggerFactory

import org.springframework.http.HttpStatus

import org.springframework.http.ResponseEntity

import org.springframework.web.bind.annotation.DeleteMapping

import org.springframework.web.bind.annotation.GetMapping

import org.springframework.web.bind.annotation.PathVariable

import org.springframework.web.bind.annotation.PostMapping

import org.springframework.web.bind.annotation.PutMapping

import org.springframework.web.bind.annotation.RequestBody

import org.springframework.web.bind.annotation.RequestMapping

import org.springframework.web.bind.annotation.RestController

import com.javasampleapproach.webflux.model.Customer

import com.javasampleapproach.webflux.model.Address

import reactor.core.publisher.Flux;

import reactor.core.publisher.Mono;

@RestController

@RequestMapping(value="/api/customer")

class RestControllerAPIs {

val log = LoggerFactory.getLogger(RestControllerAPIs::class.java);

// Define customer storage

val custStores = mutableMapOf<Long, Customer>()

@PostConstruct

fun initial(){

custStores.put(1, Customer(1, "Jack", "Smith", 20, Address("NANTERRE CT", "77471")))

custStores.put(2, Customer(2, "Peter", "Johnson", 25, Address("W NORMA ST", "77009")))

}

@GetMapping

fun getAll(): Flux<Customer> {

return Flux.fromIterable(ArrayList(custStores.values));

}

@GetMapping("/{id}")

fun getCustomer(@PathVariable id: Long): Mono<Customer> {

return Mono.justOrEmpty(custStores.get(id))

}

@PostMapping("/post")

fun postCustomer(@RequestBody customer: Customer): Mono<ResponseEntity<String>>{

// do post

custStores.put(customer.id, customer)

log.info("########### POST:" + customer)

return Mono.just(ResponseEntity("Post Successfully!", HttpStatus.CREATED))

}

@PutMapping("/put/{id}")

fun putCustomer(@PathVariable id: Long, @RequestBody customer: Customer): Mono<ResponseEntity<Customer>>{

// reset customer.Id

customer.id = id;

if(custStores.get(id) != null){

custStores.replace(id, customer)

}else{

customer.id = id

custStores.put(id, customer)

}

log.info("########### PUT:" + customer)

return Mono.just(ResponseEntity(customer, HttpStatus.CREATED))

}

@DeleteMapping("/delete/{id}")

fun deleteCustomer(@PathVariable id: Long): Mono<ResponseEntity<String>> {

val cust = custStores.remove(id)

if(cust != null){

log.info("########### DELETE:" + cust)

}else{

log.info("########### Don't exist any customer with id = ${id}")

}

return Mono.just(ResponseEntity("Delete Succesfully!", HttpStatus.ACCEPTED))

}

4. Run and check results

Run the Kotlin SpringBoot project with commandline: mvn spring-boot:run

-> See console’ logs:

s.w.r.r.m.a.RequestMappingHandlerMapping : Mapped "{[/api/customer],methods=[GET]}" onto public reactor.core.publisher.Flux<com.javasampleapproach.webflux.model.Customer> com.javasampleapproach.webflux.controller.RestControllerAPIs.getAll()

s.w.r.r.m.a.RequestMappingHandlerMapping : Mapped "{[/api/customer/delete/{id}],methods=[DELETE]}" onto public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<java.lang.String>> com.javasampleapproach.webflux.controller.RestControllerAPIs.deleteCustomer(long)

s.w.r.r.m.a.RequestMappingHandlerMapping : Mapped "{[/api/customer/{id}],methods=[GET]}" onto public reactor.core.publisher.Mono<com.javasampleapproach.webflux.model.Customer> com.javasampleapproach.webflux.controller.RestControllerAPIs.getCustomer(long)

s.w.r.r.m.a.RequestMappingHandlerMapping : Mapped "{[/api/customer/post],methods=[POST]}" onto public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<java.lang.String>> com.javasampleapproach.webflux.controller.RestControllerAPIs.postCustomer(com.javasampleapproach.webflux.model.Customer)

s.w.r.r.m.a.RequestMappingHandlerMapping : Mapped "{[/api/customer/put/{id}],methods=[PUT]}" onto public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<com.javasampleapproach.webflux.model.Customer>> com.javasampleapproach.webflux.controller.RestControllerAPIs.putCustomer(long,com.javasampleapproach.webflux.model.Customer)

– Make a GET all customer request: http://localhost:8080/api/customer

Kotlin Spring WebFlux AnnotationBased RestAPIs - get all customers

– Make a GET customer request: http://localhost:8080/api/customer/1

Kotlin Spring WebFlux AnnotationBased RestAPIs - get a customer

– Make a POST request: http://localhost:8080/api/customer/post

Kotlin Spring WebFlux AnnotationBased RestAPIs - post a customer

– Make a PUT request: http://localhost:8080/api/customer/put/3

Kotlin Spring WebFlux AnnotationBased RestAPIs - put a customer

– Make a DELETE request: http://localhost:8080/api/customer/delete/1

Kotlin Spring WebFlux AnnotationBased RestAPIs - delete a customer

– Make a GET all customers request again: http://localhost:8080/api/customer

Kotlin Spring WebFlux AnnotationBased RestAPIs - get all customers

-> Logs from Kotlin SpringBoot server:

c.j.w.controller.RestControllerAPIs : ########### POST:Customer(id=3, firstName=Mary, lastName=Taylor, age=27, address=Address(street=S NUGENT AVE, postcode=77571))

c.j.w.controller.RestControllerAPIs : ########### PUT:Customer(id=3, firstName=Amy, lastName=Taylor, age=24, address=Address(street=E NAVAHO TRL, postcode=77449))

c.j.w.controller.RestControllerAPIs : ########### DELETE:Customer(id=1, firstName=Jack, lastName=Smith, age=20, address=Address(street=NANTERRE CT, postcode=77471))

IV. Sourcecode

SpringBootKotlinWebFluxAnnotationBased

By grokonez | December 10, 2017.

Kotlin Spring WebFlux Annotation-Based RestAPIs – with SpringBoot 2

I. Technologies

II. Spring WebFlux

III. Practice

1. Create Kotlin SpringBoot project

2. Create data models

3. Implement Spring WebFlux APIs

4. Run and check results

IV. Sourcecode

Post Tags

Got Something To Say: Cancel reply

I. Technologies

II. Spring WebFlux

III. Practice

1. Create Kotlin SpringBoot project

2. Create data models

3. Implement Spring WebFlux APIs

4. Run and check results

IV. Sourcecode

Related Posts

Post Tags

Got Something To Say: Cancel reply