Schlank in den Service: Der große Java-Microframework-Test!

Schlank in den Service:
Der große Java-
Microframework-Test!

2018-03-13

@bentolor

? for help

Schlank in den Service: Der große Java-Microframework-Test! by Benjamin Schmid is licensed under a Creative Commons License (BY-NC-SA/4.0) .

* Freue mich heute hier, in diesem stilvolle Ambiente sein zu dürfen * **Java Plattform** * Beeindruckende Plattform * **wahnsinnig viele**, attraktive & leistungsfähige Tools, Frameworks & freie Lösungen * *Lange Historie* führt teils auch zu vielen **Verwachsungen**, Bloat, Schwerfälligkeiten * Kennt z.B. jemand die [FizzBuzz Enterprise Edition](http://www.fizzbuzz.enterprises/)? * _ made by serious businessmen for serious business_ * %3==0: Fizz, %5=0: Buzz in 89 Java Klassen und 3,8kLOC * Trend weg vom Monolithen zu **kleineren, besser managebaren Einheiten** * Gelingt das auch unter Java? * Das wollen wir herausfinden und in dieser Session ein paar Inspirationen sammeln

http://microjs.com/

Microservice Architektur

Entscheidend: Geringe Komplexität/Aufwand sowie geringe Größe

Java Microframeworks:

„Elegante, flexible auf ein Thema fokussierte Rahmenwerke für eine Problemstellung (in der Regel Webanwendungen) mit dem Ziel einer schlankere Source- und/oder Bytecode-Linie“

Die Kandidaten

* Als Vergleichsgrundlage dient uns eine kleine Anwendung zur Verwaltung von Einkaufslisten. * Wir wollen Einkaufslisten anlegen können und online darauf jederzeit Einkaufspositionen **anlegen, lesen, verändern oder wieder löschen** können. * Sprich: In unserem Beispiel geht es um eine **klassische CRUD Anwendung**. --- Wie wir die einzelnen Teile effizient realisieren, lernen wir im Verlauf unserer Reise durch die Kandidaten --- Ganz im Sinne eines Microframeworks soll unsere Anwendung dem RESTful Pattern folgen. Im ersten Schritt geht es also darum, **die CRUD Operationen auf HTTP-Routen zu mappen**. Sprich ganz klassisch wird Anlegen zu einem HTTP `POST`, lesen zu einem `GET`, Update zu `PUT` usw.

Eleganter Zündfunken

Datenblatt

Sinatra-inspiriert
Minimaler Boilerplate
Ausdrucksstärke
Standalone (Jetty 9)

Java 8 & Kotlin

zusätzliche Spark-DSL unter Kotlin

2.7.1 (Nov. 2017), APL2
Start: ~Feb. 2013
http://sparkjava.com/

1. Beginne mit einem leeren Projekt Arbeiten mit _Gradle_, legen dazu ein neues Gradle Buildfile an. 2. Da wir **Standalone** Arbeiten wollen → `application` Plugin, Definieren die Einstiegsklasse, holen uns als einige Dependency `spark-core` … und beginnen mit unsere Anwendung --- 1. Spark = **Deklarativ.** Sprich wir definieren Routen * Also Pfad, welche Inhalte wir darüber ausliefern und einen Handler der die Route bedient. * Für etwas mehr Spass auch ein Beispiel mit URL Parameter 2. Wir bauen & starten. **Das entspricht einem einfachen Start der `main`-Methode!** … und testen unseren Microservice. Fertig! **Sehr elegant & Prägnant**. Kein Boiler-Code. Server **startet implizit.** Belange kann man optional **konfigurieren** (Port, SSL, …). **Ich denke das Beispiel spricht für sich!**

Quick-Start #1 `build.gradle`

apply plugin: 'java'
apply plugin: 'application'

repositories {
    jcenter()
}

dependencies {
    mainClassName = 'bentolor.HelloSpark'
    compile         'com.sparkjava:spark-core:2.5'
}

Quick-Start #2 `build.gradle`

package bentolor.sparkjava;

import static spark.Spark.*;

public class HelloWorld {

    public static void main(String[] args) {
        get("/hello", "text/plain", (req, res) -> "Hello World!");

        get("/greet/:name", "text/plain",
            (req, res) -> "Hello "+req.params("name")+"!");
    }

}

## Kern-Konzepte 1. *DSL* zur Definition von *Routen* `methode(pfad, type, callback)` 2. zusätzlich: Filter & Transformer 3. optional: Template Engine Support *That's it!*

## Templating ```java get("/greet/:name", "text/html", (req, res) -> { String name = req.params("name"); Map<String, String> values = new HashMap<>(); values.put("name", name != null ? name : "Anon"); return new JadeTemplateEngine().render( new ModelAndView(values, "greet") ); }); ``` ##### z.B. mit Jade4j Template `greet.jade` ``` doctype html html body h1 Welcome to my Microservice p Dear #{name}, welcome to my web-based Microservice endpoint ``` Alternativ: Velocity, Freemarker, Mustache, Handlebars, Thymeleaf & 5 weitere …

Foo bar. * Verschiedene Templating-Extensions binden dritte Template Engines ein und machen diese für Antworten verfügbar * **Entweder:** man übergibt an der Route einen Transformer mit, der die Rückhabe des Callbacks passend rendert * **Oder:** wir machen es wie hier und geben direkt den gerenderten Inhalt zurück * Das `ModelAndView`-Objekt enthält die in das einzusetzende Daten und den Namen des anzuwendenden Templates --- Im Beispiel sehen wir z.B: die Jade4j Templating Engine die besonders kompakte Notation für HTML Inhalte erlaubt. Im Beispiel wird am Platzhalter der Wert für `name` eingesetzt. Andere Engine wie Freemarker & Co. bieten natürlich deutlich mehr Logik.

Spark Java

Elegant & Minimalistisch
Sinatra-inspiriert. Deklarativ.

Strukturierung: Routen, Filter, Transformer,
optional Template Engines – That's it!

Jetty 9, slf4j

Sehr schnell erste Ergebnisse.
Macht Spaß in der Verwendung!

Minimalismus bedeutet aber auch:
Zergliederung, Fehlerbehandlung Antwortseiten in Entwicklerverantwortung

Dokumentation könnte umfassender & gründlicher sein. Code aber gut verständlich & debugbar

2,7

4,9

* Das erste Microframework haben wir schon kennengelernt. Nun geht es an die Bewertung. * **Vorstellung Scoresheet:** * _Bossability, Micro, Fun_ * Performance: Gesamtbytecode meiner Referenz-Lösung als Single-JAR & Durchsatz (ungetuned) --- * Wie Sinatra: **DSL für Routen** das zentrale Strukturierungsmittel * Über Routen werden HTTP-Anfragen auf Callbacks umgeleitet. * Diese verarbeiten und beantworten die Requests * Ansonsten nur noch Filter, Transformer: Fertig! --> Elegant & Minimalistisch * sinnvolle _Zergliederung der Logik,_ _Fehlerbehandlung_ oder die Art um die Antwortseiten zu erzeugen, überlässt Spark vollständig dem Entwickler (optional Templating Engines) * Doku ist "okay". Code aber gut überschaubar.

### Model: POJOs mit Lombok ```java /** A shopping list for groceries. */ @Data @NoArgsConstructor @AllArgsConstructor public class GroceryList implements ModelElement { private UUID id; private LocalDate date; private String comment; private boolean settled; private Item[] shoppingItems; } ```

#### ... oder mit Kotlin ```kotlin data class GroceryList(val id: UUID, var date: LocalDate, var comment: String?, var isSettled: Boolean, var shoppingItems: List<Item>) ```

Spion mit Konventionen

Datenblatt

CoC
MVC
Stateless

Full-Stack

Hibernate, Guice, Jackson,
Flyway, Ehcache, …

Nicht wirklich „Micro“

6.2.2 (Jan. 2018), APL2
Start: Juli 2012
http://www.ninjaframework.org/

Convention-over-Configuration (CoC)

##### Fixe Paket/Ordnerstruktur & MVC Pattern * *Models:* Im Paket `model` * *Routendefinitionen:* In Klasse `conf.Routes` * *Controller:* Im Paket `controller` * *Views (MVC):* Freemarker-Template `views/CONTROLLER/METHOD.ftl.html` ##### Konfiguration * *Applikation:* `conf/application.conf` * *Guice:* `conf/Module.java` * *I18N:* `conf/messages_XX.properties`

##### Binding * *Dependencies:* Guice CDI. * *Input Parsing:* via `Content-Type` * *Bean Validation:* Automatisch bei passenden Controller-Methodensignaturen ##### Persistenz * *ORM:* JPA und Guice Persist * *Change Management:* mittels Flyway * *I18N:* `conf/messages_XX.properties`

## Ninja – Controller ```java package controllers; @Singleton public class GroceryListController { @Inject private Repository repository; public Result index() { return html(); } public Result createGroceryList(GroceryList newList) { return ok().render(repository.createList(newList)); } public Result getGroceryList(@PathParam("id") String id) { Optional<GroceryList> match = repository.getList(id); return match.isPresent() ? json().render(match.get()); : notFound().render(new Message(id + " not found")); } ```

← Immer: controllers

← Guice Dependency Injection

← Immer: Result
← /GroceryListController/index.ftl.html

← Request Body
geparsed via Content-Type

← URL Parameter

← Utility Methoden für Result

## Kern-Konzepte
 * Convention over Configuration (CoC)
 * Model–View–Controller (MVC)
 * Client-Side Sessions, Stateless Server
 → einfache Skalierbarkeit

NOTE:
                    Die Reichweiter der Konventionen haben wir gesehen, ebenfalls wie konsequent der MVC-Ansatz
                    umgesetzt ist.

---
                    Ninja ist **serverseitige Zustandslos!** D.h. keine Mittel für Server-seitige Session.
                    Stattdessen alle Zustandsinformationen als Cookie (auch verschlüsselt) auf dem Client
                    (max 64kb).

Nachteil: Session kann nur sehr kleine Datenmengen speichern.

Vorteil: Ninja-Applikationen inhärent horizontal skalierbar. Einfach weitere Server
                    hinter dem Loadbalancer aufstellen genügt!

##### Kombination bewährter Technologien

* Backend: Servlets, Guice, JPA, Flyway, …
 * Frontend: Freemarker (HTML)
 / Jackson (XML, Jason)

Ninja

Full Stack & MVC
Umfassende Konventionen
Play!-inspired Client-side Session

daher einfache Skalierbarkeit

Jetty 9, Guice, Guava, Logback, Jackson,
Woodstox, 6x commons-*, joda-time, ehcache,
memcached, flyway, freemarker, hibernate, prettytime, slf4j

Sehr umfassend.
Kombiniert viele etablierte Frameworks.

Architektur sehr stark vorgegeben. Wenig Flexibilität / Modularität

Umgehen von Detailproblemen durch monolithischen Ansatz teils schwer

Von Verbreitung eher Nische gegenüber Dropwizard/Spring Boot/Play!

4,8

127

Ninja ist ganz klar ein Full-Stack Framework das mit viel Konventionen versucht Kürze im Sourcecode zu gewinnnen, mit 25MB aber nicht unbedingt eine zu schlanke Bytecodelinie hat. Interessant ist der _Share-nothing_ Ansatz der zur leichten Skalierbarkeit zwingt. Die Bestandteile sind alles solide Technologien. * Von Verbreitung her Nische, daher geringe Bossability. Schwer gegenüber Platzhirschen zu vertreten. * Nochmals verstärkt durch großen Umfang und mangelnde Flexiblität. Der Aufbau und die Mittel sind stark vorgegeben und engen ein ("strongly opinionated"). Das macht das Ausbrechen schwer. Das machen viele andere besser. * _Ausreißer Antwortzeiten!_ (1,1s Ausreiser. verm. GC).

GUI in 64 Zeilen mit ng-admin : https://github.com/marmelab/ng-admin

ng-admin (1)


var myApp = angular.module('myApp', ['ng-admin']);
myApp.config(['NgAdminConfigurationProvider',
                function (NgAdminConfigurationProvider) {

    var nga = NgAdminConfigurationProvider;
    var admin = nga.application('My Grocery Lists');

    var configureFields = function (view) {
        return view.fields([
            nga.field('id').editable(false),
            nga.field('comment'),
            nga.field('settled', 'boolean'),
            nga.field('date', 'date'),
            nga.field('shoppingItems', 'embedded_list')
                .targetFields([
                    nga.field('quantity', 'number'),
                    nga.field('unit', 'choice').choices([
                        {value: 'pcs', label: 'pieces'},
                        {value: 'kg', label: 'kilogram'},
                        {value: 'g', label: 'gram'},
                        {value: 'l', label: 'litre'}
                    ]),
                    nga.field('name', 'string')
                ])
        ]);
    };

ng-admin (2)


    // lists entity
    var list = nga.entity('list');

    list.listView()
        .fields([
            nga.field('comment'),
            nga.field('settled', 'boolean'),
            nga.field('date', 'date')])
        .listActions(['show', 'edit', 'delete'])
        .title("My shopping lists");

    configureFields(list.editionView())
        .title('Edit "{{ entry.values.comment }}"')
        .actions(['show', 'list', 'delete']);
    configureFields(list.showView())
        .title('View "{{ entry.values.comment }}"');
    configureFields(list.creationView());

    admin.addEntity(list);

    nga.configure(admin);
}]);

Floppytaugliches Baukastensystem

Datenblatt

Komplettes
Baukastensystem

an Microframeworks & Tools !

IoC, AOP,
Bean-Validation,
SQL/OR-Mapper,
HTML Parser, …

Einzeln einbindbar
Alles zusammen: 1,7MB

4.2.0 (März 2018), APL2
Start: 2009
https://jodd.org/

Jodd Komponenten (Auszug)

Jodd components
Und noch einiges mehr in nur 1,7MB!
(Validierung, HTTP, Utils, CSS, …)

### Jodd – Madvoc: Controller ```java @MadvocAction public class ListAction { @In @Scope(ScopeType.SERVLET) HttpServletRequest request; @RestAction("/list/{id}") @GET public GroceryList getList(@In("id") String id) { return GroceryService.get().getGroceryList(id); } … } ``` * Injection von Parametern und Servlet-Werten via `jodd-petite` IoC * Automatische Konvertierung/Serialisierung via `jodd-json` * `Action` optional – dann URL-Pfade via Konventionen

### Jodd – Limitationen in der Praxis *Problem:* JSON Serialisierung/Deserialisierung weitestgehend fix.
Format unserer `LocalDate` Instanzen nicht passend. *Workaround:* (De-)Serialisierung selbst in die Hand nehmen: ```java @Action("/list") @POST public MyJsonResult createList(@In @Scope(SERVLET) String jsonString) { return GroceryService.get().createGroceryList(jsonString)); } ``` ```java @RenderWith(MyJsonResultRenderer.class) public class JsonResult { private final Object model; private final int status; … ```

Jodd (Madvoc)

Ausgeprägt
Leichtgewichtig / Modular / KISS

Trotz 1,7MB weit mehr als nur Web-Framework. Geringe Verbreitung.

nichts!

Große Breite
bei geringer Größe & Einfachheit.

Microframework at it's best!

Öfters Breaking changes. Engagierter Maintainer – aktuell aber in der Sinnkrise

In komplexeren Fällen ggf. Rückgriff auf umfassendere Lösungen notwendig

4,9

4,9

Reaktiver Entertainer

Datenblatt

Reaktiv, Asynchron
Event-basiert,
stark typisiert

hohe Ähnlichkeit mit Vert.X

Basis:
Java 8, Netty & Promises

Zahlreiche Module:
Guice, Groovy, Jackson, Redis, Hystrix, Templating

1.5.3 (März 2018), APL2
Start: 2012
https://ratpack.io/

**Hohe Skalierbarkeit** und vereinfachte Entwicklung der **Event-basierenden Programmierung asynchroner Anwendungen** gehören zu den primären Design-Zielen von Ratpack. Dazu will Ratpack ganz im Sinne eines Microframework weder eine komplette Full-Stack Lösung sein und **keine unnötige Annahmen** bezüglich der sonstigen Tools & Bibliotheken treffen. **Zahlreiche Zusatzmodule bieten optionale Integrationen** z.B. für Guice, Groovy, Jackson oder Spring Boot. Das Java 8-basierte Microframework setzt auf die NIO Client-Bibliothek Netty für die asynchrone Verarbeitung der HTTP-Requests.

### Ratpack – Asynchrone Verarbeitung
 _Handler_ können (asynchron) Requests beantworten 
 oder an bestehende bzw. ad-hoc erzeugte Handler delegieren

_Jede Anfrage wird letztlich durch eine Kette von Handlern verarbeitet._

```java
                    // Unser Handler für POST /list
                    public void createGroceryList(Context ctx) {
                        // Asynchron auf Parsen warten: Rückgabe = Promise
                        ctx.parse(GroceryList.class).then(newList -> {
                            ctx.render(json(repository.createList(newList)));
                        });
                    }
                    ```

Für die Asynchronität verarbeitet und liefert Ratpack _Promises_

NOTE:
                    Handler stellen das zentrale Konstrukt zum Verarbeiten von HTTP-Anfragen
                    in Ratpack dar. Jeder Handler kann entweder den Request beantworten,
                    ihn an den nächsten Handler weitergeben oder ad hoc neue in die
                    Verarbeitungskette einfügen und sofort an diese delegieren.

**Jede Anfrage wird letztlich also nur durch eine Kette von Handlern verarbeitet.**

Für die asynchrone Verarbeitung setzt Ratpack auf Promises.

Der Handler für das Anlegen muss erst einmal darauf warten,
                    dass die Daten vollständig angekommen sind. Daher erhält der
                    Handler also nicht das konkrete GroceryList-Objekt, sondern
                    nur ein Promis als Platzhalter.

**Aber:** Das hier ist nur ein einfaches Beispiel!

Das geht schon z.B. los beim Anlegen/Konfigurieren der Routen…

### Ratpack – Handler Factory (statische Routen) ```java public static void main(String... args) throws Exception { ObjectMapper objectMapper = ModelSerializer.buildConfiguredObjectMapper(); GroceryService service = new GroceryService(); RatpackServer.start(server -> server .serverConfig(configBldr -> configBldr.baseDir(BaseDir.find()).development(true).port(8080)) .registryOf(r -> r.add(objectMapper)) .handlers(chain -> chain // 1. URL: /list .prefix("list", nested -> { nested.path(ctx -> ctx.byMethod(method -> { // 2. POST ---> Delegation an unseren vorherigen Handler! --- method.post(() -> service.createGroceryList(ctx)); method.get(() -> service.getAllGroceryLists(ctx)); })); nested.path(":id", ctx -> ctx.byMethod(method -> { method.put(() -> service.updateGroceryList(ctx)); method.get(() -> service.getGroceryList(ctx)); method.delete(() -> service.deleteGroceryList(ctx)); })); }) .files(f -> f.indexFiles("index.html")) ) ); } ``` **Verschachtelte Entscheidungslogik:** Recht verwirrend und wenig intuitiv.

### Ratpack – dynamisches Re-routing

Zur Laufzeit dynamische Delegation an andere Handler 
 z.B. basierend auf der Request-URL
 ```java
 public class Router implements Handler {
 private final Handler fooHandler = new FooHandler();
 private final Handler barHandler = new BarHandler();

public void handle(Context context) {
                        String path = context.getRequest().getPath();
                        if (path.equals("foo")) {
                          context.insert(fooHandler);
                        } else if (path.equals("bar")) {
                          context.insert(barHandler);
                        } else {
                          context.next();
                        }
                      }
                    }
                    ```

NOTE:
                    Hier sieht man ein Biespiel, wie zur Requestverarbeitung dynamisch
                    weitere Handler in die Verarbeitungskette injiziert werden.

Es war vorhin schon schwer zu verstehen.
                    … Und nun auch noch hierbei noch den Überblick zu behalten

**Man merkt: Ich bin kein großer Freund dieses Ansatzes**

Ratpack

Asynchron
non-blocking
reaktiv

Netty, Jackson, Javassist, SnakeYaml, slf4j

Interessanter Ansatz & Konzept

Problematisch: viele Lücken in der Dokumentation

Asynchronen Programmierung in Kombination mit vielen Lambda-Ausdrücke begrenzt intuitiv.

Komplexität vs. Gewinn?

9,5

4,5

Start für den Platzhirsch

Datenblatt

CoC für Spring
= Full-stack
Auswahl an „Starters"
Maven-zentrisch

Ziele
Möglichst viel Autokonfiguration
Standalone Apps
„Opinionated“ Vorlagen

Hier gewählt
Spring 5 mit WebFlux (reaktiv)

2.0.0 (März 2018), APL2
https://projects.spring.io/

### Spring Boot 2 – Spring 5 – WebFlux

```java
                    @RestController
                    @RequestMapping(produces = MediaType.APPLICATION_JSON_VALUE)
                    public class GroceryListController {

@GetMapping(path = "/list")
 Flux<GroceryList> listStream() {
 return repository.getLists();
 }

@PutMapping(value = "/list/{id}",
 consumes = MediaType.APPLICATION_JSON_VALUE)
 public Mono<GroceryList> updateList(
 @PathVariable(value = "id") UUID id,
 @RequestBody GroceryList updatedList) {
 return repository.updateList(id, updatedList);
 }

…
                    ```

NOTE:
                    * API sehr **nahe am alten Spring MVC**.
                    *  Dabei sind`Flux` & `Mono` = Reactive Streams Implementierung _Reactor_
                    * Mit `@RestController`, welche ein Alias für Spring Web Annotation `Controller`
                    und `ResponseBody` ist, markieren wir die Klasse für die Autoerkennung.
                    * `produces` erklärt, dass wir JSON-Werte zurückgeben möchten. **In echtem
                    reaktiver Manier würden wir hier eher einen Stream zurückgeben wollen!**
                    * Der Rest sehr analog anderen Controller-basierten Ansätzen die wir bereits gesehen haben.

---
                    * Haben heute schon elegantere APIs gesehen; Altlasten aus Spring MVC
                    * Prägnanz fehlt, wir z.B. das zusätzlich notwendige `consumes`

### WebFlux – `index.html` als `/` ausliefern

Ohne Google kann einfaches auch kompliziert sein.

```java
 /**
 * Dirty hack to redirect / to /index.html.
 * @see https://github.com/spring-projects/spring-boot/issues/9785
 */
 @Component
 public class RedirectToIndexHtmlWebFilter implements WebFilter {
 public Mono<Void> filter(ServerWebExchange exchg, WebFilterChain chain) {
 if (exchg.getRequest().getURI().getPath().equals("/")) {
 return chain.filter(exchg.mutate().request(
 exchg.getRequest().mutate().path("/index.html").build()
 ).build());
 }
 return chain.filter(exchg);
 }
 }
 ```

NOTE:
                    Die Aufgabe war einfach: Wir möchten einfach '/' auf '/index.html' umrouten.
                    Ohne Stackoverflow und Google habe ich das allerdings nicht hinbekommen.

Das Beispiel belegt, **das Spring Boot viel Komplexität hinter einfacher
                    Oberfläche versteckt, aber bereits einfachste "Sonderfälle" schnell extremes
                    Expertenwissen erforderlich machen.**

**Etwas, was in echten Microframeworks nicht notwendig ist**, da dort die
                    Lösung in der Regel einfach und komplett überschaubar ist.

Spring Boot

Mainstream. Full-stack.

Kein "Micro" – eher ganze Landschaft

Spring Boot, Spring Web/Beans/Core/JCL,
WebFlux, Reactor/ReactiveStreams, Netty
Hibernate Validator, slf4j, SnakeYaml, Logback, Jackson

Viel Automagie.
Hohe Komplexität & Lernkurve

Detailanforderungen können schnell Expertenwissen erfordern

Höchstes Niveau an
Support & Verbreitung

Umfangreiche Dokumentation

4,1

149

* Spring Boot – sei der initiale Code-Aufwand noch so gering - ist **ganz klar kein Microframework** sondern eindeutig Fullstack mit einer ganzen Landschaft. **Dafür ist es absolut Mainstream: Daher maximale Punktezahl bei der _Bossability!_**. Viel Automagie – zur Behersschung muss man das Spring Framework doch vollständiger erfasst haben. Nichts was eben mal auf die Schnelle geht. --- Auffällig war nicht nur der der schlechteste Durchsatz, sondern insbesondere die Ausreisser in den Antwortzeiten. Sehen wir nacher noch. Was den Bytecode-Umfang anbetrifft: Kein Ruhmesblatt – aber hätte fast mehr erwartet.

Benchmark Crunchdown
(Bytecode Size)

All-in-one JAR

Benchmark Crunchdown
(Request Duration)

$ ab -n 400000 -c 400 "http://localhost:8080/list?_page=1&_…"

* Wir haben einfach 0,4 Mio Requests auf die Einkaufslistenliste mit parallel 400 Nutzern getestet. Die URL-Parameter sind ohne Effekt aber zu Zwecken um die Request- Verarbeitung zu testen drin. * Rot (hell+dunkel) = Mittelwert. Hellrot+Gelb = Feld der Standardabweichung * Wer möchte kann auch gerne die Referenzanwendungen austesten und eigenen Experiemten/Tests wagen. Dafür das `benchmark.sh`. --- **Wichtig: Die Benchmarks sind nicht das Maß aller Dinge sondern meehr Quick & Dirty!** Es spielen doch noch einige andere Faktoren wie verwendeter Servelet-Container (Jetty, Undertow, Netty) oder Serialisierungsbibliothek mit rein. Also nicht normiert. Zudem keinerlei Tuning.

Micro macht Spaß!

Risiken:
Traktion, Stabilität, geringe Verbreitung

Gegenstrategie:
Fokus: Micro & gute Verständlichkeit; Bereitschaft, Bugs ggf. selbst zu lösen

Materialien, Links & Weiterführendes

###### Microframeworks * [sparkjava.com](http://sparkjava.com/) * [ninjaframework.org](http://www.ninjaframework.org/) * [jodd.org](https://jodd.org/) * [ratpack.io](https://ratpack.io/) --- * [pippo.ro](http://www.pippo.ro/) * [jooby.org](http://jooby.org/) * [Javalite.io](http://javalite.io/) * [bootique.io](https://bootique.io/) --- * [REST Service w/o any Framework](https://www.stubbornjava.com/posts/lightweight-embedded-java-rest-server-without-a-framework) only with [Undertow container](http://undertow.io/)

###### Efficency * [projectlombok.org](https://projectlombok.org/) ###### Sonstiges * Präsentation via [reveal.js](https://revealjs.com) * Photos via [unsplash.com](https://unsplash.com/) * Charts via [chartist.js](https://gionkunz.github.io/chartist-js/)

###### Vom Autor * [*@bentolor*](http://twittter.com/bentolor) * [*Java++*: Effiziente & sichere JVM-Entwicklung mit Kotlin](https://bentolor.github.io/kotlin-talk/) * [`idea-cli-inspector`](https://github.com/bentolor/idea-cli-inspector)

Referenzprojekt und HTML5 Slides:
https://github.com/bentolor/microframeworks-showcase/