Klassenname für Logger unter Java automatisch ermitteln

Vor einiger Zeit schrieb ich einen Artikel darüber, wie der Klassenname für einen Logger ermittelt werden kann. Im Endergebnis sah die damalige Lösung, unter Nutzung der Simple Logging Facade for Java kurz SLF4J, wie folgt aus:

Logger log = LoggerFactory.getLogger(new Exception().fillInStackTrace().getStackTrace()[0].getClassName());

Damit wird der gesamte Stacktrace zusammengesammelt und entsprechend der Klassenname extrahiert. Das Problem an dieser Variante ist das der gesamte Stack dafür ausgewertet wird und für jede Nutzung eines Logs eine relativ unintuitive und lange Zeile von A nach B kopiert werden muss. Anders sieht es mit folgender Lösung aus:

package net.seeseekey.example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Utility class to get logger
 */
public final class Logging {

    private Logging() {
    }

    public static Logger getLogger() {

        StackWalker.StackFrame frame = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE)
                .walk(stream -> stream.skip(1)
                        .findFirst()
                        .orElse(null));

        if (frame == null) {
            return LoggerFactory.getLogger("Common");
        }

        return LoggerFactory.getLogger(frame.getClassName());
    }
}

Bei dieser Utility-Klasse wird der entsprechende Klassenname dynamisch über einen StackWalker ermittelt. Zurückgegeben wird hierbei der Klassenname des Aufrufers. Konnte kein Klassenname ermittelt werden, so wird stattdessen ein Logger mit dem Namen Common zurückgegeben. Damit kann der eigentliche Logger nun wie folgt angelegt werden:

Logger log = Logging.getLogger();

Der StackWalker ist ab Java 9 verfügbar und kann somit in neueren Projekten problemlos genutzt werden. Im Gegensatz zu den bisherigen Methoden Teile des Stacktrace zu erhalten, ist der StackWalker aus Performancesicht zu bevorzugen. Definiert wurde diese API in der JEP 259.

Tastatur und Maus unter Java fernsteuern

Für bestimmte Automatisierungsaufgaben ist es manchmal nötig die Tastatur und die Maus eines Rechners fernzusteuern. Unter Java kann dies mit der Klasse Robot aus dem Package java.awt erledigt werden. Ein einfaches Beispiel zur Nutzung sieht dabei wie folgt aus:

// Create robot
Robot robot = new Robot();

// Move mouse and make a mouse click, then wait
robot.mouseMove(1000, 1000);
robot.mousePress(InputEvent.BUTTON1_MASK);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
robot.delay(1000);

// Press key a, then wait
robot.keyPress(KeyEvent.VK_A);
robot.keyRelease(KeyEvent.VK_A);
robot.delay(1000);

In diesem Beispiel wird zunächst eine Instanz der Klasse Robot angelegt. Anschließend wird die Maus bewegt und die linke Maustaste gedrückt und wieder losgelassen. Danach wartet der Robot eine Sekunde, um anschließend die Taste A zu drücken. Neben den im Beispiel gezeigten Funktionalität kann unter anderem das Mausrad gesteuert werden. Auch Methoden um einen Pixel auszulesen oder größere Bereiche des Bildschirmes sind in der Klasse zu finden.

Enumerationen unter Java mit Eigenschaften ausstatten

Im Gegensatz zu vielen anderen Programmiersprachen sind Enumerationen unter Java ein wenig anders gestrickt. Wird eine Enumerationen dort kompiliert entsteht als Ergebnis eine Klasse. Dieser Umstand kann für interessante Dinge genutzt werden. Während in C# der Enum:

public enum Unit {
    PASCAL,
    PSI
}

eine reine Enumeration, mit zwei Werten, darstellt, kann die Enumeration unter Java mit zusätzlicher Funktionalität ausgestattet werden:

public enum Unit {

    PASCAL("Pascal", 1),
    PSI("Pound-force per square inch", 6.895);

    Unit(String name, double conversionFactor) {
        this.name = name;
        this.conversionFactor = conversionFactor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getConversionFactor() {
        return conversionFactor;
    }

    public void setConversionFactor(double conversionFactor) {
        this.conversionFactor = conversionFactor;
    }

    private String name;
    private double conversionFactor;
}

In diesem Fall erhält die Enumeration zwei zusätzliche Eigenschaften, einen Namen und einen Faktor zur Umrechnung in Pascal. Bei der Definition der einzelnen Werte der Enumeration werden diese zusätzlichen Eigenschaften über den Konstruktor übergeben. In der Nutzung sieht das Ganze dann wie folgt aus:

Unit unit = Unit.PSI;

System.out.println(unit.getName());
System.out.println("Conversion factor to Pascal: " + unit.getConversionFactor());

Mit dieser Herangehensweise lassen sich Enumerationen unter Java einfach mit dazugehörigen Metadaten bzw. zusätzlichen Informationen anreichern.

Angelscript

Es gibt ja so einige Skriptsprachen auf dem Markt welche sich in Spiele integrieren lassen. Da wären z.B. Lua oder Javascript. Meist stört mich an diesen Sprachen die Syntax (wobei man sich an diese gewöhnen kann), allerdings haben die meisten dieser Sprachen keine Unterstützung für Klassen sondern nur für Prototypen. Deshalb bin ich von AngelScript doch recht begeistert, denn es bietet eine C Syntax, Klassenunterstützung und statische Typisierung. Daneben steht es unter der zlib Lizenz lässt sich also problemlos in eigene Projekte integrieren. Zu finden ist Angelskript dabei unter http://www.angelcode.com/angelscript/.

Weitere Informationen gibt es unter:
http://de.wikipedia.org/wiki/AngelScript