API-Kataloge im Web

Jeder und kleinere und größere Webdienst verfügt mittlerweile über eine API, meist ausgeführt in Form eines RESTful-Webservice. Interessant ist es natürlich zu schauen, welche APIs öffentlich verfügbar sind. Hierbei helfen entsprechende Kataloge wie AnyAPI, welcher unter any-api.com zu finden ist. Dieser bietet Informationen über 1400 öffentlich zugängliche APIs.

Any API listet über 1400 öffentlich zugängliche APIs

Die APIs bei AnyAPI sind nach Kategorien geordnet. Zu jeder API finden sich in dem Katalog die Auflistung der Ressourcen und Dokumentation zur Nutzung der API. Daneben existieren weitere Kataloge wie die API List oder die Public APIs-Sammlung. Letztere wiederrum verfügt über eine API zum Abruf der APIs.

curl zur Abfrage von REST-APIs benutzen

Die Aufgabe des freien Kommandozeilentools curl ist einfach beschrieben: Datentransfer. So unterstützt curl unterschiedlichste Protokolle wie FTP, HTTP, HTTPS, IMAP, SCP, SMB und viele mehr. Ein einfacher Download einer Datei über HTTP bzw. HTTPS würde mit curl wie folgt aussehen:

curl -O https://example.com/file.zip

Auch ein Transfer z.B. per FTP ist kein Problem:

ftp://example.com/file.zip

Allerdings beherrscht curl wesentlich mehr Operationen als nur das Herunterladen von Dateien. So kann curl genutzt werden, um REST-APIs zu benutzen. Diese APIs arbeiten nicht nur mit dem HTTP-Verb GET, sondern auch mit anderen Verben wie POST und PUT. Ein einfacher GET-Request wurde mittels curl wie folgt aussehen:

curl -X GET https://example.com/

Ein POST-Request wird auf die gleiche Art durchgeführt:

curl -X POST https://example.com/

Sollen zusätzlich Daten übertragen werden, so geschieht dies mit dem Parameter -d:

curl -X POST https://example.com/  -d '{
	field: "data",
	field2: "data",
	field3: "data"
}'

Damit werden die Daten im Body des Requests mitgesendet. Auch die Übergabe von Headern ist mittels curl möglich:

curl -X POST https://example.com/ 
 -H 'HeaderField: headerValue'
 -d '{
	field: "data",
	field2: "data",
	field3: "data"
}'

Manche APIs und andere Services blockieren Abrufe über curl manchmal. Dabei wird der Useragent von curl ausgesperrt. Allerdings kann dieser einfach geändert werden:

curl -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0" -X GET https://example.com/

Damit können solche fragwürdigen Maßnahmen, welche zum Ausschluss von curl führen, umgangen werden. Daneben verfügt curl über viele weitere Operationen bzw. Optionen. So kann z.B. mittels des Parameters -I nur der Header des Response bezogen werden:

curl -I -X GET https://example.com

Somit bietet curl die entsprechende Funktionalität um REST-APIs für Tests und ähnliches flexibel abzufragen.

Nachkommastellen von Pi als REST-Service

Die Zahl Pi beschreibt das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser und gehört sicherlich zu den bekannteren mathematischen Konstanten. Anlässlich des Pi-Days am 14. März 2019 veröffentlichte Google die Zahl Pi mit bisher unerreichten 31,4 Billionen Nachkommastellen.

3.1415926535897…

Passend dazu stellte Google die Seite pi.delivery in Netz. Neben einigen Spielereien rund um Pi, wie die Nutzung von Pi zur Generierung von Musik, findet sich dort eine REST-API, mit welcher die Nachkommastellen von Pi erfragt werden können. Ein einfacher Request des Services sieht wie folgt aus:

GET https://api.pi.delivery/v1/pi?start=0&numberOfDigits=42

Für den Request existieren zwei Parameter. Der erste Parameter mit dem Namen start definiert ab welcher Stelle die Nachkommastellen geliefert werden sollen. Der zweite Parameter numberOfDigits setzt die Anzahl der zurückgelieferten Nachkommastellen. Als Antwort erhält der Nutzer des Service anschließend die entsprechenden Nachkommastellen (sowie die 3 am Anfang von Pi):

{
    "content": "314159265358979323846264338327950288419716"
}

Element einer Liste unter Java mittels des Stream-API ermitteln

Unter Java kommt es öfter vor, das ein bestimmter Eintrag in einer Liste gesucht werden soll. Gegeben sei in diesem Beispiel folgende Liste:

// List of elements
List elements = new ArrayList();

elements.add(new Element("Suppe", "Löffel"));
elements.add(new Element("Wasser", "Flüssigkeit"));
elements.add(new Element("Käse", "Gelb"));
elements.add(new Element("Huhn", "Ei"));

Die Klasse, welche die Elemente hält ist wie folgt definiert:

class Element {
    public final String Key;
    public final String Value;

    public Element(String key, String value) {
        Key = key;
        Value = value;
    }
}

Soll nun ein bestimmtes Element der Liste ermittelt werden, so kann dies auf dem klassischen Weg wie folgt erledigt werden:

// Get element
Element specificElement = null;

for (Element element : elements) {

    if ("Huhn".equals(element.Key)) {
        specificElement = element;
        break;
    }
}

Mit der seit Java 8 eingeführtes Stream-API kann das Problem eleganter gelöst werden:

// Get element via stream api
Element specificElement = elements.stream()
        .filter(element -> "Huhn".equals(element.Key))
        .findFirst()
        .orElse(null);

In diesem Fall werden die Elemente durchgegangen und überprüft ob in element.Key die Zeichenkette Huhn enthalten ist. Ist dies der Fall, wird das entsprechende Element zurückgegeben. Wird das Element in diesem Fall nicht gefunden, so ist die Variable specificElement null.

Konvertierungen zwischen alter und neuer Datums- und Zeit-API

Seit Java 8 verfügt die Programmiersprache über eine sinnvolle Datums- und Zeit-API. In den meisten Fällen kann diese API ohne weitere Probleme genutzt werden. Problematisch wird es nur, wenn die neue API im Zusammenhang mit Legacy-Code genutzt werden soll. Meist wird dort die Klasse Date aus dem Package java.util genutzt. Damit werden Methoden benötigt, um eine Brücke von der alten zur neuen API und umgekehrt zu schlagen. Um ein Date in eine LocalDateTime umzuwandeln, kann folgende Methode genutzt werden:

public static LocalDateTime convertToLocalDateTime(Date date) {
    return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}

Soll der Wert, welcher in der LocalDateTime gespeichert ist, wieder in ein Date-Objekt konvertiert werden, kann folgende Methode genutzt werden:

public static Date convertToDate(LocalDateTime localDateTime) {
    return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}

Bei diesen Konvertierungsmethoden ist zu beachten, dass die Zeitzonen bei der Konvertierung ignoriert werden. Stattdessen wird die Konvertierung mit der Standardzeitzone des Systems durchgeführt. Für die Konvertierung unter Berücksichtigung und Speicherung der Zeitzonen kann die Klasse ZonedDateTime genutzt werden. Die entsprechenden Methoden zur Konvertierung wären folgende:

public static ZonedDateTime convertToZonedDateTime(Date date, ZoneId zoneId) {
    return date.toInstant().atZone(zoneId);
}

public static Date convertToDate(ZonedDateTime zonedDateTime) {
    return Date.from(zonedDateTime.toInstant());
}

Bei der Konvertierung einer Date-Instanz in eine ZoneDateTime muss die entsprechende Zeitzone als ZoneId mitgegeben werden.