Utilisation de l'annotation NotNull dans l'argument de méthode

Je viens de commencer à utiliser l' @NotNullannotation avec Java 8 et à obtenir des résultats inattendus.

J'ai une méthode comme celle-ci:

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

J'ai écrit un test JUnit en passant la valeur nulle pour l'argument searchList. Je m'attendais à ce qu'une erreur se produise, mais elle s'est déroulée comme si l'annotation n'était pas là. Est-ce un comportement attendu? D'après ce que j'ai compris, c'était pour vous permettre d'éviter d'écrire le code de contrôle nul standard.

Une explication de ce que @NotNull est censé faire exactement serait grandement appréciée.

@Nullableet @NotNullne rien faire de leur propre chef. Ils sont censés agir comme des outils de documentation.

L' @Nullableannotation vous rappelle la nécessité d'introduire une vérification NPE lorsque:

1. Appel de méthodes qui peuvent renvoyer null.
2. Déréférencer les variables (champs, variables locales, paramètres) pouvant être nulles.

L' @NotNullannotation est, en fait, un contrat explicite déclarant ce qui suit:

1. Une méthode ne doit pas retourner null.
2. Une variable (comme les champs, les variables locales et les paramètres) ne peut pas ne doit pas contenir de valeur nulle.

Par exemple, au lieu d'écrire:

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

Vous pouvez utiliser:

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

De plus, il @NotNullest souvent vérifié par ConstraintValidators (par exemple au printemps et en veille prolongée).

L' @NotNullannotation n'effectue aucune validation par elle-même car la définition d'annotation ne fournit aucune ConstraintValidatorréférence de type.

Pour plus d'informations, voir:

1. Validation du bean
2. NotNull.java
3. Constraint.java
4. ConstraintValidator.java

Comme mentionné ci-dessus, @NotNullne fait rien de lui-même. Une bonne façon d'utiliser @NotNullserait de l'utiliser avecObjects.requireNonNull

public class Foo {
    private final Bar bar;

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

Pour être @NotNullactif, vous avez besoin de Lombok:

https://projectlombok.org/features/NonNull

import lombok.NonNull;

Suivez: Quelle annotation Java @NotNull dois-je utiliser?

SO @NotNull est juste une balise ... Si vous voulez la valider, vous devez utiliser quelque chose comme le validateur d'hibernation jsr 303

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

Si vous utilisez Spring, vous pouvez forcer la validation en annotant la classe avec @Validated:

import org.springframework.validation.annotation.Validated;

Plus d'informations disponibles ici: Validation Javax @NotNull utilisation de l'annotation

Je fais cela pour créer ma propre annotation de validation et validateur:

ValidCardType.java(annotation à mettre sur les méthodes / champs)

@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 {};
}

Et, le validateur pour déclencher le contrôle 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));
    }
}

Vous pouvez faire quelque chose de très similaire pour vérifier @NotNull.

Pour tester la validation de votre méthode dans un test, vous devez l'envelopper d'un proxy dans la méthode @Before.

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

Avec MethodValidationProxyFactory comme:

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());
}

}

Et puis, ajoutez votre test:

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

}