Weniger aber ausdrucksstarker Code mit Project Lombok

Es gibt Libraries und Frameworks, die gehören zum täglichen Handwerkszeug eines Java-Entwicklers. Sei es das bevorzugte Test-Framework oder nützliche Libraries wie Guava. Für mich gehört seit langer Zeit Project Lombok dazu. Es erfüllt drei Kriterien, die mir im Entwickleralltag sehr wichtig sind: Lombok erlaubt mir überflüssigen Boilerplate Code zu vermeiden, reduziert Fehlerquellen und spielt sehr gut mit anderen Frameworks zusammen.

Warum ich von Lombok so begeistert bin, lässt sich mit einem Blick auf etwas Code, der sich so oder so ähnlich in vielen Java-Projekten finden lässt, demonstrieren:

1public class Person {
2    private String firstName;
3    private String familyName;
4 
5    public Person(String firstName, String lastName){
6        this.firstName = firstName;
7        this.lastName = lastName;
8    }
9 
10    public String getFirstName() {
11        return firstName;
12    }
13 
14    public void setFirstName(String firstName) {
15        this.firstName = firstName;
16    }
17 
18    public String getFamilyName() {
19        return familyName;
20    }
21 
22    public void setFamilyName(String familyName) {
23        this.familyName = familyName;
24    }
25 
26    @Override
27    public boolean equals(Object o) {
28        if (this == o) return true;
29        if (o == null || getClass() != o.getClass()) return false;
30 
31        Person person = (Person) o;
32 
33        if (firstName != null ? !firstName.equals(person.firstName) : person.firstName != null) return false;
34        return !(familyName != null ? !familyName.equals(person.familyName) : person.familyName != null);
35    }
36 
37    @Override
38    public int hashCode() {
39        int result = firstName != null ? firstName.hashCode() : 0;
40        result = 31 * result + (familyName != null ? familyName.hashCode() : 0);
41        return result;
42    }
43 
44    @Override
45    public String toString() {
46        return "Person{" +
47               "firstName='" + firstName + '\'' +
48               ", familyName='" + familyName + '\'' +
49               "}";
50    }
51}

Was direkt auffällt: In Java ist relativ viel Code notwendig um sehr wenig auszudrücken. In der Tat überlassen es viele Entwickler der IDE, den Code zu generieren und hier fängt das Problem an: Sobald eine Klasse verändert wird, müssen auch equals, hashCode und toString berücksichtigt und neue Getter und Setter geschrieben werden. Natürlich ist dies beonders fehleranfällig, wenn unter Zeitdruck noch schnell eine Klasse angepasst werden muss. Sprachen wie Scala und Groovy können dies definitiv besser.

Hier kommt Lombok ins Spiel, denn mit einer einzigen Annotation sieht die selbe Klasse schon viel übersichtlicher aus:

1@Data
2public class Person {
3    private String firstName;
4    private String familyName;
5 
6    public Person(String firstName, String lastName){
7        this.firstName = firstName;
8        this.lastName = lastName;
9    }
10}

Lombok generiert für uns alle Getter, Setter sowie hashCode, equals und toString. Da das Ganze zur compile time passiert, spielt Lombok auch sehr gut mit anderen Frameworks wie JPA zusammen.

Auch für die Generierung von Konstruktoren gibt es Annotationen (@Data) von Lombok:

1@Data
2@AllArgsConstructor
3public class Person {
4    private String firstName;
5    private String familyName;
6}

Ein weiterer Vorteil: Lombok ergänzt nur die fehlenden Methoden. Wenn es also einen Getter oder Setter gibt, der vom Standard abweicht, kann er problemlos ergänzt werden. Dieser fällt dann in der Klasse auch gleich viel stärker auf.

1@Data
2@AllArgsConstructor
3public class Person {
4    private String firstName;
5    private String familyName;
6 
7    public void setFamilyName(String familyName){
8        if(familyName == null || familyName.isEmpty()){
9            throw new IllegalArgumentException("Family name must be set.");
10        }
11        this.familyName = familyName;
12    }
13}

Aber Lombok kann noch mehr: Sobald Vererbung ins Spiel kommt, lässt sich einfach festlegen ob hashCode, equals und toString auch die Felder der Elternklasse berücksichtigen sollen:

1@Data
2@EqualsAndHashCode(callSuper = true)
3@ToString(callSuper = true)
4public class Developer extends Person{
5    private String favoriteFramework;
6}

Das Einsatzgebiet von Lombok beschränkt sich nicht nur darauf Java POJOs mit weniger Code zu schreiben. Auch für andere Dinge kann Lombok verwendet werden:

• Lombok bietet Annotationen für alle gängigen Logger-Frameworks um in einer Klasse einen Logger zu generieren.
• Mit @Builder kann ein POJO einfach um eine Builder-API erweitert werden.
• weitere Einsatzgebietet sind in der Dokumentation zu finden.

Lombok im Projekt verwenden

Alle notwendigen Informationen zu den Maven-Koordinaten (bzw. Ivy und Gradle) findet man auf der Download-Seite . Auf dieser Seite sind auch die IDE Plugins aufgelistet, die Lombok-Support anbieten. Dies ist gerade für Funktionen wie Autovervollständigung notwendig.

Für Eclipse reicht es die aktuelle Version von Lombok zu laden und das jar auszuführen. Es öffnet sich eine grafische Oberfläche die den Anwender durch die Installation führt. In IntelliJ kann das Plugin über die Plugin-Verwaltung installiert werden.

Alle, die gerne weniger Code schreiben möchten, sollten Lombok eine Chance geben. Was sind Eure bevorzugten Libraries und warum? Schreibt doch einen Kommentar und erzählt mehr über Eure Werkzeuge.