Using NullAway to Avoid NullPointerExceptions
Last updated: January 8, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
1. Overview
We’ve been undertaking numerous strategies over the years, from Elvis operators to Optional, to help remove NullPointerExceptions from our apps. In this tutorial, we’ll learn about Uber’s contribution to the conversation, NullAway, and how to use it.
NullAway is a build tool that helps us to eliminate NullPointerExceptions (NPEs) in our Java code.
This tool performs a series of type-based, local checks to ensure that any pointer that gets dereferenced in your code cannot be null. It has low build-time overhead and can be configured to run in every build of your code.
2. Installation
Let’s take a look at how to install NullAway and its dependencies. In this example, we’re going to configure NullAway using Gradle.
NullAway is dependant on Error Prone. Therefore, we will add the errorprone plugin:
plugins {
id "net.ltgt.errorprone" version "1.1.1"
}We’ll also add four dependencies in different scopes: annotationProcessor, compileOnly, errorprone, and errorproneJavac:
dependencies {
annotationProcessor "com.uber.nullaway:nullaway:0.7.9"
compileOnly "com.google.code.findbugs:jsr305:3.0.2"
errorprone "com.google.errorprone:error_prone_core:2.3.4"
errorproneJavac "com.google.errorprone:javac:9+181-r4173-1"
}
Finally, we’ll add the Gradle task that configures how NullAway works during the compilation:
import net.ltgt.gradle.errorprone.CheckSeverity
tasks.withType(JavaCompile) {
options.errorprone {
check("NullAway", CheckSeverity.ERROR)
option("NullAway:AnnotatedPackages", "com.baeldung")
}
}The above task sets NullAway severity to the error level which means we can configure NullAway to stop the build with an error. By default, NullAway will just warn the user at compile time.
Additionally, the task sets the package to be checked for null dereferences.
And that’s it, we’re ready now to use the tool in our Java code.
Similarly, we can use other build systems, Maven or Bazel, to integrate the tool.
3. Usage
Let’s say we have a Person class, containing an age attribute. Additionally, we have a getAge method that takes a Person instance as a parameter:
Integer getAge(Person person) {
return person.getAge();
}At this point, we can see that getAge will throw a NullPointerException if person is null.
NullAway assumes every method parameter, return value, and field are non-null. Therefore, it will expect the person instance to be non-null.
And let’s also say that there is someplace in our code that is, indeed, passing a null reference into getAge:
Integer yearsToRetirement() {
Person p = null;
// ... p never gets set correctly...
return 65 - getAge(p);
}Then, running a build will produce the following error:
error: [NullAway] passing @Nullable parameter 'null' where @NonNull is required
getAge(p);We can fix this error by adding a @Nullable annotation to our parameter:
Integer getAge(@Nullable Person person) {
// ... same as earlier
}Now when we run a build, we’ll see a new error:
error: [NullAway] dereferenced expression person is @Nullable
return person.getAge();
^This is telling us that the person instance has the possibility of being null. We can fix this adding a standard null check:
Integer getAge(@Nullable Person person) {
if (person != null) {
return person.getAge();
} else {
return 0;
}
}4. Conclusions
In this tutorial, we’ve looked at how we can use NullAway to limit the possibilities of encountering NullPointerExceptions.
