Proyecto Java Lombok

Tutoriales

Java

Proyecto Lombok es una herramienta muy útil para proyectos Java que reduce el código redundante.

Declaración del Problema

En el debate entre Java y otros lenguajes, el primer argumento de los seguidores de otros idiomas es que Java requiere mucho código redundante y simplemente no puedes superarlo, quedas indefenso. El mismo problema también se informa en varias plataformas y comunidades de desarrolladores. Veamos un ejemplo de código que tiene código redundante.

package com.askrakesh.java.manage_boilerplate;

import java.time.LocalDate;

public class Person {

	String firstName;
	String lastName;
	LocalDate dateOfBirth;

	public Person(String firstName, String lastName, LocalDate dateOfBirth) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
		this.dateOfBirth = dateOfBirth;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public LocalDate getDateOfBirth() {
		return dateOfBirth;
	}

	public void setDateOfBirth(LocalDate dateOfBirth) {
		this.dateOfBirth = dateOfBirth;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((dateOfBirth == null) ? 0 : dateOfBirth.hashCode());
		result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
		result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (dateOfBirth == null) {
			if (other.dateOfBirth != null)
				return false;
		} else if (!dateOfBirth.equals(other.dateOfBirth))
			return false;
		if (firstName == null) {
			if (other.firstName != null)
				return false;
		} else if (!firstName.equals(other.firstName))
			return false;
		if (lastName == null) {
			if (other.lastName != null)
				return false;
		} else if (!lastName.equals(other.lastName))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Person [firstName=" + firstName + ", lastName=" + lastName + "dateOfBirth=" + dateOfBirth + "]";
	}

}

A class should have getter-setters for the instance variables, equals & hashCode method implementation, all field constructors and an implementation of toString method. This class so far has no business logic and even without it is 80+ lines of code. This is insane.

Proyecto Lombok

Proyecto Lombok es una biblioteca Java que se integra automáticamente en tu editor y herramientas de construcción, ayudando a reducir el código redundante. Veamos cómo configurar el proyecto Lombok primero.

¿Cómo funciona Java Project Lombok?

Lombok tiene varias anotaciones que se pueden usar dentro de nuestro código que se procesa durante el tiempo de compilación y se realizará una expansión de código apropiada según la anotación utilizada. Lombok solo hace la reducción de código en el tiempo de vista, después de compilar el byte code se inyecta con todo el código boilerplate. Esto ayuda a mantener nuestro código base pequeño, limpio y fácil de leer y mantener.

Proyecto Lombok Maven

Agregar Lombok en tu proyecto es simple. Simplemente agrega la siguiente dependencia en el archivo pom.xml de tu proyecto Maven.

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

Agregando el complemento Lombok en el IDE (Eclipse)

Aquí están los pasos de instalación para Windows:

Descarga el jar desde https://projectlombok.org/download o utiliza el jar que se descargó de tu construcción Maven.
Ejecuta el comando en la terminal: java -jar lombok.jar
Este comando abrirá una ventana como se muestra en la imagen a continuación, instala y cierra el instalador y reinicia Eclipse.

Si estás en MacOS, entonces los siguientes son los pasos para usar Lombok en tu proyecto.

Copia lombok.jar en el directorio Eclipse.app/Contents/MacOS.
Agrega -javaagent:lombok.jar al final del archivo Eclipse.app/Contents/Eclipse/eclipse.ini.
Reinicia Eclipse y habilita el “Procesamiento de anotaciones” en las propiedades del proyecto como se muestra en la imagen de abajo.

Vistazo de Lombok en el esquema de Eclipse

Después de la instalación, ¿vamos a verificar cómo podemos ver nuestro código reducido? He recreado la misma clase como PersonLombok. El esquema de Eclipse muestra el getter y setter para el nombre. Esto se hizo basado en las anotaciones @Getter y @Setter de Lombok configuradas para la variable de instancia firstName.

Vistazo de Lombok en el bytecode de Java

Podemos verificar la adición de los métodos getter y setter para firstName desde el bytecode de la clase.

Annotations del Proyecto Lombok

El Proyecto Lombok proporciona muchas anotaciones que ayudan a reducir el código redundante en varios escenarios. Vamos a revisar algunas de ellas.

Anotación de Constructor
```
@AllArgsConstructor
public class PersonLombok {
	@NonNull String firstName;
	String lastName;
	LocalDate dateOfBirth;
	public static void main(String[] args) {
		new PersonLombok(null, "Kumar", LocalDate.now());
	}
}
```
El código anterior inyecta lo siguiente en la clase:
- Un constructor con todos los argumentos por @AllArgsConstructor
- Comprobación de nulos al pasar un argumento en el constructor por @NonNull. La anotación @NonNull también se puede usar al pasar un argumento como parámetro a un método
Aquí está el resultado de la ejecución del programa. @RequiredArgsConstructor genera un constructor con 1 parámetro para cada campo que requiere un manejo especial. Todos los campos finales no inicializados obtienen un parámetro, así como cualquier campo marcado como @NonNull que no esté inicializado donde se declara.
Anotaciones de Getter/Setter

Estas anotaciones pueden usarse tanto a nivel de campo como de clase. Si deseas un control más detallado, úsalas a nivel de campo. Cuando se usan a nivel de clase, se crean todos los getters/setters. Trabajemos en la clase que habíamos creado anteriormente.
```
@AllArgsConstructor @Getter @Setter
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Anotaciones equals, hashCode y toString

Se recomienda sobrescribir los métodos hashCode() y equals() al crear una clase. En Lombok tenemos la anotación @EqualsAndHashCode que inyecta código para los métodos equals() y hashCode() ya que van juntos. Además, una anotación @ToString proporciona una implementación de toString(). Veamos esto:
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Ahora hemos logrado crear la clase Person sin ningún código de boilerplate con la ayuda de las anotaciones de Lombok. Sin embargo, aún mejor, podemos reemplazar todas las anotaciones utilizadas en la clase anterior con @Data y obtener la misma funcionalidad.

Patrones de diseño basados en anotaciones

@Builder te permite generar automáticamente el código necesario para que tu clase sea instanciable utilizando el patrón del constructor.

@Builder
public class Empleado {
	String nombre;
	String apellido;
	LocalDate fechaNacimiento;

	public static void main(String[] args) {
		Empleado emp = new EmployeeBuilder().nombre("Rakesh")
				.apellido("Kumar")
				.fechaNacimiento(LocalDate.now())
				.build();
	}
}

@Delegate genera métodos delegados que reenvían la llamada a este campo en el que se utiliza la anotación. “Favorecer la composición sobre la herencia“, pero esto crea mucho código repetitivo similar al patrón de adaptador. Lombok tomó la pista de la anotación del mismo nombre de Groovy mientras implementaba esta funcionalidad. Veamos una implementación:

@RequiredArgsConstructor
public class AdapterImpl implements Adaptador {
	@Delegate
	private final Adaptee instancia;

	public static void main(String[] args) {
		AdapterImpl impl = new AdapterImpl(new Adaptee());
		impl.mostrar();
	}
}

interface Adaptador {
	public void mostrar();
}

class Adaptee {
	public void mostrar() {
		System.out.println("En Adaptee.mostrar()");
	}
}

Lombok proporciona funcionalidad para un control detallado en todas las anotaciones.

Código boilerplate: ¿Los arquitectos de Java están escuchando?

Sí, lo son. Necesitas entender que, a diferencia de otros lenguajes, Java ha cuidado al máximo la actualización del lenguaje para que no rompa ningún código existente que esté en versiones anteriores de Java. Esto en sí mismo es una tarea enorme y no se puede subestimar. Ya están modificando y mejorando las capacidades de inferencia de tipos en el lenguaje, que se han implementado. Una de las características importantes planeadas para Java 10 es Inferencia de Tipo de Variable Local. Aunque la característica tiene más que ver con agregar tipado dinámico que con el boilerplate, es solo una pequeña gota en el océano para manejar el código boilerplate.

Resumen

Reducir el código boilerplate ayuda a una mejor legibilidad, menos código también significa menos errores. Project Lombok se utiliza ampliamente hoy en día en casi todas las organizaciones importantes. Te proporcionamos las características más útiles de Lombok. Esperamos que lo pruebes. Código Fuente: Puedes visitar mi enlace de Github para descargar el código fuente completo utilizado en este tutorial.

Source:
https://www.digitalocean.com/community/tutorials/java-project-lombok

Anotación de Constructor

Anotaciones de Getter/Setter

Anotaciones equals, hashCode y toString

Patrones de diseño basados en anotaciones