Introdução ao Projeto Lombok

Lombok é uma das ferramentas que eu literalmente sempre coloco em meus projetos de builds primeiro. Eu não conseguia me imaginar programando Java sem ele hoje em dia. Eu realmente espero que você encontre seu poder lendo este artigo!

1. Evite código repetitivo

Java é uma ótima linguagem, mas às vezes fica muito detalhada para as coisas que você precisa fazer no seu código para tarefas comuns ou conformidade com algumas práticas de estrutura. Muitas vezes, elas não trazem valor real para o lado comercial dos seus programas - e é aqui que a Lombok está aqui para tornar sua vida mais feliz e mais produtiva.

A maneira como funciona é conectando-se ao seu processo de construção e gerando automaticamente o bytecode Java em seus arquivos.class de acordo com uma série de anotações de projeto que você introduz em seu código.

Leitura adicional:

Construtor Lombok com valor padrão

Aprenda a criar valores de propriedade padrão do construtor usando Lombok

Configurando o Lombok com Eclipse e Intellij

Aprenda a configurar o Lombok com IDEs populares

2. Getters/Setters, Constructors – So Repetitive

Encapsular propriedades de objetos por meio de métodos públicos getter e setter é uma prática comum no mundo Java, e muitas estruturas contam com esse padrão de "Java Bean" extensivamente: uma classe com um construtor vazio e métodos get / set para "propriedades".

Isso é tão comum que a maioria dos IDEs suporta código de geração automática para esses padrões (e mais). Esse código, no entanto, precisa estar em suas fontes e também deve ser mantido quando, digamos, uma nova propriedade é adicionada ou um campo renomeado.

Vamos considerar esta classe que queremos usar como uma entidade JPA como exemplo:

@Entity
public class User implements Serializable {

    private @Id Long id; // will be set when persisting

    private String firstName;
    private String lastName;
    private int age;

    public User() {
    }

    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getters and setters: ~30 extra lines of code
}

Esta é uma classe bastante simples, mas ainda considere se adicionarmos o código extra para getters e setters, acabaríamos com uma definição onde teríamos mais código de valor zero clichê do que as informações de negócios relevantes: "um usuário tem primeiro e sobrenomes e idade. ”

Vamos agoraLombok-ize esta classe:

@Entity
@Getter @Setter @NoArgsConstructor // <--- THIS is it
public class User implements Serializable {

    private @Id Long id; // will be set when persisting

    private String firstName;
    private String lastName;
    private int age;

    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
}

Adicionando as anotações@Getter e@Setter, dissemos ao Lombok para, bem, gerá-las para todos os campos da classe. @NoArgsConstructor levará a uma geração de construtor vazio.

Observe que este é o código de classewhole, não estou omitindo nada em oposição à versão acima com o comentário// getters and setters. Para uma classe de três atributos relevantes, é uma economia significativa no código!

Se você adicionar atributos (propriedades) à sua classeUser, o mesmo acontecerá: você aplicou as anotações ao próprio tipo para que eles cuidem de todos os campos por padrão.

E se você quisesse refinar a visibilidade de algumas propriedades? Por exemplo, gosto de manter os modificadores de campoid das minhas entidadespackage ouprotected visíveis porque se espera que sejam lidos, mas não explicitamente definidos pelo código do aplicativo. Basta usar um@Setter mais granulado para este campo específico:

private @Id @Setter(AccessLevel.PROTECTED) Long id;

3. Lazy Getter

Muitas vezes, os aplicativos precisam executar algumas operações caras e salvar os resultados para uso posterior.

Por exemplo, digamos que precisamos ler dados estáticos de um arquivo ou banco de dados. Geralmente, é uma boa prática recuperar esses dados uma vez e, em seguida, armazená-los em cache para permitir leituras na memória dentro do aplicativo. Isso evita que o aplicativo repita a operação cara.

Outro padrão comum éretrieve this data only when it’s first needed. Em outras palavras,only get the data when the corresponding getter is called the first time. This is called lazy-loading.

Suponha que esses dados sejam armazenados em cache como um campo dentro de uma classe. A classe agora deve garantir que qualquer acesso a esse campo retorne os dados em cache. Uma maneira possível de implementar essa classe é fazer com que o método getter recupere os dados apenas se o campo fornull. Por esse motivo,we call this a lazy getter.

O Lombok torna isso possível comlazy parameter in the @Getter annotation que vimos acima.

Por exemplo, considere esta classe simples:

public class GetterLazy {

    @Getter(lazy = true)
    private final Map transactions = readTxnsFromFile();

    private Map readTxnsFromFile() {

        final Map cache = new HashMap<>();
        List txnRows = readTxnListFromFile();

        txnRows.forEach(s -> {
            String[] txnIdValueTuple = s.split(DELIMETER);
            cache.put(txnIdValueTuple[0], Long.parseLong(txnIdValueTuple[1]));
        });

        return cache;
    }
}

Isso lê algumas transações de um arquivo emMap. Como os dados no arquivo não mudam, vamos armazená-los em cache uma vez e permitir o acesso por meio de um getter.

Se agora olharmos para o código compilado desta classe, veremos umgetter method which updates the cache if it was null and then returns the cached data:

public class GetterLazy {

    private final AtomicReference

TOC

Introdução ao Projeto Lombok