{"id":889,"date":"2016-03-08T17:15:00","date_gmt":"2016-03-08T15:15:00","guid":{"rendered":"http:\/\/invidit.de\/blog\/?p=889"},"modified":"2020-12-08T10:32:03","modified_gmt":"2020-12-08T08:32:03","slug":"lombok-macht-das-schon","status":"publish","type":"post","link":"https:\/\/invidit.de\/blog\/lombok-macht-das-schon\/","title":{"rendered":"Lombok macht das schon"},"content":{"rendered":"

Hallo Spa\u00df-Coder.<\/p>\n

Wer kennt sie nicht: Datenklassen, die ausschlie\u00dflich Attribute enthalten um Daten aufzunehmen und selbst keine Logik beinhalten? Sei es f\u00fcr die Entit\u00e4ten der Datenbanktabellen oder einfache Datentranfsfer-Objekte. Diese Klasse k\u00f6nnte echt \u00fcbersichtlich und aufger\u00e4umt sein, w\u00e4ren da nicht diese Getter<\/em> und Setter<\/em> der Attribute, eine Implementierung der toString()<\/em>-Methode, equals()<\/em> oder hashCode()<\/em>.<\/p>\n

Damit wird die vermeintlich einfache Klasse doch wieder recht un\u00fcbersichtlich und aufgebl\u00e4ht. In diesem Artikel stellen wir eine Bibliothek vor, die es uns erm\u00f6glicht, auf das Wesentliche zu fokussieren.<\/p>\n

Was macht Lombok?<\/h1>\n

Das Projekt Lombok[1]<\/sup> stellt eine Java-Bibliothek zu Verf\u00fcgung, die uns erm\u00f6glicht den Code deutlich aufger\u00e4umter zu gestalten und die \u00fcblichen erforderlichen Methoden einfach durch Annotationen generieren zu lassen. Wie das aussehen kann, m\u00f6chten wir euch anhand von ein paar Beispielen verdeutlichen. Dazu verwenden wir unser kleines TicTacToe Spiel, welches wir auch in anderen Artikeln <\/a>bereits als Beispiel herangezogen hatten.<\/p>\n

Geben und Nehmen<\/h2>\n

Unsere Entities sollen Daten tragen. Diese sind per Konvention zun\u00e4chst einmal als private<\/span> markiert. Damit wir doch Zugriff darauf haben, verwenden wir Getter<\/em> und Setter<\/em>. Im Normalfall k\u00f6nnen die nicht viel und verschmutzen unseren sch\u00f6nen Code.<\/p>\n

Schauen wir doch mal, was Lombok in diesem Fall f\u00fcr uns tun kann:<\/p>\n\n\n\n\n
Natural Pure Java<\/strong><\/td>\nMit Lombok-Magie<\/strong><\/td>\n<\/tr>\n
\n
public class Player {\n\n\tprivate String name;\n\tprivate String symbol;\n\tprivate MoveStrategy strategy;\n\n\tpublic Player() {\n\t\tthis.name = \"\";\n\t\tthis.strategy = null;\n\t\tthis.symbol = \"?\";\n\t}\n\t\n\t[...]\n\t\n\tpublic String getName() {\n\t\treturn name;\n\t}\n\n\tpublic void setName(String name) {\n\t\tthis.name = name;\n\t}\n\t\n\tpublic String getSymbol() {\n\t\treturn this.symbol;\n\t}\n\t\n\tpublic int getNextMove(GameState state) {\n\t\treturn this.strategy.getNextPosition(state);\n\t}\n}<\/pre>\n<\/td>\n
\n
public class Player {\n\n\t@Getter @Setter\n    private String name;\n    @Getter\n\tprivate String symbol;\n    private MoveStrategy strategy;\n\n\tpublic Player() {\n\t\tthis.name = \"\";\n\t\tthis.strategy = null;\n\t\tthis.symbol = \"?\";\n\t}\n\t\n\t[...]\n\n\tpublic int getNextMove(GameState state) {\n\t\treturn this.strategy.getNextPosition(state);\n\t}\n}<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Durch die beiden einfachen Annotationen @Getter<\/em> und @Setter<\/em> lassen sich in diesem Beispiel 10 Zeilen Code sparen. Das sch\u00f6ne daran ist, dass nun gut sichtlich wird, dass die Methode getNextMove()<\/em> kein klassischer Getter ist, sondern \u00fcber eine Strategie ein bestimmtes Verhalten erzeugt (dazu kommen wir in einem anderen Artikel noch). So erkennen wir den wichtigen Teil unseres Codes viel schneller.<\/p>\n
Nullen sind hier nicht erlaubt!<\/h2>\n
Frei nach dem Prinzip fail fast<\/em> wollen wir oft die Eingangsparameter unserer Methoden pr\u00fcfen. Die h\u00e4ufigste Pr\u00fcfung ist dabei die Pr\u00fcfung darauf, dass der \u00fcbergebene Parameter nicht null<\/em> ist.<\/p>\n
Auch hier schauen wir mal, wie Lombok uns das Leben vereinfacht:<\/p>\n\n\n\n\n
Natural Pure Java<\/strong><\/td>\nMit Lombok-Magie<\/strong><\/td>\n<\/tr>\n
\n
public class Player {\n\n\t[...]\n\t\n\tpublic Player(PlayerData playerData) {\n        if(playerData == null) {\n            throw new NullPointerException(\"playerData\");\n        }\n\t\tthis.name = playerData.getName();\n\t\tthis.symbol = playerData.getSymbol();\n\t\tthis.strategy = playerData.getStrategy();\n\t}\n\n\t[...]\n}<\/pre>\n<\/td>\n
\n
public class Player {\n\t\n\t[...]\n\n\tpublic Player(@NonNull PlayerData playerData) {\n\t\tthis.name = playerData.getName();\n\t\tthis.symbol = playerData.getSymbol();\n\t\tthis.strategy = playerData.getStrategy();\n\t}\n\n\t[...]\n\n}<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Auch hier reicht eine einfache Annotation. Wir erhalten eine NullPointerException und als Nachricht den Namen des betroffenen Parameters…und sparen 3 Zeilen Code…pro zu pr\u00fcfendem Parameter.<\/p>\n
Noch besser: Kombinieren wir z.B. die @Setter-Annotation mit der @NonNull-Annotation, k\u00fcmmert sich Lombok sogar gleich darum:<\/p>\n\n\n\n\n
Natural Pure Java<\/strong><\/td>\nMit Lombok-Magie<\/strong><\/td>\n<\/tr>\n
\n
public class Player {\n    private String name;\n\n    public String getName() {\n        return name;\n    }\n\n    public void setName(String name) {\n        if(name == null) {\n            throw new NullPointerException(\"name\");\n        }\n        this.name = name;\n    }\n\n    [...]\n\n}<\/pre>\n<\/td>\n
\n
public class Player {\n    @Getter @Setter @NonNull\n    private String name;\t\n\t\n    [...]\n\n}<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Drei Annotations anstelle von 9 Zeilen Code, die in aller Regel immer gleich aussehen.<\/p>\n
Vergleichende Objekte<\/h3>\n
Werfen wir auch noch einen Blick auf das Thema equals<\/em> und hashCode<\/em>, welches wir eingangs des Artikels angesprochen haben:<\/p>\n\n\n\n\n
Natural Pure Java\u00a0 (IDE-generiert)<\/strong><\/td>\nMit Lombok-Magie<\/strong><\/td>\n<\/tr>\n
\n
public class Player {\n\n    [...]\n\n    @Override\n    public boolean equals(Object o) {\n        if (this == o) {\n            return true;\n        }\n        if (o == null || getClass() != o.getClass()) {\n            return false;\n        }\n        Player player = (Player) o;\n        return Objects.equals(name, player.name) &&\n                Objects.equals(symbol, player.symbol);\n    }\n\n    @Override\n    public int hashCode() {\n        return Objects.hash(name, symbol);\n    }\n}<\/pre>\n<\/td>\n
\n
@EqualsAndHashCode(exclude = {\"strategy\"})\npublic class Player {\n\n    [...]\n\n}\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Auf der einen Seite durch IntelliJ generierte equals<\/em>– und hashCode<\/em>-Methoden, bei denen die Variable strategy<\/em> aus dem Vergleich ausgelassen wurde. Auf der anderen Seite die Klasse mit der Annotation @EqualsAndHashCode<\/em>, sowie einer erg\u00e4nzenden Anweisung, welche Variablen ausgelassen werden sollen (in unserem Fall eben strategy<\/em>). \u00dcbersichtlich, oder?<\/p>\n
Und nun, alle zusammen…<\/h2>\n
Als letztes m\u00f6chten wir noch ein Beispiel f\u00fcr echte, dumme Datentransportobjekte verwenden. Diesmal nehmen wir als Beispiel nicht mehr die Klasse Player<\/em>, die hatte ja durch die Delegation der Aufgabe an die \u00fcbergebene Strategie schon ein bisschen Intelligenz an Bord.<\/p>\n
Stattdessen muss diesmal die Klasse PlayerData<\/em> als Beispiel herhalten. Diese besteht aus drei Eigenschaften, mit Gettern<\/em>, einem Konstruktor<\/em> mit allen Werten als \u00dcbergabeparameter, equals<\/em>, hashCode<\/em>, toString<\/em>, alles was man eben so braucht, wenn man als Datentransportobjekt was auf sich h\u00e4lt.<\/p>\n\n\n\n\n
Natural Pure Java\u00a0 (teilweise IDE-generiert)<\/strong><\/td>\nMit Lombok-Magie<\/strong><\/td>\n<\/tr>\n
\n
public class PlayerData {\n    private final String name;\n    private final String symbol;\n    private final MoveStrategy strategy;\n\n    public PlayerData(String name, String symbol, MoveStrategy strategy) {\n        this.name = name;\n        this.symbol = symbol;\n        this.strategy = strategy;\n    }\n\n    public String getName() {\n        return name;\n    }\n\n    public String getSymbol() {\n        return symbol;\n    }\n\n    public MoveStrategy getStrategy() {\n        return strategy;\n    }\n\n    @Override\n    public String toString() {\n        return \"PlayerData{\" +\n                \"name='\" + name + '\\'' +\n                \", symbol='\" + symbol + '\\'' +\n                \", strategy=\" + strategy +\n                '}';\n    }\n\n    @Override\n    public boolean equals(Object o) {\n        if (this == o) {\n            return true;\n        }\n        if (o == null || getClass() != o.getClass()) {\n            return false;\n        }\n        PlayerData that = (PlayerData) o;\n        return Objects.equals(name, that.name) &&\n                Objects.equals(symbol, that.symbol) &&\n                Objects.equals(strategy, that.strategy);\n    }\n\n    @Override\n    public int hashCode() {\n        return Objects.hash(name, symbol, strategy);\n    }\n}<\/pre>\n<\/td>\n
\n
@Data\npublic class PlayerData {\n\tprivate final String name;\n    private final String symbol;\n    private final MoveStrategy strategy;\n}<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ein Wort: @Data<\/em>. Reicht oder? \ud83d\ude09<\/p>\n
Und sonst?<\/h1>\n
Die Projektseite enth\u00e4lt eine sehr gute (englischsprachige) Beschreibung der Funktionalit\u00e4t, weshalb wir hier nicht alle einzeln beschreiben, sondern euch einladen, einfach mal durchzuschauen, was hinter Lombok steckt und was es sonst noch kann.<\/p>\n
Unsere Erfahrungen mit Lombok<\/h1>\n
Kleine Klassen auch wirklich klein und \u00fcbersichtlich zu halten funktioniert mit Lombok sehr gut. Auch wenn sicherlich jede Entwicklungsumgebung Getter und Setter mittlerweile per Knopfdruck generiert, stehen sie dennoch im Code und bl\u00e4hen diesen unn\u00f6tig auf. Der Blick in die annotierte – beinahe leere – Klasse ist etwas gew\u00f6hnungsbed\u00fcrftig, beschleunigt allerdings auch das Arbeiten und lenkt unsere Aufmerksamkeit st\u00e4rker auf das Wesentliche – n\u00e4mlich die umzusetzenden Anforderungen.<\/p>\n
Verwendung und Einrichtung<\/h2>\n
Wir haben Lombok bisher nur zusammen mit IntelliJ in Verbindung mit Maven verwendet. Damit dies reibungslos funktioniert, braucht es folgende Zutaten:<\/p>\n
    \n
  1. Das Lombok-Plugin f\u00fcr IntelliJ\n