Projeto Java Lombok

Tutoriais

Java

O Projeto Lombok é uma ferramenta muito útil para projetos Java para reduzir o código boilerplate.

Declaração do Problema

Na discussão entre Java e outras linguagens, o primeiro golpe que você recebe dos apoiadores de outras linguagens é que o Java requer muito código boilerplate e você simplesmente não pode superá-lo, e fica 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 boilerplate.

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 conecta automaticamente ao seu editor e ferramentas de construção e ajuda a reduzir o código boilerplate. Vamos ver como configurar o projeto Lombok primeiro.

Como o Projeto Lombok do Java funciona?

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

Projeto Lombok Maven

Adicionar o Lombok em seu projeto é simples. Basta adicionar a dependência abaixo no arquivo pom.xml do seu 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 as etapas de instalação para o Windows:

Baixe o arquivo JAR em https://projectlombok.org/download ou use o JAR baixado do seu build Maven.
Execute o comando no terminal: java -jar lombok.jar
Este comando abrirá uma janela conforme mostrado na imagem abaixo; instale e saia do instalador e reinicie o Eclipse.

Se você estiver no MacOS, siga as etapas a seguir para usar o Lombok em seu projeto.

Copie 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 “Processamento de Anotações” nas propriedades do projeto, conforme mostrado na imagem abaixo.

Visualização do Lombok no contorno do Eclipse

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

Visualização do Lombok no bytecode Java

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

Anotações do Projeto Lombok

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

Anotação do Construtor
```
@AllArgsConstructor
public class PessoaLombok {
	@NonNull String primeiroNome;
	String sobrenome;
	LocalDate dataNascimento;
	public static void main(String[] args) {
		new PessoaLombok(null, "Kumar", LocalDate.now());
	}
}
```
O código acima injeta o seguinte na classe:
- Um construtor com todos os argumentos por meio de @AllArgsConstructor
- Verificação de nulo ao passar um argumento no construtor por meio de @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 tratamento especial. Todos os campos finais não inicializados recebem um parâmetro, assim como qualquer campo marcado com @NonNull que não é inicializado onde é declarado.
Anotações Getter/Setter

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

É recomendado substituir os métodos hashCode() e equals() ao criar uma classe. No Lombok, temos a anotação @EqualsAndHashCode, que injeta o código para os métodos equals() & hashCode(), já que eles são usados juntos. Além disso, a anotação @ToString fornece uma implementação para o método toString(). Vejamos:
```
@AllArgsConstructor @Getter @Setter
@EqualsAndHashCode 
@ToString
public class PersonLombok {
	String firstName;
	String lastName;
	LocalDate dateOfBirth;
}
```
Agora conseguimos criar a classe Person sem qualquer código repetitivo, graças às anotações do Lombok. E fica ainda melhor, podemos substituir todas as anotações usadas na classe acima com @Data e obter a mesma funcionalidade.

Padrões de Design baseados em Anotações

@Builder permite que você produza automaticamente o código necessário para que sua classe seja instanciável usando o padrão builder.

@Builder
public class Funcionário {
	String primeiroNome;
	String últimoNome;
	LocalDate dataDeNascimento;

	public static void main(String[] args) {
		Funcionário emp = new EmployeeBuilder().primeiroNome("Rakesh")
				.últimoNome("Kumar")
				.dataDeNascimento(LocalDate.now())
				.build();
	}
}

@Delegate gera métodos de delegação que encaminham a chamada para este campo no qual a anotação é usada. “Preferência por Composição sobre Herança“, mas isso cria muito código de boilerplate semelhante ao padrão Adapter. O Lombok pegou a pista da anotação de mesmo nome do Groovy ao implementar essa funcionalidade. Vamos ver uma implementação:

@RequiredArgsConstructor
public class AdapterImpl implements Adapter {
	@Delegate
	private final Adaptee instância;

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

interface Adaptador {
	public void exibir();
}

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

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

Código de Boilerplate: Os Arquitetos Java estão Ouvindo?

Sim, eles são. Você precisa entender que, ao contrário de outras linguagens, o Java tem tomado o máximo cuidado para atualizar a linguagem de forma que não quebre nenhum código existente que esteja 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 melhorando as capacidades de inferência de tipo na linguagem, que foram implementadas. Uma das características importantes planejadas para o Java 10 é Inferência de Tipo de Variável Local. Embora a característica tenha mais a ver com a adição de tipagem dinâmica do que com o código de boilerplate, ainda é uma pequena contribuição para gerenciar o código de boilerplate.

Resumo

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

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

Anotação do Construtor

Anotações Getter/Setter

anotações equals, hashCode e toString

Padrões de Design baseados em Anotações