Projeto Java Lombok

Tutoriais

Java

O Projeto Lombok é uma ferramenta muito útil para projetos Java, pois reduz o código repetitivo.

Declaração do Problema

No debate entre Java e outras linguagens, o primeiro argumento dos defensores de outras linguagens é que o Java exige muito código repetitivo e você simplesmente não consegue superar isso, ficando indefeso. O mesmo problema também é relatado em várias plataformas e comunidades de desenvolvedores. Vamos ver um exemplo de código que possui código repetitivo.

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.

Projeto Lombok

O Projeto Lombok é uma biblioteca Java que se integra automaticamente ao seu editor e ferramentas de construção, ajudando a reduzir o código repetitivo. Vamos ver como configurar o projeto Lombok primeiro.

Como o Projeto Lombok para Java funciona?

Lombok possui várias anotações que podem ser usadas em nosso código e que são processadas durante o tempo de compilação, e a expansão de código apropriada ocorrerá com base na anotação utilizada. Lombok apenas reduz o código em tempo de visualização, após a compilação o código de byte é injetado com todo o boilerplate. Isso ajuda a manter nossa base de código pequena, limpa, fácil de ler e manter.

Projeto Lombok Maven

Adicionar o Lombok em seu projeto é simples. Basta adicionar a dependência abaixo em seu arquivo pom.xml do projeto Maven.

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

Adicionando o Plugin Lombok no IDE (Eclipse)

Aqui estão os passos de instalação para Windows:

Baixe o arquivo jar em https://projectlombok.org/download ou use o jar que foi baixado a partir da sua construção Maven.
Execute o comando no terminal: java -jar lombok.jar
Este comando abrirá uma janela como mostrado na imagem abaixo, instale e saia do instalador e reinicie o Eclipse.

Se você estiver no MacOS, então os seguintes são os passos para usar o Lombok em seu projeto.

Copie o arquivo lombok.jar para o diretório Eclipse.app/Contents/MacOS.
Adicione -javaagent:lombok.jar ao final do arquivo Eclipse.app/Contents/Eclipse/eclipse.ini.
Reinicie o Eclipse e habilite o “Processamento de Anotações” nas propriedades do projeto, conforme mostrado na imagem abaixo.

Pico do Lombok no esboço do Eclipse

Após a instalação, vamos verificar como podemos ver nosso código de boilerplate reduzido? Eu recriei a mesma classe como PersonLombok. O esboço do Eclipse exibe getter e setter para o firstName. Isso foi feito com base nas anotações @Getter e @Setter do Lombok definidas para a variável de instância firstName.

Pico do Lombok no bytecode Java

Podemos verificar a adição dos métodos getter e setter para o firstName no bytecode da classe.

Anotações do Projeto Lombok

O Projeto Lombok fornece muitas anotações que ajudam a reduzir o código redundante em vários cenários. Vamos dar uma olhada em algumas delas.

Anotação de Construtor
```
@AllArgsConstructor
public class PersonLombok {
	@NonNull String firstName;
	String lastName;
	LocalDate dateOfBirth;
	public static void main(String[] args) {
		new PersonLombok(null, "Kumar", LocalDate.now());
	}
}
```
O código acima injeta o seguinte na classe:
- Um construtor com todos os argumentos por @AllArgsConstructor
- Verificação de nulo ao passar um argumento no construtor por @NonNull. A anotação @NonNull também pode ser usada ao passar um argumento como parâmetro para um método.
Aqui está o resultado da execução do programa. @RequiredArgsConstructor gera um construtor com 1 parâmetro para cada campo que requer manipulação especial. Todos os campos finais não inicializados recebem um parâmetro, assim como quaisquer campos marcados como @NonNull que não são inicializados onde são declarados.
Anotações de Getter/Setter

Essas anotações podem ser usadas no nível do campo ou da classe. Se você deseja um controle mais detalhado, use-as no nível do campo. Quando usadas no nível da classe, todos os getter/setters são criados. Vamos trabalhar na classe que criamos acima.
```
@AllArgsConstructor @Getter @Setter
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
anotações equals, hashCode e toString

É recomendado sobrescrever os métodos hashCode() e equals() ao criar uma classe. No Lombok, temos a anotação @EqualsAndHashCode que injeta código para os métodos equals() & hashCode() pois eles trabalham juntos. Adicionalmente, a anotação @ToString fornece uma implementação toString(). Vamos ver isso:
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Agora conseguimos criar a classe Person sem nenhum código repetitivo com a ajuda das anotações do Lombok. No entanto, fica ainda melhor, podemos substituir todas as anotações usadas na classe acima por @Data e obter a mesma funcionalidade.

Padrões de Design baseados em Anotações

@Builder permite gerar automaticamente o código necessário para tornar sua classe instanciável usando o padrão de construtor.

@Builder
public class Employee {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;

	public static void main(String[] args) {
		Employee emp = new EmployeeBuilder().firstName("Rakesh")
				.lastName("Kumar")
				.dateOfBirth(LocalDate.now())
				.build();
	}
}

@Delegate gera métodos de delegação que encaminham a chamada para este campo no qual a anotação é usada. “Prefira Composição em vez de Herança“, mas isso cria muito código repetitivo semelhante ao Padrão de Adaptador. O Lombok pegou a dica da anotação com o mesmo nome em Groovy ao implementar essa funcionalidade. Vamos ver uma implementação:

@RequiredArgsConstructor
public class AdapterImpl implements Adapter {
	@Delegate
	private final Adaptee instance;

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

interface Adapter {
	public void display();
}

class Adaptee {
	public void display() {
		System.out.println("Em Adaptee.display()");
	}
}

O Lombok fornece funcionalidade para controle detalhado em todas as anotações.

Boiler-Plate: Os Arquitetos Java Estão Ouvindo?

Sim, são. Você precisa entender que, ao contrário de outras linguagens, o Java tem se esforçado ao máximo para atualizar a linguagem sem quebrar qualquer base de código existente em versões mais antigas do Java. Isso por si só é uma tarefa enorme e não pode ser subestimada. Eles já estão modificando e aprimorando as capacidades de inferência de tipo na linguagem, o que já foi implementado. Uma das características importantes planejadas para o Java 10 é a Infêrencia de Tipo de Variável Local. Embora a característica esteja mais relacionada à adição de tipagem dinâmica do que à redução do código boilerplate, é uma pequena contribuição significativa para lidar com o código boilerplate.

Resumo

Reduzir o código boilerplate ajuda na melhor legibilidade, e menos código também significa menos erros. O Project Lombok é amplamente utilizado hoje em quase todas as principais organizações. Nós fornecemos as características mais úteis do Lombok. Esperamos que você experimente. Código Fonte: Você pode visitar meu link no Github para baixar o código fonte completo usado neste tutorial.

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

Anotação de Construtor

Anotações de Getter/Setter

anotações equals, hashCode e toString

Padrões de Design baseados em Anotações