Spring's Assert Class: The Smart Way to Validate

September 6, 2023
3 minutes to read
Share this post:

There are many ways to ensure your code does what it’s supposed to do. Java even has a built-in assert language feature for this very purpose. And then there’s Spring’s Assert class. But why should I use this? In this article, we delve deeply into the subject and explore the advantages of using this class for validating your data and arguments.

Why Use Assertions at All?

Before diving into the details of the Spring Assert class, let’s briefly clarify the significance of assertions. Assertions help us verify the correctness of our code at runtime. They are an essential tool for debugging and testing. This is particularly useful when you’re working with multiple developers on a project and want to ensure that the delivered data and parameters meet expectations. When this is not the case, we want to terminate our application and throw an exception.

What Makes Spring’s Assert Class Special?

The Spring Assert class offers a plethora of static methods for checking conditions. What’s special about them is that these methods react with a clearly defined IllegalArgumentException or another runtime exception. This kind of exception simplifies error tracing and is much more expressive compared to Java’s assert language feature or individual if statements.

Advantages Over Java’s assert and if-Statements

Java’s built-in assert is less expressive and throws AssertionError, making it harder to react to. Moreover, the assert feature must be activated by specifying an extra parameter when starting the application. This makes it possible to accidentally run different code on different environments. The errors caused this way are hard to trace.

When using simple if statements for validation, the code becomes cluttered. Also, it’s likely that we’ll be inconsistent in throwing exceptions.

// With Java's assert
assert someVariable != null : "someVariable must not be null";

// With if-Statement
if (someVariable == null) {
    throw new IllegalArgumentException("someVariable must not be null");

In contrast, the code with Spring’s Assert class is shorter and consistent:

// With Spring Assert
Assert.notNull(someVariable, "someVariable must not be null");

What Spring’s Assert Class Offers Us

The Assert class includes common validation methods for frequently used data types.


With methods like hasText() and hasLength(), we can check strings. You can ensure that the string is not only non-null but also contains actual text.

String name = "John";
Assert.hasText(name, "Name must not be empty");


Collections are another common data type where the Spring Assert class shines. The method notEmpty() is an excellent example.

List<String> items = Arrays.asList("Apple", "Banana");
Assert.notEmpty(items, "The list must not be empty");

Type Checks

Spring Assert also provides isInstanceOf() and isAssignable() methods for type checks. If you want to ensure that an object is of a specific type, this is a good way to do it.

Object animal = new Dog();
Assert.isInstanceOf(Dog.class, animal, "The animal must be a dog");

Use Spring Asserts to Be Consistent

Granted, Spring’s Assert class is nothing groundbreaking. However, the small advantages of being consistent in throwing your exceptions and saving a few lines in your code make it worth using. It offers an expressive, efficient, and easy-to-handle way to validate data and arguments.

Check out the Assert class and discover what other validations it offers you.

Have you heard of Marcus' Backend Newsletter?

New ideas. Twice a week!