Generic Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Introduction

In many data-centric applications, there might be situations where we need to check whether a particular object already exists.

In this tutorial, we’ll discuss several ways to achieve precisely that using Spring Data and JPA.

2. Sample Entity

To set the stage for our examples, let’s create an entity Car with two properties, model and power:

public class Car {

    private int id;

    private Integer power;
    private String model;
    // getters, setters, ...

3. Searching by ID

The JpaRepository interface exposes the existsById method that checks if an entity with the given id exists in the database:

int searchId = 2; // ID of the Car
boolean exists = repository.existsById(searchId)

Let’s assume that searchId is the id of a Car we created during test setup. For the sake of test repeatability, we should never use a hard-coded number (for example “2”) because the id property of a Car is likely auto-generated and could change over time. The existsById query is the easiest but least flexible way of checking for an object’s existence.

4. Using a Derived Query Method

We can also use Spring’s derived query method feature to formulate our query. In our example, we want to check if a Car with a given model name exists, therefore we devise the following query method:

boolean existsCarByModel(String model);

It’s important to note that the naming of the method is not arbitrary — it must follow certain rules. Spring will then generate the proxy for the repository such that it can derive the SQL query from the name of the method. Modern IDEs like IntelliJ IDEA will provide syntax completion for that.

When queries get more complex – for example, by incorporating ordering, limiting results, and several query criteria – these method names can get quite long, right up to the point of illegibility. Also, derived query methods might seem magical because of their implicit and “by convention” nature.

Nevertheless, they can come in handy when clean and uncluttered code is important and when developers want to rely on a well-tested framework.

5. Searching by Example

An Example is a very powerful way of checking for existence because it uses ExampleMatchers to dynamically build the query. So, whenever we require dynamicity, this is a good way to do it. A comprehensive explanation of Spring ExampleMatchers and how to use them can be found in our Spring Data Query article.

5.1. The Matcher

Suppose that we want to search for model names in a case-insensitive way. Let’s start by creating our ExampleMatcher:

ExampleMatcher modelMatcher = ExampleMatcher.matching()
  .withMatcher("model", ignoreCase());

Note that we must explicitly ignore the id path because id is the primary key and those are picked up automatically by default.

5.2. The Probe

Next, we need to define a so-called “probe”, which is an instance of the class we want to look up. It has all search-relevant properties set. We then connect it to our nameMatcher and execute the query:

Car probe = new Car();
Example<Car> example = Example.of(probe, modelMatcher);
boolean exists = repository.exists(example);

With great flexibility comes great complexity, and as powerful as the ExampleMatcher API may be, using it will produce quite a few lines of extra code. We suggest using this in dynamic queries or if no other method fits the need.

6. Writing a Custom JPQL Query with Exists Semantics

The last method we’ll examine uses JPQL (Java Persistence Query Language) to implement a custom query with existssemantics:

@Query("select case when count(c)> 0 then true else false end from Car c where lower(c.model) like lower(:model)")
boolean existsCarLikeCustomQuery(@Param("model") String model);

The idea is to execute a case-insensitive count query based on the model property, evaluate the return value, and map the result to a Java boolean. Again, most IDEs have pretty good support for JPQL statements.

Custom JPQL queries can be seen as an alternative to derived methods and are often a good choice when we’re comfortable with SQL-like statements and don’t mind the additional @Query annotations.

7. Conclusion

In this tutorial, we saw how to check if an object exists in a database using Spring Data and JPA. There is no hard and fast rule when to use which method because it’ll largely depend on the use case at hand and personal preference.

As a rule of thumb, though, given a choice, developers should always lean toward the more straightforward method for reasons of robustness, performance, and code clarity. Also, once decided on either derived queries or custom JPQL queries, it’s a good idea to stick with that choice for as long as possible to ensure a consistent coding style.

A complete source code example can be found on Github.

Generic bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2: