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