Uso de la anotación NotNull en el argumento del método

Acabo de comenzar a usar la @NotNullanotación con Java 8 y obtener algunos resultados inesperados.

Tengo un método como este:

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

Escribí una prueba JUnit pasando el valor nulo para el argumento searchList. Esperaba que ocurriera algún tipo de error, pero sucedió como si la anotación no estuviera allí. ¿Es este comportamiento esperado? Por lo que entendí, esto fue para permitirle omitir la escritura del código de verificación nulo repetitivo.

Una explicación de lo que se supone que debe hacer exactamente @NotNull sería muy apreciada.

@Nullabley @NotNullno hacer nada por su cuenta. Se supone que actúan como herramientas de documentación.

La @Nullableanotación le recuerda la necesidad de introducir una verificación NPE cuando:

1. Llamar a métodos que pueden devolver nulo.
2. Desreferenciar variables (campos, variables locales, parámetros) que pueden ser nulos.

La @NotNullAnotación es, en realidad, un contrato explícito que declara lo siguiente:

1. Un método no debe devolver nulo.
2. Una variable (como campos, variables locales y parámetros) no puede no debe llevar a cabo valor nulo.

Por ejemplo, en lugar de escribir:

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

Puedes usar:

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

Además, a @NotNullmenudo es verificado por Validadores de restricción (por ejemplo, en primavera e hibernación).

La @NotNullanotación no realiza ninguna validación por sí sola porque la definición de la anotación no proporciona ninguna ConstraintValidatorreferencia de tipo.

Para más información ver:

1. Validación de frijol
2. NotNull.java
3. Constraint.java
4. ConstraintValidator.java

Como se mencionó anteriormente @NotNull, no hace nada por sí solo. Una buena forma de usarlo @NotNullsería 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");
    }
}

Para hacer @NotNull activarlo necesitas Lombok:

https://projectlombok.org/features/NonNull

import lombok.NonNull;

Siga: ¿Qué anotación Java @NotNull debería usar?

SO @NotNull solo es una etiqueta ... Si desea validarlo, debe usar algo como hibernate validator jsr 303

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

Si está utilizando Spring, puede forzar la validación anotando la clase con @Validated:

import org.springframework.validation.annotation.Validated;

Más información disponible aquí: validación Javax @NotNull uso de anotaciones

Hago esto para crear mi propia anotación de validación y validador:

ValidCardType.java(anotación para poner en métodos / campos)

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

Y, el validador para activar la verificación 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));
    }
}

Puedes hacer algo muy similar a comprobar @NotNull.

Para probar la validación de su método en una prueba, debe envolverlo como proxy en el método @Before.

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

Con MethodValidationProxyFactory como:

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

}

Y luego, agregue su prueba:

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

}