Entenda as Annotations do Lombok, as 4 annotations avançadas que vão facilitar seu trabalho

Hoje em dia é muito comum você entrar em um projeto Java com Spring por exemplo e acabar se deparando com as Annotations do Lombok, quem nunca achou em um código de aplicação moderno usando as annotations do lombok @Getter e @Settter ou talvez a @ToString.

Bom o Lombok é uma realidade em quase todas as aplicações de mercado, pois facilita e muito o desenvolvimento, fazendo com o que desenvolvedor passe mais tempo preocupado com a regra de negócio ao invés de gastar um tempo valioso escrevendo código boilerplate, que são para atender as especificações do estilo de codificação e da própria linguagem.

E não entendam mal, esse códigos são muito importantes pois fazem você respeitar, inclusive para deixar o seu código organizado, padronizado e respeitando os conceitos de orientação a objeto.

Mas para que vou ter o trabalho de gerar todo um código para criar getters e setters sendo que posso usar simplesmente algumas annotations do lombok, que irá fazer todo esse trabalho por você.

A proposta aqui é mostrar outras annotations do lombok que as vezes passam desapercebido pelos desenvolvedores e temos certeza que você já pode ter precisado de algumas delas.

Explicando as Annotations do Lombok

Vamos falar sobre 4 annotations do Lombok que facilitam muito o trabalho, mas que as vezes acabam não sendo utilizadas pelos desenvolvedores, não vamos abordar aqui o uso das annotations do Lombok @Getter, @Setter e @ToString, porque essa são mais comuns e o seu uso é auto explicativo.

Vamos a explicação:

@EqualsAndHashCode

A annotation @EqualsAndHashCode é uma das annotations do lombok mais úteis para simplificar a implementação dos métodos equals() e hashCode() em uma classe Java. Em vez de escrever manualmente esses métodos, podemos simplesmente adicionar a annotation @EqualsAndHashCode à nossa classe, e o Lombok se encarrega de gerar os métodos para nós.

A annotation @EqualsAndHashCode gera automaticamente os métodos equals() e hashCode() com base nos campos da classe. Isso significa que, se dois objetos têm os mesmos valores em seus campos, eles serão considerados iguais e terão o mesmo hashcode.

Para usar a annotation @EqualsAndHashCode, basta adicioná-la à sua classe. Por exemplo, suponha que você tenha a seguinte classe Pessoa:

import lombok.EqualsAndHashCode;

@EqualsAndHashCode
public class Pessoa { 

    private String nome; 
    private int idade; 
    private String email;
}

Observe que a annotation @EqualsAndHashCode também tem parâmetros opcionais que podemos usar para personalizar a geração dos métodos equals() e hashCode(). Por exemplo, podemos usar o parâmetro exclude para excluir campos específicos da comparação de igualdade ou hashCode. Ou podemos usar o parâmetro of para incluir apenas alguns campos na comparação de igualdade ou hashCode.

Em resumo, a annotation @EqualsAndHashCode do Lombok é uma ferramenta útil para simplificar a implementação dos métodos equals() e hashCode() em uma classe Java. Com essa annotation, podemos deixar o Lombok se encarregar de gerar os métodos para nós, tornando nossa vida como desenvolvedores muito mais fácil e produtiva.

@Data

A annotation @Data é uma das mais úteis e populares annotations do Lombok. Ela é usada para gerar automaticamente os métodos getters, setters, equals(), hashCode() e toString() de uma classe Java.
A annotation @Data substitui a necessidade de escrever manualmente esses métodos, o que reduz muito a quantidade de código que precisamos escrever. Em vez de criar os métodos manualmente, podemos simplesmente adicionar a annotation @Data à nossa classe e o Lombok irá gerar esses métodos automaticamente.

Se observar bem, com essa annotations eu não preciso utilizar as outras annotations como @Getter, @Setter e @ToString.

Vamos considerar um exemplo de uso da annotation @Data em uma classe Pessoa:

import lombok.Data;

@Data
public class Pessoa {

    private String nome;    
    private int idade;    
    private String email;
}

Observe que a annotation @Data é uma combinação de outras annotations do Lombok, incluindo @Getter, @Setter, @EqualsAndHashCode e @ToString. Isso significa que, se você precisar personalizar a geração de algum desses métodos, pode usar as annotations individuais em vez da @Data.

Em resumo, a annotation @Data do Lombok é uma ferramenta muito útil para reduzir a quantidade de código que precisamos escrever em nossas classes Java. Com essa annotation, podemos deixar o Lombok gerar automaticamente os métodos getters, setters, equals(), hashCode() e toString() para nós, o que nos ajuda a economizar tempo e aumentar a produtividade.

@Builder

A annotation @Builder é uma das mais úteis annotations do Lombok. Ela é usada para gerar automaticamente um padrão de construção de objetos usando o padrão Builder.

Essa annotation é uma alternativa ao construtor padrão e evita a necessidade de escrever construtores complexos, especialmente em classes com muitos atributos.

Vamos considerar um exemplo de uso da annotation @Builder em uma classe Pessoa:

import lombok.EqualsAndHashCode;

@Builder
public class Pessoa { 

    private String nome; 
    private int idade; 
    private String email;
}

Com a annotation @Builder, o Lombok irá gerar automaticamente um padrão de construção de objetos usando o padrão Builder para a classe Pessoa. Isso significa que podemos criar objetos Pessoa usando o seguinte código:

Pessoa pessoa = Pessoa.builder()
  .nome("João")
  .idade(30)
  .email("joao@example.com")
  .build();

O método builder() retorna um objeto PessoaBuilder, que é usado para configurar os valores dos atributos da classe Pessoa. O método build() cria e retorna uma instância de Pessoa com os valores configurados.

Observe que, com a annotation @Builder, é possível criar objetos Pessoa com valores default (usando @Builder.Default) e valores opcionais. Os valores default são aqueles que são atribuídos automaticamente pelo Lombok, enquanto os valores opcionais podem ser especificados pelo usuário.

Além disso, a annotation @Builder permite que sejam adicionados métodos personalizados ao padrão Builder.

Em resumo, a annotation @Builder do Lombok é uma ferramenta muito útil para reduzir a quantidade de código que precisamos escrever em nossas classes Java. Com essa annotation, podemos deixar o Lombok gerar automaticamente um padrão de construção de objetos usando o padrão Builder para nós, o que nos ajuda a economizar tempo e aumentar a produtividade.

@SneakyThrows

A anotação @SneakyThrows é uma das annotations do Lombok, que podemos considerar no grupo de anotações avançadas, ela pode ser usada para lidar com exceções de forma mais elegante em Java.

Com a anotação @SneakyThrows, podemos converter uma exceção verificada em uma exceção não verificada. Dessa forma, podemos lidar com a exceção sem ter que escrever um bloco try-catch, o que torna nosso código mais limpo e legível.

Para usar a anotação @SneakyThrows, basta anotar um método ou um bloco de código que possa lançar uma exceção verificada.

Por exemplo, suponha que você tenha o seguinte método que lança uma exceção verificada:

public void readFromFile(String fileName) throws IOException { 
    try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
         String line = reader.readLine(); System.out.println(line); 
    }
}

Com a anotação @SneakyThrows, podemos reescrever esse método da seguinte maneira:

import lombok.SneakyThrows; 

public class MyFileReader { 

    @SneakyThrows public void readFromFile(String fileName) {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line = reader.readLine(); System.out.println(line); 
        } 
    }
}

Observe que a anotação @SneakyThrows é aplicada ao método readFromFile e não há mais uma declaração throws na assinatura do método. Agora, se ocorrer uma exceção dentro do bloco try, ela será convertida automaticamente em uma exceção RuntimeException.

Isso significa que não precisamos mais escrever um bloco try-catch para lidar com a exceção. No entanto, é importante lembrar que o uso excessivo dessa anotação pode tornar o código mais difícil de entender, pois as exceções não são explicitamente declaradas. Portanto, é sempre bom usar a anotação com moderação e manter a legibilidade do código.

Bônus

Essa você já deve conhecer, mas é bom lembrar, ainda temos uma Annotation do Lombok muito útil que foi feito para logs, trata-se da @Slf4j

Com a @Slf4j, você pode adicionar automaticamente logging ao seu código, veja o exemplo:

import lombok.SneakyThrows; 
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyFileReader { 

    @SneakyThrows public void readFromFile(String fileName) {
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line = reader.readLine(); 
            log.info(line); 
        } 
    }
}

Vimos que utilizar as annotations do Lombok é simples e muito útil em qualquer contexto de projeto java, pois a sua utilização só agrega o dia a dia da equipe de desenvolvimento, além de ajudar o código a ficar bem organizado e de fácil entendimento.

Otimização do processo de desenvolvimento é sempre bem vindo, temos também um tutorial que ensina como configurar o Lombok em conjunto com o MapStruct em um projeto Spring Boot, o uso dessas duas ferramentas traz um retorno muito bom em termos de produtividade, confira o tutorial aqui.

Links uteis

• Se você não usa o Lombok ou tem dificuldade de integra-lo com a sua IDE acesse aqui
• Para diminuir ainda mais o código boilerplate veja esse post
• Site oficial do projeto Lombok