Lombok – mniej kodu a ten sam efekt!

Problem konieczności pisania tego samego kodu przy deklaracji nowej klasy, konfigurowaniu projektu czy też wyłapywaniu wyjątków prześladował programistów JAVA od samego początku. Ilość czasu, jaką trzeba poświęcić na pisanie getterów, seterów, metod equals i hashcode czy też tworzenie różnych wariantów konstruktorów jest niewspółmiernie duża do korzyści z tego wynikających. Może jednak da się uniknąć tej „małpiej roboty”?

Co to jest Lombok?

Nie, nie chodzi tu o indonezyjską wyspę, która notabene leży niedaleko wyspy JAWA. Jest to jednak biblioteka, która ma za zadane znacząco skracać kod pisany w języku JAVA. Cóż za zbieżność nazw 🙂 Projekt Lombok to darmowe narzędzie do generowania najczęściej powtarzającego się kodu. Za pomocą adnotacji jesteśmy w stanie znacząco zmniejszyć ilość linii kodu nie wpływając tym samym na jego użyteczność. Dodatkowo wszystko to dzieję się podczas budowania projektu. Generowanie kodu podczas budowania aplikacji ma jedną bardzo dużą zaletę. Podczas implementacji nie widzimy kodu, który i tak zawsze wygląda tak samo. Wpływa to na poprawę czytelności oraz pozwala się skupić bardziej na implementowaniu logiki biznesowej.

Zobacz jak dodać Lombok to Twojego projektu oraz jak wykorzystać najczęściej używane adnotacje.

Jak dodać Lombok do projektu?

Maven

<dependencies>
	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<version>1.18.12</version>
		<scope>provided</scope>
	</dependency>
</dependencies>

Gradle

repositories {
	mavenCentral()
}

dependencies {
	compileOnly 'org.projectlombok:lombok:1.18.12'
	annotationProcessor 'org.projectlombok:lombok:1.18.12'
	
	testCompileOnly 'org.projectlombok:lombok:1.18.12'
	testAnnotationProcessor 'org.projectlombok:lombok:1.18.12'
}

Ant

<javac srcdir="src" destdir="build" source="1.8">
	<classpath location="lib/lombok.jar" />
</javac>

Dostępne adnotacje (w wersji stabilnej)

@NonNull – generuje kod, który sprawdza czy parametr metody lub konstruktora nie posiada wartości null. Jeśli parametr posiada wartość null to zostanie wyrzucony wyjątek NullPointerException.

import lombok.NonNull;

public class SomeClass {
   
   public SomeClass(@NonNull String param) {
       //Don't need to check if param is null or not. You can use it as it is.
       System.println(param.substring(0, 1));
   }

   public void someMothod(@NonNull String anotherParam) {
       //Same here.
       System.println(anotherParam.substring(0, 1));
   }
}

@Cleanup– automatycznie czyści dany zasób jeśli proces wykonywania programu opuści blok kodu. Standardowo adnotacja ta wywołuję metodę „close()” na obiekcie, przed którym została dodana. Jak widać w załączonym niżej kodzie, nie ma potrzeby tworzenia konstrukcji try final aby wywołać metodę „close()” dla obiektów „InputStream” i „OutputStream”

import lombok.Cleanup;
import java.io.*;

public class CleanupExample {
  public static void main(String[] args) throws IOException {
    @Cleanup InputStream in = new FileInputStream(args[0]);
    @Cleanup OutputStream out = new FileOutputStream(args[1]);
    byte[] b = new byte[10000];
    while (true) {
      int r = in.read(b);
      if (r == -1) break;
      out.write(b, 0, r);
    }
  }
}

Jeśli dany obiekt nie posiada metody „close()” można podać nawę innej metody, która ma być wykonana po wyjścu z danego bloku kodu. W poniższym przykładzie zostanie wywołana metoda „cleanResources()” zaimplementowana w klasie „SomeObject”.

@Cleanup("cleanResources") SomeObject someObject= new SomeObject();

@Getter/@Setter – generują gettery i settery. adnotacja „@Getter” z parametrem „lazy=true” pozwala na zdefiniowanie, że dane pole ma ładować dane w trybie „Lazy Loading”. Są to chyba najczęściej stosowane adnotacje z projektu Lombok.

import lombok.Getter;
import lombok.Setter;

public class Person {

   @Getter
   @Setter
   private int age;

   @Getter
   @Setter
   private String name;

   // you don't have to implement getters and setters yourself
}

@ToString i @EqualsAndHashCode – generują odpowiednio metody „toString()”, „equals()” oraz „hashCode()”. Dodajemy je przed definicją klasy.

import lombok.ToString;
import lombok.EqualsAndHashCode;

@ToString
@EqualsAndHashCode
public class Person {
   // some fields, getters and setters

   // you don't have to implement toString, equals and hashcode methods yourself
}

@NoArgsConstructor – tworzy konstruktor bezparametrowy.

import lombok.NoArgsConstructor;

@NoArgsConstructor 
public class Person {
   // non-parameter constructor will be created here
}

@RequiredArgsConstructor – tworzy konstruktor z parametrami, których wartości są przypisywane polom finalnym, które nie mają przypisanej wartości oraz tym oznaczonych adnotacją „@NonNull”.

import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class Person {

   private final int age = 10;
   
   @NonNull
   private String name;

   private String city;
   
   /**
   this will be generated by Lombok
   public RequiredArgsConstructor(String name) {
      this.name = name;
   }
   **/
}

@AllArgsConstructor – tworzy konstruktor ze wszystkimi parametrami odpowiadającymi polom klasy.

import lombok.AllArgsConstructor;

@AllArgsConstructor
public class Person {

   private int age = 10;
   private String name;
   private String city;
   
   /**
   this will be generated by Lombok
   public RequiredArgsConstructor(int age, String name, String city) {
      this.age = age;
      this.name = name;
      this.city = city;
   }
   **/
}

@Data – tworzy to samo co @ToString, @EqualsAndHashCode, @Getter, @Setter i @RequiredArgsConstructor. Innymi słowy, jest to skrót do najczęściej używanych ze sobą adnotacji Lombok’a.

import lombok.AccessLevel;
import lombok.Setter;
import lombok.Data;
import lombok.ToString;

@Data 
public class SomeClass{
  private final String name; //setter will be not generated because this field is final
  private int count; // setter and getter will be created
  private String[] tags; // setter and getter will be created
  
  //equals, hashCode and toString methods and constructor will be created here
}

@Value – jest to niemutowana wersja adnotacji @Data. Umieszczenie tej adnotacji przed definicją klasy tworzy ją finalną. Wszystkie pola zostaną oznaczone jako final. Dodatkowo jeśli nie posiadają jawnie zdefiniowanego modyfikatora dostępu, to zostanie im przydzielony modyfikator private. Nie zostaną wygenerowane dla nich settery. Poza tym wszystkie inne właściwości adnotacji @Data pozostają niezmienne.

import lombok.AccessLevel;
import lombok.experimental.NonFinal;
import lombok.experimental.Value;
import lombok.experimental.Wither;
import lombok.ToString;

@Value 
public class SomeClass{ //this class will be marked as final 
  String name; //this will be private final field
  int count; // this will be also private and final field
  protected String[] tags; // this will be protected final field
}

Podsumowanie

Oczywiście, nie są to jedyne adnotacje dostępne w Lombok’u. Istnieje jeszcze kilka adnotacji dostępnych w wersji stabilnej oraz cała masa nowych feature’ów, które są jeszcze w fazie testowania – experimental.

Dodatkowo Lombok udostępnia jeszcze możliwość dynamicznego typowania zmiennych. Ten temat zostanie poruszony w innym poście już niedługo!

Jak zawsze zachęcam Cię do udostępnienia tej treści i zapisania się na listę mailingową, aby nie ominą Cię żaden nowy post na blogu!

Przydatne linki:
https://projectlombok.org/
https://projectlombok.org/features/all