Uma das características da linguagem Java que incomodam muitas pessoas, é o quanto a linguagem é verbosa. Escrever uma simples classe em Java pode requerer uma grande quantidade de getters e setters, e apesar das IDEs de desenvolvimento gerarem o código dos getters e setters de forma automática, o resultado final é uma classe extensa.

Uma das abordagens que defendo, é a criação de getter e setter apenas quando realmente necessário, dessa forma se evita quebrar o encapsulamento da classe, mas muitas vezes somos obrigados a usar getters e setters por causa de algum framework que utilizamos no projeto. Então, o que fazer nesses casos? Lombok.

Mas o que é esse tal de Lombok?
É um processador do APT (Annotation Processor Tool) que, através de recursos da API não pública da JVM, gera código na própria classe que está sendo compilada.

E o que ele faz?
Ele gera automaticamente o código Java desejado, por exemplo get e set para seus atributos. Isso é possível porque o Lombok se integra ao Eclipse, NetBeans, Maven, Gradle, etc. Quando sua classe é compilada, automaticamente é gerado o respectivo código Java para cada uma das anotações do Lombok que foram utilizadas.

E como funciona na prática?
Vamos a um exemplo para ver como o Lombok pode reduzir a quantidade de código, e simplificar o desenvolvimento. Vamos criar uma classe chamada Cliente usando o forma tradicional:

package lombok;

import java.util.Calendar;

public class Cliente {

	public Cliente() {
		
	}
	
	public Cliente(String nome, Calendar dataCadastro, String cpf) {
		this.cpf = cpf;
		this.nome = nome;
		this.dataCadastro = dataCadastro;
	}
	
	private String nome;
	private Calendar dataCadastro;
	private String cpf;
	
	public String getNome() {
		return nome;
	}
	public void setNome(String nome) {
		this.nome = nome;
	}
	public Calendar getDataCadastro() {
		return dataCadastro;
	}
	public void setDataCadastro(Calendar dataCadastro) {
		this.dataCadastro = dataCadastro;
	}
	public String getCpf() {
		return cpf;
	}
	public void setCpf(String cpf) {
		this.cpf = cpf;
	}
	
	@Override
	public String toString() {
		return "Cliente(nome=" + nome + ", dataCadastro=" + dataCadastro + ", cpf=" + cpf + ")";
	}
}

Nossa classe cliente, possui 2 construtores, sendo um que não possui parâmetros, e o outro que possui todos atributos como parâmetros. Criamos 3 atributos, e seus respectivos getters e setters, e sobrescrevemos o método toString(). E como resultado, ficamos com uma classe com quase 50 linhas de código, muita coisa para algo tão simples, certo?

Agora vamos ver como a mesma classe ficaria usando o Lombok?

package lombok;

import java.util.Calendar;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ClienteLombok {

	private String nome;
	private Calendar dataCadastro;
	private String cpf;
}

Veja que temos uma classe com apenas 17 linhas, quase um terço do tamanho da classe no modelo tradicional acima. Será que temos o mesmo resultado que a primeira classe? De semelhança, só temos apenas os três atributos declarados. Mas onde estão os getters e setters, e onde está o override do toString(), e onde está a criação dos dois construtores? Eles são criados automaticamente pelo Lombok, graças ao uso das anotações:
–@Data: cria todos getters e setters, além de sobrescrever os métodos toString(), equals() e hasCode();
–@AllArgsConstructor: cria o construtor que possui todos atributos como parâmetros;
–@NoArgsConstructor: cria o construtor que não possui parâmetros;

Vamos ver como fica nossa classe de teste de execução de nossas 2 classes acima?

package lombok;

public class TesteExecucao {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Cliente c = new Cliente();
		c.setNome("Desenvolvedor Ninja");
		c.setCpf("123.456.789-00");
		
		System.out.println(c.toString());
		System.out.println("Método getNome=" + c.getNome());
		
		ClienteLombok cl = new ClienteLombok();
		cl.setNome("Desenvolvedor Ninja");
		cl.setCpf("123.456.789-00");
		
		System.out.println(cl.toString());
		System.out.println("Método getNome=" + cl.getNome());
		
		ClienteLombok cl2 = new ClienteLombok("Programador Ninja", null, "987.654.321-00");
		
		System.out.println(cl2.toString());
		System.out.println("Método getNome=" + cl2.getNome());
	}
}

Repare que ambas as classes Cliente e ClienteLombok possuem os mesmos métodos de get e set, assim como o mesmo comportamento no método toString(), assim como também vemos o construtor que recebe todos atributos como parâmetro. Veja o resultado da execução dessa classe:

Cliente(nome=Desenvolvedor Ninja, dataCadastro=null, cpf=123.456.789-00)
Método getNome=Desenvolvedor Ninja
ClienteLombok(nome=Desenvolvedor Ninja, dataCadastro=null, cpf=123.456.789-00)
Método getNome=Desenvolvedor Ninja
ClienteLombok(nome=Programador Ninja, dataCadastro=null, cpf=987.654.321-00)
Método getNome=Programador Ninja

Legal, aí agora e se quisermos que apenas alguns atributos tenham get e set, ou se quisermos que um atributo só tenha get? Vamos ver como ficaria nossa classe.

package lombok;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@ToString
public class FornecedorLombok {

	@Getter @Setter
	private String nome;
	@Getter @Setter
	private String cnpj;
	@Getter
	private double credito;
	private double score;
}

Veja que continuamos tendo uma classe enxuta, sem código desnecessário. O que temos de diferente, é que retiramos a anotação @Data da classe, e adicionamos as anotações @Getter e @Setter nos atributos que desejamos. Dessa forma apenas nome e cnpj terão get e set, o atributo credito terá apenas o get, e o atributo score não terá nem get e nem set. Ou seja, ganhamos um código mais limpo, enxuto, e que continua flexível. Com a retirada da anotação @Data, tivemos que inserir a anotação @ToString.

Com a criação da classe FornecedorLombok, alteramos nossa classe execução inserindo as linhas:

		FornecedorLombok fl = new FornecedorLombok();
		fl.setNome("Fornecedor Ninja");
		fl.setCnpj("000.000.000/0000-00");
		
		System.out.println(fl.toString());
		
		FornecedorLombok fl2 = new FornecedorLombok("Desenvolvedor Ninja", "111.111.111/1111-11", 999.99, 50.00);
		
		System.out.println(fl2.toString());

Vamos ao resultado da execução de nosso teste?

FornecedorLombok(nome=Fornecedor Ninja, cnpj=000.000.000/0000-00, credito=0.0, score=0.0)
FornecedorLombok(nome=Desenvolvedor Ninja, cnpj=111.111.111/1111-11, credito=999.99, score=50.0)

Como vimos, o Lombok ajuda a reduzir o código desnecessário, deixando nossas classes mais limpas e enxutas, deixando o código menos verboso, e tudo isso sem a necessidade de uma alteração na linguagem, e no seu funcionamento. Existem outras anotações que o Lombok suporta, que veremos mais adianta aqui no blog, ou que pode ser conferida no site do projeto: http://projectlombok.org/

Para começar a usar o Lombok, visite a página de download do projeto e veja como fazer a instalação de acordo com a ferramenta que você utiliza: http://projectlombok.org/download.html