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

Quase 20 anos de experiência no mercado de TI.
Atuação em grandes empresas como Netshoes, Borland, JBS, Bradesco, Hospital das Clínicas, Rede, Prodam, HSPE, Instituto Ayrton Senna, e também em empresas internacionais como Delta Dental, T-Mobile, Pepsi e Mckesson.
Fundador da TecPrime Solutions, administrador da comunidade nopCommerce Brasil, e autor dos sites InvestFacil.net e Desenvolvedores.ninja