Anotações de segurança nula na primavera

1. Visão geral

A partir do Spring 5, agora temos acesso a um recurso interessante que nos ajuda a escrever um código mais seguro. Esse recurso é chamado de segurança nula, um grupo de anotações que funciona como uma salvaguarda que cuida de possíveis referências nulas.

Em vez de nos permitir escapar impunes de código inseguro,the null-safety feature produces warnings at compile time. Tais avisos podem evitar exceções de ponteiro nulo catastróficas (NPEs) em tempo de execução.

2. A anotação@NonNull

A anotação@NonNull é a mais importante entre todas as anotações do recurso de segurança nula. We can use this annotation t0 declare non-null constraint anywhere an object reference is expected: um campo, um parâmetro de método ou valor de retorno de um método.

Suponha que tenhamos uma classe chamadaPerson:

public class Person {
    private String fullName;

    void setFullName(String fullName) {
        if (fullName != null && fullName.isEmpty()) {
            fullName = null;
        }
        this.fullName = fullName;
    }

    // getter
}

Esta definição de classe é válida, mas tem um defeito - o campofullName pode ser definido comonull. Se isso acontecer, podemos acabar com um NPE ao trabalhar comfullName.

O recurso de segurança nula do Spring permite que as ferramentas relatem esse perigo. Por exemplo, se escrevermos código no IntelliJ IDEA e decorarmos o campofullName com a anotação@NonNull, veremos um aviso:

Graças a essa indicação, estamos cientes do problema com antecedência e podemos tomar as medidas adequadas para evitar uma falha no tempo de execução.

3. A anotação@NonNullFields

A anotação@NonNull é útil para garantir segurança nula. No entanto, poluiríamos toda a base de código se adornássemos todos os campos não nulos com esta anotação.

Podemos evitar o abuso de@NonNull com outra anotação -@NonNullFields. This annotation is applicable at the package level, notifying our development tools that all fields in the annotated package are, by default, non-null.

Para que a anotação@NonNullFields seja iniciada, precisamos criar um arquivo chamadopackage-info.java no diretório raiz do pacote e anotar o pacote com@NonNullFields:

@NonNullFields
package org.example.nullibility;

Vamos declarar outra propriedade na classePerson, chamadanickName:

package org.example.nullibility;

// import statements

public class Person {
    private String nickName;

    void setNickName(@Nullable String nickName) {
        if (nickName != null && nickName.isEmpty()) {
            nickName = null;
        }
        this.nickName = nickName;
    }

    // other declarations
}

Desta vez, não embelezamos o camponickName com@NonNull, mas ainda vemos uma advertência semelhante:

A anotação@NonNullFields torna nosso código menos prolixo enquanto garante o mesmo nível de segurança que@NonNull fornece.

4. A anotação@Nullable

A anotação@NonNullFields geralmente é preferível a@NonNull, pois ajuda a reduzir o clichê. Às vezes, queremos isentar alguns campos da restrição não nula especificada no nível do pacote.

Vamos voltar ao camponickName em e decorá-lo com a anotação@Nullable:

@Nullable
private String nickName;

O aviso que vimos antes se foi agora:

Nesta situação,we used the @Nullable annotation to override the semantics of @NonNullFields on a field.

5. A anotação@NonNullApi

A anotação@NonNullFields só se aplica, como seu nome sugere, aos campos. If we want to have the same impact on the methods' parameters and return values, we’ll need @NonNullApi.

Tal como acontece com@NonNullFields, devemos especificar a anotação@NonNullApi no arquivopackage-info.java:

@NonNullApi
package org.example.nullibility;

Vamos definir um getter para o camponickName:

package org.example.nullibility;

// import statements

public class Person {
    @Nullable
    private String nickName;

    String getNickName() {
        return nickName;
    }

    // other declarations
}

Com a anotação@NonNullApi em vigor, um aviso é emitido sobre um possível valornull produzido pelo métodogetNickName:

Observe que, assim como a anotação@NonNullFields, podemos substituir o@NonNullApi no nível do método pela anotação@Nullable.

6. Conclusão

A segurança nula da primavera é um ótimo recurso que ajuda a diminuir a possibilidade de NPEs. No entanto, há dois pontos importantes que precisamos tomar cuidado ao usar esse recurso:

Só pode ser usado em uma ferramenta de desenvolvimento de suporte, como o IntelliJ IDEA
Ele não impõe verificações denull em tempo de execução - ainda precisamos escrever código para evitar NPEs

O código-fonte deste tutorial pode ser encontradoover on GitHub.

TOC

Anotações de segurança nula na primavera