Using NotNull Annotation in method argument

Making sense of @NotNull

In the wild world of Java, @NotNull is a tool that developers wield to fend off contradictory Null values. It's a shiny badge that politicians (developers and validation frameworks) wear to signify that null values are persona non grata.

The three-step dance to @NotNull

The route from null chaos to @NotNull nirvana involves three moves:

1. Grab your dancing shoes (add a validation provider dependency) for your build tool (like Maven or Gradle).
2. Mark your dance floor (place the @NotNull annotation where it fits like a glove in your code).
3. Do the dance (enable validation): This could be prancing to the beat of @Validated in a Spring application or performing the tango with a ValidatorFactory and a Validator.

Lombok's magic wand

Lombok has a neat parlor trick up its sleeve. Its @NonNull annotation instantly spawns a null check, throwing a NullPointerException before anyone notices, saving you from the potential of stepping on a NullPointerException landmine later on.

Your custom validation kingdom

With the power of ConstraintValidator interface, you can establish your kingdom's validation constitution. This allows the customization of the validation routine, leading to an intricate and efficient system.

The code proclamation

By decree of the @NotNull, all developers shall know the expectation is to never pass a null value. This is a decree that resonates throughout the kingdom (the entire codebase).

Manual validation - the rite of passage

For those who want a personal touch, or for when the automatic validation is catching some Z's, manual validation rises to the occasion. Using a Validator instance, you can check the pulse of constraint violations with a handy validate method.

The null check - the shield against NPEs

Merely adding a @NotNull proclamation provides no assurance against null values. A true guardian requires an additional null check, either manually or through a trusty steward, Lombok, or a structured framework. An unverified @NotNull is as effective as screen doors on a submarine.

The art of null management

Beyond just @NotNull, here are additional methods to marshall nulls in your Java codebase:

Objects.requireNonNull - the bouncer's bodyguard

Pair @NotNull with Objects.requireNonNull() for immediate reveal of null values:

public void doSomething(@NotNull MyObject obj) {
    Objects.requireNonNull(obj, "Top security clearance needed: obj must not be null");
    // ...rest of method
    // "Treat it like your house, notNull values only!"
}


Popping the @Validated champagne in Spring

In a Spring application, you can trigger automatic validation using @Validated. It's like popping the champagne bottle as soon as the party starts, giving meaningful and immediate feedback to the guests (caller).

Teaming up with the Validator squad

There may be instances where you need to perform a roll call check on objects. You can do this with a ValidatorFactory and a Validator instance:

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
Set<ConstraintViolation<Object>> violations = validator.validate(object);
// "Let's run through this again, shall we?"


Forming your custom validator band

For advanced enforcing, you can implement ConstraintValidator to customize validation alignment with complex rules:

public class CustomNotNullValidator implements ConstraintValidator<NotNull, Object> {
    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        // "Hey! No tailgating! Follow the rules, will ya?"
        return value != null;
    }
}


This enables your application to march to the beat of complex business rules while still keeping focus on basic non-null values.

Navigating the maze of edge cases

Collections and arrays - don't be fooled

In the world of collections and arrays, @NotNull can be deceiving. It doesn't guarantee that the contents are also non-null or non-empty. A more elaborate method or custom validator could be your map to navigate the maze.

The interface-implementation dichotomy

The implementation of @NotNull may play tricks depending on the validation provider. A switch in the provider could potentially change the nature of your validation strategy.

The power of external magic (libraries)

The essence of @NotNull lies in the power of external libraries like Hibernate Validator or JSR 303/JSR 380 Bean Validation APIs. Remember to integrate them well into your application to amplify the power of @NotNull.