Hallo Spaß-Coder.

Wer kennt sie nicht: Datenklassen, die ausschließlich Attribute enthalten um Daten aufzunehmen und selbst keine Logik beinhalten? Sei es für die Entitäten der Datenbanktabellen oder einfache Datentranfsfer-Objekte. Diese Klasse könnte echt übersichtlich und aufgeräumt sein, wären da nicht diese Getter und Setter der Attribute, eine Implementierung der toString()-Methode, equals() oder hashCode().

Damit wird die vermeintlich einfache Klasse doch wieder recht unübersichtlich und aufgebläht. In diesem Artikel stellen wir eine Bibliothek vor, die es uns ermöglicht, auf das Wesentliche zu fokussieren.

Was macht Lombok?

Das Projekt Lombok^[1] stellt eine Java-Bibliothek zu Verfügung, die uns ermöglicht den Code deutlich aufgeräumter zu gestalten und die üblichen erforderlichen Methoden einfach durch Annotationen generieren zu lassen. Wie das aussehen kann, möchten wir euch anhand von ein paar Beispielen verdeutlichen. Dazu verwenden wir unser kleines TicTacToe Spiel, welches wir auch in anderen Artikeln bereits als Beispiel herangezogen hatten.

Geben und Nehmen

Unsere Entities sollen Daten tragen. Diese sind per Konvention zunächst einmal als private markiert. Damit wir doch Zugriff darauf haben, verwenden wir Getter und Setter. Im Normalfall können die nicht viel und verschmutzen unseren schönen Code.

Schauen wir doch mal, was Lombok in diesem Fall für uns tun kann:

Natural Pure Java

Mit Lombok-Magie

Java public class Player { private String name; private String symbol; private MoveStrategy strategy; public Player() { this.name = ""; this.strategy = null; this.symbol = "?"; } [...] public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSymbol() { return this.symbol; } public int getNextMove(GameState state) { return this.strategy.getNextPosition(state); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 public class Player {   private String name; private String symbol; private MoveStrategy strategy;   public Player() { this.name = ""; this.strategy = null; this.symbol = "?"; } [...] public String getName() { return name; }   public void setName(String name) { this.name = name; } public String getSymbol() { return this.symbol; } public int getNextMove(GameState state) { return this.strategy.getNextPosition(state); } }

Java public class Player { @Getter @Setter private String name; @Getter private String symbol; private MoveStrategy strategy; public Player() { this.name = ""; this.strategy = null; this.symbol = "?"; } [...] public int getNextMove(GameState state) { return this.strategy.getNextPosition(state); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class Player {   @Getter @Setter     private String name;     @Getter private String symbol;     private MoveStrategy strategy;   public Player() { this.name = ""; this.strategy = null; this.symbol = "?"; } [...]   public int getNextMove(GameState state) { return this.strategy.getNextPosition(state); } }

Durch die beiden einfachen Annotationen @Getter und @Setter lassen sich in diesem Beispiel 10 Zeilen Code sparen. Das schöne daran ist, dass nun gut sichtlich wird, dass die Methode getNextMove() kein klassischer Getter ist, sondern über eine Strategie ein bestimmtes Verhalten erzeugt (dazu kommen wir in einem anderen Artikel noch). So erkennen wir den wichtigen Teil unseres Codes viel schneller.

Nullen sind hier nicht erlaubt!

Frei nach dem Prinzip fail fast wollen wir oft die Eingangsparameter unserer Methoden prüfen. Die häufigste Prüfung ist dabei die Prüfung darauf, dass der übergebene Parameter nicht null ist.

Auch hier schauen wir mal, wie Lombok uns das Leben vereinfacht:

Natural Pure Java

Mit Lombok-Magie

Java public class Player { [...] public Player(PlayerData playerData) { if(playerData == null) { throw new NullPointerException("playerData"); } this.name = playerData.getName(); this.symbol = playerData.getSymbol(); this.strategy = playerData.getStrategy(); } [...] } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Player {   [...] public Player(PlayerData playerData) {         if(playerData == null) {             throw new NullPointerException("playerData");         } this.name = playerData.getName(); this.symbol = playerData.getSymbol(); this.strategy = playerData.getStrategy(); }   [...] }

Java public class Player { [...] public Player(@NonNull PlayerData playerData) { this.name = playerData.getName(); this.symbol = playerData.getSymbol(); this.strategy = playerData.getStrategy(); } [...] } 1 2 3 4 5 6 7 8 9 10 11 12 13 public class Player { [...]   public Player(@NonNull PlayerData playerData) { this.name = playerData.getName(); this.symbol = playerData.getSymbol(); this.strategy = playerData.getStrategy(); }   [...]   }

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üfendem Parameter.

Noch besser: Kombinieren wir z.B. die @Setter-Annotation mit der @NonNull-Annotation, kümmert sich Lombok sogar gleich darum:

Natural Pure Java

Mit Lombok-Magie

Java public class Player { private String name; public String getName() { return name; } public void setName(String name) { if(name == null) { throw new NullPointerException("name"); } this.name = name; } [...] } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class Player {     private String name;       public String getName() {         return name;     }       public void setName(String name) {         if(name == null) {             throw new NullPointerException("name");         }         this.name = name;     }       [...]   }

Java public class Player { @Getter @Setter @NonNull private String name; [...] } 1 2 3 4 5 6 7 public class Player {     @Getter @Setter @NonNull     private String name;     [...]   }

Drei Annotations anstelle von 9 Zeilen Code, die in aller Regel immer gleich aussehen.

Vergleichende Objekte

Werfen wir auch noch einen Blick auf das Thema equals und hashCode, welches wir eingangs des Artikels angesprochen haben:

Natural Pure Java  (IDE-generiert)

Mit Lombok-Magie

Java public class Player { [...] @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } Player player = (Player) o; return Objects.equals(name, player.name) && Objects.equals(symbol, player.symbol); } @Override public int hashCode() { return Objects.hash(name, symbol); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class Player {       [...]       @Override     public boolean equals(Object o) {         if (this == o) {             return true;         }         if (o == null || getClass() != o.getClass()) {             return false;         }         Player player = (Player) o;         return Objects.equals(name, player.name) &&                 Objects.equals(symbol, player.symbol);     }       @Override     public int hashCode() {         return Objects.hash(name, symbol);     } }

Java @EqualsAndHashCode(exclude = {"strategy"}) public class Player { [...] } 1 2 3 4 5 6 @EqualsAndHashCode(exclude = {"strategy"}) public class Player {       [...]   }

Auf der einen Seite durch IntelliJ generierte equals– und hashCode-Methoden, bei denen die Variable strategy aus dem Vergleich ausgelassen wurde. Auf der anderen Seite die Klasse mit der Annotation @EqualsAndHashCode, sowie einer ergänzenden Anweisung, welche Variablen ausgelassen werden sollen (in unserem Fall eben strategy). Übersichtlich, oder?

Und nun, alle zusammen…

Als letztes möchten wir noch ein Beispiel für echte, dumme Datentransportobjekte verwenden. Diesmal nehmen wir als Beispiel nicht mehr die Klasse Player, die hatte ja durch die Delegation der Aufgabe an die übergebene Strategie schon ein bisschen Intelligenz an Bord.

Stattdessen muss diesmal die Klasse PlayerData als Beispiel herhalten. Diese besteht aus drei Eigenschaften, mit Gettern, einem Konstruktor mit allen Werten als Übergabeparameter, equals, hashCode, toString, alles was man eben so braucht, wenn man als Datentransportobjekt was auf sich hält.

Natural Pure Java  (teilweise IDE-generiert)

Mit Lombok-Magie

Java public class PlayerData { private final String name; private final String symbol; private final MoveStrategy strategy; public PlayerData(String name, String symbol, MoveStrategy strategy) { this.name = name; this.symbol = symbol; this.strategy = strategy; } public String getName() { return name; } public String getSymbol() { return symbol; } public MoveStrategy getStrategy() { return strategy; } @Override public String toString() { return "PlayerData{" + "name='" + name + '\'' + ", symbol='" + symbol + '\'' + ", strategy=" + strategy + '}'; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } PlayerData that = (PlayerData) o; return Objects.equals(name, that.name) && Objects.equals(symbol, that.symbol) && Objects.equals(strategy, that.strategy); } @Override public int hashCode() { return Objects.hash(name, symbol, strategy); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 public class PlayerData {     private final String name;     private final String symbol;     private final MoveStrategy strategy;       public PlayerData(String name, String symbol, MoveStrategy strategy) {         this.name = name;         this.symbol = symbol;         this.strategy = strategy;     }       public String getName() {         return name;     }       public String getSymbol() {         return symbol;     }       public MoveStrategy getStrategy() {         return strategy;     }       @Override     public String toString() {         return "PlayerData{" +                 "name='" + name + '\'' +                 ", symbol='" + symbol + '\'' +                 ", strategy=" + strategy +                 '}';     }       @Override     public boolean equals(Object o) {         if (this == o) {             return true;         }         if (o == null || getClass() != o.getClass()) {             return false;         }         PlayerData that = (PlayerData) o;         return Objects.equals(name, that.name) &&                 Objects.equals(symbol, that.symbol) &&                 Objects.equals(strategy, that.strategy);     }       @Override     public int hashCode() {         return Objects.hash(name, symbol, strategy);     } }

Java @Data public class PlayerData { private final String name; private final String symbol; private final MoveStrategy strategy; } 1 2 3 4 5 6 @Data public class PlayerData { private final String name;     private final String symbol;     private final MoveStrategy strategy; }

Ein Wort: @Data. Reicht oder? 😉

Und sonst?

Die Projektseite enthält eine sehr gute (englischsprachige) Beschreibung der Funktionalität, weshalb wir hier nicht alle einzeln beschreiben, sondern euch einladen, einfach mal durchzuschauen, was hinter Lombok steckt und was es sonst noch kann.

Unsere Erfahrungen mit Lombok

Kleine Klassen auch wirklich klein und übersichtlich 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ähen diesen unnötig auf. Der Blick in die annotierte – beinahe leere – Klasse ist etwas gewöhnungsbedürftig, beschleunigt allerdings auch das Arbeiten und lenkt unsere Aufmerksamkeit stärker auf das Wesentliche – nämlich die umzusetzenden Anforderungen.

Verwendung und Einrichtung

Wir haben Lombok bisher nur zusammen mit IntelliJ in Verbindung mit Maven verwendet. Damit dies reibungslos funktioniert, braucht es folgende Zutaten:

1. Das Lombok-Plugin für IntelliJ
   • seit Version 2020.3 ist Lombok gebündelt in IntelliJ enthalten
   • Für ältere Versionen einfach wie alle Plugins installieren, ist unter „Lombok“ im Plugin-Repository zu finden
2. Die Abhängigkeit zu Lombok in der pom.xml
   
   XHTML

   <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.6</version> </dependency>

   1 2 3 4 5

   <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.6</version> </dependency>

3. In den Einstellungen ist die Verarbeitung von Annotationen zu aktivieren (Settings > Build, Execution, Deployment > Compiler > Annotation Processors > Enable Annotation Processing).

Lombok funktioniert auch mit anderen IDEs, etwa Eclipse. Details dazu sind ebenfalls auf der Projektseite von Lombok zu finden.

Zusammenfassung

In diesem Artikel haben wir euch eine Bibliothek vorgestellt, die das Leben eines Entwicklers vereinfachen kann und Java-Klassen aufgeräumt und damit übersichtlich hält. Es gibt keinen Grund Lombok nicht einmal auszuprobieren. Selbst wenn ihr euch nach einiger Zeit im Projekt dafür entscheiden solltet, Lombok nicht mehr zu verwenden, könnt ihr die Annotationen mit Hilfe von Delombok sehr leicht wieder in „normalen“ Java-Code überführen.

Welche Bibliothek unterstützt euch beim Sauberhalten eures Codes?

Eure Spaß-Coder

Referenzen:

• ^[1] https://projectlombok.org/