Utilizzo dell'annotazione NotNull nell'argomento del metodo

Ho appena iniziato a utilizzare l' @NotNullannotazione con Java 8 e ho ottenuto risultati inaspettati.

Ho un metodo come questo:

public List<Found> findStuff(@NotNull List<Searching> searchingList) {
    ... code here ...
}

Ho scritto un test JUnit passando il valore Null per l'argomento researchList. Mi aspettavo che accadesse qualche tipo di errore, ma è passato come se l'annotazione non fosse presente. Questo comportamento è previsto? Da quello che ho capito, questo era per permetterti di saltare la scrittura del codice di controllo nullo della caldaia.

Una spiegazione di cosa dovrebbe fare esattamente @NotNull sarebbe molto apprezzata.

@Nullablee @NotNullnon fanno nulla da soli. Dovrebbero fungere da strumenti di documentazione.

L' @Nullableannotazione ricorda la necessità di introdurre un controllo NPE quando:

1. Chiamare metodi che possono restituire null.
2. Dereferenziazione di variabili (campi, variabili locali, parametri) che possono essere nulle.

L' @NotNullannotazione è, in realtà, un contratto esplicito che dichiara quanto segue:

1. Un metodo non deve restituire null.
2. Una variabile (come campi, variabili locali e parametri) non può non deve tenere il valore nullo.

Ad esempio, invece di scrivere:

/**
 * @param aX should not be null
 */
public void setX(final Object aX ) {
    // some code
}

Puoi usare:

public void setX(@NotNull final Object aX ) {
    // some code
}

Inoltre, @NotNullviene spesso controllato da ConstraintValidators (ad es. In primavera e in letargo).

L' @NotNullannotazione non esegue alcuna convalida da sola perché la definizione dell'annotazione non fornisce alcun ConstraintValidatorriferimento al tipo.

Per maggiori informazioni vedi:

1. Convalida del fagiolo
2. NotNull.java
3. Constraint.java
4. ConstraintValidator.java

Come accennato in precedenza @NotNull, non fa nulla da solo. Un buon modo di usare @NotNullsarebbe usarlo conObjects.requireNonNull

public class Foo {
    private final Bar bar;

    public Foo(@NotNull Bar bar) {
        this.bar = Objects.requireNonNull(bar, "bar must not be null");
    }
}

Per renderti @NotNullattivo hai bisogno di Lombok:

https://projectlombok.org/features/NonNull

import lombok.NonNull;

Segui: Quale annotazione Java @NotNull dovrei usare?

SO @NotNull è solo un tag ... Se si desidera convalidarlo, è necessario utilizzare qualcosa di simile a hibernate validator jsr 303

ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
Validator validator = validatorFactory.getValidator();
 Set<ConstraintViolation<List<Searching>> violations = validator.validate(searchingList);

Se si utilizza Spring, è possibile forzare la convalida annotando la classe con @Validated:

import org.springframework.validation.annotation.Validated;

Maggiori informazioni disponibili qui: convalida Javax @NotNull utilizzo delle annotazioni

Faccio questo per creare la mia annotazione e validatore di convalida:

ValidCardType.java(annotazione per mettere su metodi / campi)

@Constraint(validatedBy = {CardTypeValidator.class})
@Documented
@Target( { ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidCardType {
    String message() default "Incorrect card type, should be among: \"MasterCard\" | \"Visa\"";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

E, il validatore per attivare il controllo CardTypeValidator.java::

public class CardTypeValidator implements ConstraintValidator<ValidCardType, String> {
    private static final String[] ALL_CARD_TYPES = {"MasterCard", "Visa"};

    @Override
    public void initialize(ValidCardType status) {
    }
    public boolean isValid(String value, ConstraintValidatorContext context) {
        return (Arrays.asList(ALL_CARD_TYPES).contains(value));
    }
}

Puoi fare qualcosa di molto simile da controllare @NotNull.

Per testare la convalida del metodo in un test, è necessario racchiuderlo in un proxy nel metodo @Before.

@Before
public void setUp() {
    this.classAutowiredWithFindStuffMethod = MethodValidationProxyFactory.createProxy(this.classAutowiredWithFindStuffMethod);
}

Con MethodValidationProxyFactory come:

import org.springframework.context.support.StaticApplicationContext;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;

public class MethodValidationProxyFactory {

private static final StaticApplicationContext ctx = new StaticApplicationContext();

static {
    MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
    processor.afterPropertiesSet(); // init advisor
    ctx.getBeanFactory()
            .addBeanPostProcessor(processor);
}

@SuppressWarnings("unchecked")
public static <T> T createProxy(T instance) {

    return (T) ctx.getAutowireCapableBeanFactory()
            .applyBeanPostProcessorsAfterInitialization(instance, instance.getClass()
                    .getName());
}

}

E quindi aggiungi il tuo test:

@Test
public void findingNullStuff() {
 assertThatExceptionOfType(ConstraintViolationException.class).isThrownBy(() -> this.classAutowiredWithFindStuffMethod.findStuff(null));

}