Verwenden von NotNull Annotation im Methodenargument

Ich habe gerade angefangen, das zu benutzen @NotNull Annotation mit Java 8 zu verwenden und einige unerwartete Ergebnisse zu erhalten.

Ich habe eine Methode wie diese:

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

Ich habe einen JUnit-Test geschrieben, der den Nullwert für das Argument searchList übergeben hat. Ich hatte erwartet, dass ein Fehler auftritt, aber er ging durch, als ob die Anmerkung nicht vorhanden wäre. Ist das erwartetes Verhalten? Soweit ich verstanden habe, sollten Sie damit das Schreiben des Nullprüfcodes für das Boilerplate überspringen.

Eine Erklärung, was genau @NotNull tun soll, wäre sehr dankbar.

@Nullableund @NotNullnichts alleine machen. Sie sollen als Dokumentationswerkzeuge dienen.

Die @NullableAnmerkung erinnert Sie an die Notwendigkeit, eine NPE-Prüfung einzuführen, wenn:

1. Aufruf von Methoden, die null zurückgeben können.
2. Dereferenzieren von Variablen (Felder, lokale Variablen, Parameter), die null sein können.

Die @NotNullAnmerkung ist eigentlich ein ausdrücklicher Vertrag, der Folgendes erklärt:

1. Eine Methode sollte nicht null zurückgeben.
2. Eine Variable (wie Felder, lokale Variablen und Parameter) kann nicht nicht Null - Wert halten.

Zum Beispiel anstatt zu schreiben:

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

Sie können verwenden:

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

Darüber hinaus @NotNullwird häufig von ConstraintValidators überprüft (z. B. im Frühjahr und im Ruhezustand).

Die @NotNullAnnotation führt keine eigene Validierung durch, da die Annotationsdefinition keine bereitstelltConstraintValidator .

Weitere Informationen finden Sie unter:

1. Bean-Validierung
2. NotNull.java
3. Constraint.java
4. ConstraintValidator.java

Wie oben erwähnt @NotNullmacht nichts für sich. Eine gute Art der Verwendung @NotNullwäre die Verwendung mitObjects.requireNonNull

public class Foo {
    private final Bar bar;

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

Um @NotNullaktiv zu werden, benötigen Sie Lombok:

https://projectlombok.org/features/NonNull

import lombok.NonNull;

Folgen Sie: Welche @NotNull Java-Annotation soll ich verwenden?

SO @NotNull ist nur ein Tag ... Wenn Sie es validieren möchten, müssen Sie so etwas wie den Ruhezustand-Validator jsr 303 verwenden

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

Wenn Sie Spring verwenden, können Sie die Validierung erzwingen, indem Sie die Klasse mit @Validatedfolgenden Anmerkungen versehen :

import org.springframework.validation.annotation.Validated;

Weitere Informationen finden Sie hier: Verwendung der Javax-Validierung @NotNull-Annotation

Ich mache das, um meine eigene Validierungsanmerkung und Validierung zu erstellen:

ValidCardType.java(Anmerkung zum Anlegen von Methoden / Feldern)

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

Und, um der Prüfer die Prüfung auslösen: 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));
    }
}

Sie können etwas sehr Ähnliches tun, um dies zu überprüfen @NotNull.

Um Ihre Methodenvalidierung in einem Test zu testen, müssen Sie einen Proxy in die @ Before-Methode einbinden.

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

Mit MethodValidationProxyFactory als:

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

}}

Und dann fügen Sie Ihren Test hinzu:

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

}