Java-Bibliothek für den Zugriff auf die MediaWiki-API

Bibliotheken um die MediaWiki-API anzusteuern gibt es wie Sand am Meer. Bei soviel Auswahl fällt es natürlich schwer eine passende und funktionale Bibliothek zu finden. Für Java habe ich mittlerweile die Bibliothek JWBF (kurz für Java Wiki Bot Framework) für mich entdeckt. Die Bibliothek kann einfach per Maven eingebunden werden:

<dependency>
	<groupId>net.sourceforge</groupId>
	<artifactId>jwbf</artifactId>
	<version>3.1.1</version>
</dependency>

Anschließend kann eine MediaWiki-Seite ohne Probleme bezogen werden:

MediaWikiBot wikiBot = new MediaWikiBot("https://wiki.example.org/");
Article article = wikiBot.getArticle("Artikelname");
System.out.println(article.getText());

Auch das Anlegen von Artikeln ist kein Problem:

MediaWikiBot wikiBot = new MediaWikiBot("https://wiki.example.org/");

Article article = new Article(wikiBot, "Test");
article.addText("Lorem ipsum dolor sit amet.");

wikiBot.login("Nutzername", "Passwort");
article.save();

Der Quelltext der Bibliothek ist auf GitHub zu finden. Lizenziert ist die Bibliothek unter der Apache License in der Version 2.0 und damit freie Software.

Speedtest unter Ubuntu auf der Konsole

Für den Test der Geschwindigkeit der eigenen Anbindung an das Internet, gibt es seit Jahren den Speedtest von Ookla. Dieser kann nicht nur im Browser, sondern auch in der Konsole unter Ubuntu genutzt werden. Nach der Installation mittels:

apt install speedtest-cli

kann der Dienst über die Kommandozeile genutzt werden:

speedtest-cli

Anschließend startet der Test der Anbindung und das entsprechende Ergebnis wird dargestellt:

Retrieving speedtest.net configuration…
Testing from Deutsche Telekom (XXX.XXX.XXX.XXX)…
Retrieving speedtest.net server list…
Selecting best server based on ping…
Hosted by SMSnet (Szczecin) [85.48 km]: 24.498 ms
Testing download speed……………………………………………………………………..
Download: 160.21 Mbit/s
Testing upload speed…………………………………………………………………………………………
Upload: 121.56 Mbit/s

Im Gegensatz zur Webseite kommt die Version für die Kommandozeile ohne Werbung aus. Das Projekt für die Kommandzeilen-Version befindet sich auf GitHub. Es ist unter der Apache-Lizenz in Version 2 lizenziert und somit freie Software.

LoadingCache der Guava-Bibliothek nutzen

Für Java existiert eine Bibliothek mit dem Namen Guava. Diese, von Google entwickelte, Bibliothek bietet gewisse Basisfunktionalitäten, welche vom Java-Framework nicht abgedeckt werden. Eine dieser Funktionalitäten ist der LoadingCache. Bei diesem handelt es sich um einen Cache, welcher dazu genutzt werden kann die Ergebnisse zeitintensiver Operationen zwischenzuspeichern. Daneben verfügt er über die Informationen wie er die entsprechenden Daten bezogen werden. Um Guava zu nutzen muss die Bibliothek z.B. mittels Maven eingebunden werden. Dazu muss die pom.xml-Datei um eine Abhängigkeit erweitert werden:

<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>27.0-jre</version>
</dependency>

Anschließend kann Guava in dem betreffenden Projekt genutzt werden. In diesem Beispiel soll der Cache dazu dienen Anfragen an einen Webservice zu cachen. Der Webservice liefert Daten zurück, welche in einem Objekt vom Typ BookData gespeichert werden:

class BookData {

	public final String title;
	public final String description;
	public final double price;

	public BookData(String title, String description, double price) {
		this.title = title;
		this.description = description;
		this.price = price;
	}
}

Innerhalb der Anwendung übernimmt die Methode getBookData die Aufgabe, diese Daten vom Webservice zu beziehen:

public BookData getBookData(String isbn) {
	return bookdataService.getData(isbn);
}

Der LoadingCache von Guava ist technisch betrachtet eine Map. Bei der Initialisierung ist dies ersichtlich:

LoadingCache<String, BookData> books = CacheBuilder.newBuilder()
		.maximumSize(1000)
		.expireAfterWrite(7, TimeUnit.DAYS)
		.build(
				new CacheLoader<String, BookData>() {
					public BookData load(String isbn) {
						return getBookData(isbn);
					}
				});

Beim Anlegen des Cache können unterschiedliche Parameter wie die maximale Größe, die Zeit ab der ein Eintrag erneuert wird und der CacheLoader definiert werden. Der CacheLoader implementiert die Methode load, welche die entsprechenden Daten vom Webservice bezieht. Nachdem der LoadingCache definiert ist, kann die Map normal genutzt werden:

BookData bookData = books.get("9783736889842");

Im Hintergrund wird der Wert, wenn vorhanden, aus dem Cache bezogen. Ist dies nicht der Fall wird stattdessen der CacheLoader genutzt, welcher in diesem Beispiel einen Request an den Webservice sendet und das Ergebnis wieder im Cache hinterlegt. Der LoadingCache selber beschränkt sich auf die Laufzeit der Applikation und wird nicht persistiert.

Spring Projekte einfach anlegen

Das Anlegen eines Projektes mit dem Spring-Framework (bzw. unter Zuhilfenahme von Spring Boot) kann von Hand erfolgen. Einfacher ist es den Spring Initializr zu nutzen. Über das Webinterface kann die Art der Projektes, die gewünschte Sprache und Spring Boot-Version definiert werden. Anschließend können gewünschte Abhängigkeiten ausgewählt und das Projekt generiert und heruntergeladen werden.

Mit dem Spring Initializr können Projekte schnell angelegt werden

Eine Instanz des Projektes ist unter start.spring.io zu finden. Der Quelltext des Projekts ist auf GitHub hinterlegt. Lizenziert ist Spring Initializr unter Apache License in der Version 2 und damit freie Software.

Thymeleaf ohne Servlet in Standalone-Anwendungen nutzen

Thymeleaf ist eine Template Engine, welche für die Nutzung mittels Java (oder anderer JVM-Sprachen) gedacht ist. Über diese können entsprechende Templates geschrieben werden, anschließend gefüllt und genutzt werden. Thymeleaf verfügt über eine Dokumentation, allerdings fehlt mir dort ein minimales Beispiel für Anwendungen, welche sich nicht im Web (sogenannte non-web environments) abspielen.

thymeleaf.org

Für ein minimales Beispiel wird natürlich ein Template benötigt. Dieses wird hier als HTML definiert:

<!DOCTYPE html>
<html>
<head>
    <title th:text="${title}"></title>
</head>
<body>
</body>
</html>

Interessant ist hierbei das Feld title, welches wir mit einem Titel füllen wollen. Im Java-Quellcode sieht die Implementation wie folgt aus:

ClassLoaderTemplateResolver resolver = new ClassLoaderTemplateResolver();
resolver.setPrefix("templates/");
resolver.setTemplateMode("HTML5");
resolver.setSuffix(".html");

TemplateEngine templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(resolver);

Context context = new Context(Locale.GERMAN);
context.setVariable("title", "Ein minimales Beispiel");

final String content = templateEngine.process("header.html", context);

Im ersten Schritt wird mit dem ClassLoaderTemplateResolver ein Resolver definiert, welcher schlussendlich dafür sorgt die Templates aus den Ressourcen (im resources-Ordner) bezogen werden. Daneben wird der Template-Modus eingestellt. Neben dem Modus HTML5 unterstützt Thymeleaf wie z.B. TEXT oder JAVASCRIPT. Danach wird die Template Engine erstellt und ihr der Resolver zugewiesen. Die Variablen, welche in diesem Fall im Template genutzt werden, werden über den Context definiert und gesetzt. Anschließend wird das Ganze an die process-Methode der Template Engine übergeben. Als Ergebnis erhalten wir im String content folgenden Inhalt:

<!DOCTYPE html>
<html>
<head>
    <title">Ein minimales Beispiel</title>
</head>
<body>
</body>
</html>

Damit wurde Thymeleaf in einer minimalen Variante angewendet. Die offizielle Seite der Template Engine ist unter thymeleaf.org zu finden. Lizenziert ist Thymeleaf unter der Apache License in der Version 2.0 und damit freie Software.