Project Lombok

Category: 

Mit Java hat man häufig das Problem, dass man mehr Code schreiben muss, als man eigentlich will. Project Lombok kann dazu genutzt werden diesen Boilerplate Code auf ein Minimum zu reduzieren.

Einführung

Bestes Beispiel für Boilerplate Code sind wohl die Getter und Setter. Häufig setzt man die Sichtbarkeit von Feldern auf private und macht sie nur über diese Getter/Setter zugänglich. Dies mag oft Sinnvoll sein, jedoch wird dadurch der Code sehr schnell unübersichtlich. Insbesondere wenn die Setter nichts weiter machen, als das Feld auf den Wert des Parameters zu setzen.
public class Person {
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name=name;
  }
  private int age
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  // ...
}

In diesem Beispiel wollen wir eigentlich nur zwei Felder anlegen, erzeugen aber zusätzliche 12 Zeilen Code für Getter/Setter.

Lombok löst nun dieses Problem, indem es sich in die IDE einklinkt und die Getter/Setter zur Compile Time erzeugt. Welche Felder um Getter/Setter erweitert werden sollen, wird durch Annotationen bestimmt. Das obige Beispiel lässt sich mit Lombok auf die folgenden Zeilen reduzieren:

public class Person {
  @Getter @Setter private String name;
  @Getter @Setter private int age;
  // ...
}

Innerhalb der IDE werden nun passende Getter und Setter angezeigt, obwohl sie im Code noch gar nicht drin stehen. Dadurch werden die Klassen viel übersichtlicher.
Standardmäßig ist die Sichtbarkeit der Getter/Setter public, auf Wunsch kann man diese aber auch anpassen:

@Getter @Setter(AccessLevel.PROTECTED) private String name;

Nun ist der Getter zwar public, der Setter ist jedoch protected.
Auf einige weitere wichtige Annotationen werde ich im folgenden eingehen, für eine komplette Liste kann man sich die feature-Seite von Lombok ansehen: Project Lombok.

@NonNull und @Cleanup

Neben den Getter/Setter Methoden gibt es natürlich noch mehr Stellen, an denen man dazu gezwungen ist sich wiederholenden Code zu schreiben. Beispielsweise ist es oft von Nöten, sicherzustellen dass ein Parameter nicht null ist:

public void doSomething(String value) {
  if(value==null) {
    throw new NullPointerException("value");
  }
  // do something
}

Diese Sicherheitsüberprüfung ist oft sehr wichtig, jedoch etwas lästig. Mit Lombok kann man auch dies vereinfachen:

public void doSomething(@NonNull String value) {
  // do something
}

Auch das Resourcen Management kann verbessert werden:

public void read(String file) throws IOException {
  InputStream in = new FileInputStream(file);
  try {
    //read some stuff
  } finally {
    if(in != null) {
      in.close();
    }
  }
}

Lombok Version:

public void read(String file) throws IOException {
  @CleanUp InputStream in = new FileInputStream(file);
  //read some stuff
}

Reine Datenklassen mit @Data

Manchmal benötigt man eine reine Datenklasse. Bei dieser sollen alle Felder mit Getter/Setter Methoden versehen werden, sowie die equals und hashcode Methoden überschrieben werden. Natürlich kann man dazu manuell die entsprechenden Lombok Annotationen platzieren, jedoch gibt es hierfür die @Data Annotation.

@Data
public class Vector {
  private float x;
  private float y;
  private float z;
}

Der obige Code ist äquivalent zu dem folgenden reinen Java-Code:

public class Vector {
  private float x;
  private float y;
  private float z;
  public float getX() { return x; }
  public void setX(float x) { this.x = x; }
  public float getY() { return y; }
  public void setY(float y) { this.y = y; }
  public float getZ() { return z; }
  public void setZ(float z) { this.z = z; }
  public boolean equals(final Object o) {
    if (o == this) return true;
    if (o == null) return false;
    if (o.getClass() != this.getClass()) return false;
    final Vector other = (Vector)o;
    if(this.x != other.x) return false;
    if(this.y != other.y) return false;
    if(this.z != other.z) return false;
    return true;
  }
  public int hashcode() {
    //...
  }
  public String toString() {
    //...
  }
}

Lombok installieren

Erst einmal muss man natürlich Lombok herunterladen: Download
Die heruntergeladene jar Datei muss man nun starten, wodurch Lombok sich in die IDE integriert. Unter Umständen muss man dazu die jar als Administrator ausführen. Falls Lombok keine IDE findet, muss man in der GUI einmal kurz den Pfad zur IDE angeben:

Wenn Lombok installiert wurde, muss man die IDE ggf. neustarten. Anschließend muss man nur noch das jar-Archiv jedem Projekt hinzufügen, indem man Lombok nutzen möchte. Im Falle von Eclipse macht man dazu einen Rechtsklick auf das Projekt -> Build Path -> Add External Archives und wählt dort das Archiv aus. Anschließend kann man direkt mit Lombok loslegen.
Tags: