Slide 1

Slide 1 text

The Touch and Feel of Micronaut 2019/06/20 KanJava June, 2019 Mitsuyuki Shiiba (@bufferings) EC Incubation Development Dept. Rakuten, Inc.

Slide 2

Slide 2 text

@bufferings #kanjava It reminds me Spring Boot, so it was really easy for me to try. Micronaut @Controller public class Application { public static void main(String[] args) { Micronaut.run(Application.class); } @Get("/hello/{name}") public String hello(String name) { return "Hello " + name; } }

Slide 3

Slide 3 text

@bufferings #kanjava 1. Why Micronaut? 2. The Touch and Feel of Micronaut Today's topics

Slide 4

Slide 4 text

@bufferings #kanjava Mitsuyuki Shiiba (@bufferings) Web Application Engineer @Rakuten Osaka from 2010 Love: Java, Scrum, My wife & daughters

Slide 5

Slide 5 text

@bufferings #kanjava 1. Why Micronaut? 2. The Touch and Feel of Micronaut Today's topics

Slide 6

Slide 6 text

@bufferings #kanjava • Microservices • Containers • Kubernetes • Serverless Recent Tech Trends Photo by Ilze Lucero on Unsplash

Slide 7

Slide 7 text

@bufferings #kanjava • Faster startup time • Low memory footprint • Effective use of CPU It has become matter

Slide 8

Slide 8 text

@bufferings #kanjava 1. Multiple WARs on one application server 2. One server for one app with VMs 3. PaaS, 12 Factor App & Container 4. Embedded Tomcat & executable JAR by Spring Boot 5. Kubernetes & Microservices Java 10 years around me

Slide 9

Slide 9 text

@bufferings #kanjava • Microservices – Communications over network • Blocking – Waiting time • Want to – Utilize CPU • Thread is heavy (Context Switch, Memory) • Reactive – RxJava, Spring 5 (Reactor) Recent Java - Reactive

Slide 10

Slide 10 text

@bufferings #kanjava Currently we're doing a lot at Runtime. • Runtime Component Scan • Runtime DI & AOP It makes our app start slower & consume memory. Recent Java - Challenges

Slide 11

Slide 11 text

@bufferings #kanjava • Compile-time DI & AOP • No reflection • No runtime proxy Ahead of Time (AOT) Compilation

Slide 12

Slide 12 text

No content

Slide 13

Slide 13 text

@bufferings #kanjava • Microservices in mind from the beginning • Inspired by Spring & Grails • First class support for Reactive based on Netty • Ahead of Time Compilation • Support for Java, Kotlin, Groovy • Support for GraalVM Native Image https://micronaut.io/ Micronaut

Slide 14

Slide 14 text

@bufferings #kanjava • Java code to a standalone executable • This executable does not run on the Java VM • but includes necessary components from “Substrate VM” • The resulting program has faster startup time • and lower runtime memory overhead https://www.graalvm.org/docs/reference-manual/aot-compilation/ GraalVM Native Image (early adopter)

Slide 15

Slide 15 text

@bufferings #kanjava My thoughts: • AOT compilation & Native Image would be popular in a few years • Many frameworks would start supporting them including Spring • and just I like Micronaut My Motivation

Slide 16

Slide 16 text

@bufferings #kanjava 1. Why Micronaut? 2. The Touch and Feel of Micronaut Today's topics

Slide 17

Slide 17 text

@bufferings #kanjava With Micronaut 1.2.0.RC1 • Micronaut CLI • HTTP Server • Integration Test Demo Code: https://github.com/bufferings/kanjava1906 Demo 1

Slide 18

Slide 18 text

@bufferings #kanjava Micronaut CLI # Create Application $ mn create-app demo # Interactive Mode $ mn | Starting interactive mode... | Enter a command name to run. Use TAB for completion: mn> create-controller hello

Slide 19

Slide 19 text

@bufferings #kanjava HTTP Server @Controller("/hello") public class HelloController { @Get("/{name}") public String index(String name) { return "Hello " + name; } }

Slide 20

Slide 20 text

@bufferings #kanjava Integration Test @Inject @Client("/") RxHttpClient client; @Test public void testIndex() throws Exception { assertEquals("Hello World", client.toBlocking().retrieve("/hello/World")); }

Slide 21

Slide 21 text

@bufferings #kanjava • HTTP Server (Reactive) • Valiadation (AOP) • DI Demo 2

Slide 22

Slide 22 text

@bufferings #kanjava HTTP Server (Reactive) @Controller("/hello") public class HelloController { @Get("/{name}") public Single index(String name) { return Single.just("Hello " + name); } }

Slide 23

Slide 23 text

@bufferings #kanjava Validation (AOP) @Controller("/hello") public class HelloController { @Get("/{name}") public Single index(@Size(min = 10) String name) { return Single.just("Hello " + name); } } "message": "name: size must be between 10 and 2147483647"

Slide 24

Slide 24 text

@bufferings #kanjava DI – Bean Definition @Singleton public class GreetingService { public String greeting(String name) { return "Hello " + name; } }

Slide 25

Slide 25 text

@bufferings #kanjava DI – Constructor Injection @Controller("/hello") public class HelloController { private final GreetingService greetingService; HelloController(GreetingService greetingService) { this.greetingService = greetingService; }

Slide 26

Slide 26 text

@bufferings #kanjava • Postgres Reactive • Declarative HTTP Client • Use Declarative HTTP Client for test Demo 3

Slide 27

Slide 27 text

@bufferings #kanjava Postgres Reactive public Single getScreenName(String name) { return client.rxPreparedQuery( "SELECT screen_name FROM speakers WHERE name=$1", Tuple.of(name) ).map(rows -> { PgIterator it = rows.iterator(); if (!it.hasNext()) return name; return it.next().getString("screen_name"); }); }

Slide 28

Slide 28 text

@bufferings #kanjava Declarative HTTP Client @Client("http://localhost:8081/") public interface ScreenNameClient { @Get("{name}") Single getScreenName(String name); }

Slide 29

Slide 29 text

@bufferings #kanjava Use Declarative HTTP Client for test @Inject HelloClient client; @Test public void testHello() { assertEquals("Hello World", client.hello("World")); }

Slide 30

Slide 30 text

@bufferings #kanjava Compare Blocking & Reactive Controller Demo 4

Slide 31

Slide 31 text

@bufferings #kanjava GraalVM Native Image https://github.com/bufferings/micronaut-petclinic Demo 5

Slide 32

Slide 32 text

@bufferings #kanjava Microservices in mind • HTTP Server, HTTP Client, Reactive based on Netty Fast startup & low memory footprint • DI & AOP with AOT Compilation GraalVM Native Image Support • makes our app start in a few hundreds of milliseconds Summary

Slide 33

Slide 33 text

@bufferings #kanjava Introduction to Micronaut: Lightweight Microservices with Ahead of Time Compilation by Graeme Rocher https://youtu.be/P1qp_l5EFic Micronaut | Technology Radar | ThoughtWorks https://www.thoughtworks.com/radar/languages-and- frameworks/micronaut References