JSON mit Schlüsselwörtern unter Java deserialisieren

Mittels GSON von Google, können JSONs unter Java einfach in Objekte deserialisiert werden. Allerdings können bestimmte JSON-Objekte zu Problemen führen. So zum Beispiel folgende JSON-Datei:

{
   "default":"ABC",
   "value":"DEF"
}

Das entsprechende Java-Objekt könnte in diesem Fall wie folgt aussehen:

class Data {

  public String default;
  public String value;
}

Damit wäre GSON in der Lage die entsprechenden Felder aus dem JSON, den Felder in der Klasse zuzuordnen. Allerdings kann obige Klasse nicht kompiliert werden. Hintergrund hierfür ist das Feld default. Unter Java ist dies ein Schlüsselwort und kann somit nicht als Feldname genutzt werden. Unter Sprachen wie C# könnte hier mit einer Verbatim-Zeichenkette gearbeitet werden:

public String @default;

Allerdings bietet Java diese Möglichkeit nicht an, sodass sich hier anders beholfen werden muss. Die Lösung ist die Annotation SerializedName. Diese gibt den Namen des Schlüssels im JSON an, welcher in das entsprechende Feld deserialisiert werden soll:

class Data {

  @SerializedName("default")
  public String defaultValue;
  public String value;
}

Damit kann GSON die Serialisierung wieder vornehmen und das obige JSON kann in eine entsprechende Java-Struktur abgebildet werden.

Benchmarking mit dem JMH-Framework

Benchmarking unter Java hat mit einigen Problemen zu kämpfen. So optimiert die Java-Laufzeitumgebung den Quellcode, je nachdem wie oft er benutzt wird. Wenn nun kleinere Dinge getestet werden sollen, wie z.B. ob Methode A oder B besser funktioniert so wird dies problematisch. Am Anfang würde besagte Methoden nur interpretiert werden, anschließend würden sie bei häufiger Benutzung kompiliert werden und bei noch häufigerer Benutzung weiter optimiert werden. Daneben kann es passieren dass der Benchmark komplett wegoptimiert wird, da die JVM unter Umständen erkennt, dass die genutzten Werte bzw. die Ergebnisse des Benchmarks später nicht mehr genutzt werden.

Die offizielle Seite des Java Microbenchmark Harness-Framework

Damit sich ein Entwickler nicht immer und immer wieder mit solchen Problemen beim Benchmarking herumschlagen muss, wird seit einigen Jahren im Rahmen des OpenJDK-Projektes an dem Java Microbenchmark Harness-Framework gearbeitet. Das JMH-Framework nimmt dem Entwickler viele Aufgaben ab, um diese Probleme zu lösen. So kann bzw. wird die JVM durch JMH aufgewärmt werden und auch die Messung der Zeiten übernimmt JMH. Um JMH zu nutzen, müssen die entsprechenden Abhängigkeiten (in diesem Fall über die Maven-POM-Datei) dem Projekt hinzugefügt werden:

<dependency>
	<groupId>org.openjdk.jmh</groupId>
	<artifactId>jmh-core</artifactId>
	<version>1.21</version>
</dependency>
<dependency>
	<groupId>org.openjdk.jmh</groupId>
	<artifactId>jmh-generator-annprocess</artifactId>
	<version>1.21</version>
</dependency>

Sind die Abhängigkeiten eingebunden, kann mit dem eigentlichen Aufbau des Benchmarks begonnen werden. Jede Methode, welche ein Benchmark durchführen möchte, muss mit der @Benchmark-Annotation gekennzeichnet werden:

@Benchmark
public int addInts() {
    return aInt + bInt;
}

Die Klasse, in welcher die Benchmarks definiert sind, muss mit einigen weiteren Annotationen ausgestattet werden:

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class AddingBenchmark {
...

Die @State(Scope.Benchmark)-Annotation in diesem Beispiel sorgt dafür das die Felder im Rahmen des Benchmarks für die Benchmark-Methoden zur Verfügung stehen. Mit der @BenchmarkMode-Annotation wird definiert, welche Art von Messung vorgenommen werden soll. In diesem Fall wird die durchschnittliche Zeit für eine einzelne Operation gemessen und ausgegeben. Über die @OutputTimeUnit-Annotation wird definiert wie die Zeiten für die Messungen ausgegeben werden. Werden für den Benchmark Daten benötigt so können sie über eine Methode, welche mit der @SetupAnnotation versehen wird, erzeugt werden:

@Setup
public void setup() {
    ...
}

Die setup-Methode wird damit vor dem eigentlichen Benchmark ausgeführt und somit können benötigte Daten dort erzeugt werden. Damit der Benchmark nun ausgeführt werden kann muss das Java Microbenchmark Harness-Framework angestartet werden. Dafür wird eine Klasse geschrieben und mit einer main-Methode versehen:

package net.seeseekey.JavaBenchmark;

import org.openjdk.jmh.runner.RunnerException;

import java.io.IOException;

public class Runner {

    public static void main(String[] args) throws IOException, RunnerException {
        
        org.openjdk.jmh.Main.main(args);
    }
}

Über die main-Methode wird die main-Methode des Frameworks gestartet und damit wird das Benchmark durchgeführt. Alternativ kann die Methode org.openjdk.jmh.Main.main auch direkt in der Maven-POM-Datei als Startklasse definiert werden:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>org.openjdk.jmh.Main.main</mainClass>
            </manifest>

Nachdem der Benchmark implementiert ist, kann dieser natürlich über die IDE ausgeführt werden. Das würde allerdings nicht ganz der Intention von JMH entsprechen. Stattdessen sollte eine JAR aus dem Projekt erzeugt werden und diese, auf einem möglichst unbelastetem System, über die Konsole ausgeführt werden:

java -jar benchmark.jar

Damit wird der Benchmark über JMH ausgeführt. JMH beginnt mit einer Warmup-Phase und führt anschließend den eigentlichen Benchmark durch. Nach einigen Minuten erhält der Entwickler die Auswertung des Benchmark:

Benchmark                                 Mode  Cnt   Score    Error  Units
JavaBenchmark.AddingBenchmark.addDoubles  avgt   25  ≈ 10⁻⁵           ms/op
JavaBenchmark.AddingBenchmark.addInts     avgt   25  ≈ 10⁻⁵           ms/op

In diesem Fall sieht der Entwickler bei der Ausgabe, dass die Ausgabeeinheit für die Zeit mit Millisekunden zu grob gewählt wurde und stattdessen besser Nanosekunden genutzt werden sollten.

REST-Service mittels Spring Boot aufsetzen

Sprint Boot vereinfacht das Setup eines Spring-Projektes und geht dabei nach der Methode Konvention vor Konfiguration vor. So lässt sich ein einfacher REST-Service mittels Spring Boot schnell und unkompliziert implementieren. Im ersten Schritt wird dazu mit dem Spring Initializr ein neues Projekt mit der Abhängigkeit Web angelegt.

Mit dem Spring Initializr wird ein Projekt mit der Abhängigkeit Web angelegt.

Nach dem Download des Projektes wird dieses in der IDE der Wahl (z.B. IntelliJ IDEA) geöffnet und eine Klasse mit dem Namen HelloWorldController angelegt. Die Klasse sollte im gleichen Package (in diesem Beispiel: com.example.demo) wie die DemoApplication angelegt werden und wie folgt aussehen:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    @GetMapping("/hello")
    public String helloWorld(@RequestParam final String name) {
        return "Hello " + name + "!";
    }

    @GetMapping("/hello/{name}")
    public String helloWorld2(@PathVariable("name") final String name) {
        return "Hello " + name + "!";
    }
}

Über die Annotation @RestController wird dem Framework mitgeteilt das es sich bei dieser Klasse um einen Controller für die REST-API handelt. Anschließend wird die Ressource hello definiert. Diese kann über zwei Wege aufgerufen werden:

http://localhost:8080/hello?name=seeseekey
http://localhost:8080/hello/seeseekey

Bei beiden Aufrufen erscheint als Ergebnis der Text:

Hello seeseekey!

Der erste Aufruf wird auf die Methode helloWorld gemappt, während der zweite Aufruf mit dem Parameter in der URL an die Methode helloWorld2 gemappt wird. Mittels der Annotation @GetMapping wird der URL-Pfad festgelegt, auf welchen die Methode reagieren soll. Bei der ersten Methode kommt die Annotation @RequestParam zum Einsatz, welche einen gewöhnlich Parameter definiert, welcher von der eigentlichen URL abgetrennt ist. Dagegen wird mit der Annotation @PathVariable in der Methode helloWorld2 eine Variable im Pfad der eigentlichen URL definiert.