If you have a few years of experience in the Java ecosystem, and you're interested in sharing that experience with the community (and getting paid for your work of course), have a look at the "Write for Us" page. Cheers. Eugen

I usually post about Persistence on Twitter - you can follow me there:

1. Overview

This article will focus on building out different types of queries in Spring Data MongoDB.

We’re going to be looking at querying documents with Query and Criteria classes, auto-generated query methods, JSON queries and QueryDSL.

1.1. Maven Dependencies

If you want to work with Spring Data MongoDB, you need to add the following entry to your pom.xml file:

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>1.9.6.RELEASE</version>
</dependency>

The newest version can be found here.

2. Documents Query

One of the more common ways to query MongoDB with Spring Data is by making use of the Query and Criteria classes – which very closely mirror native operators.

2.1. Is

This is simply a criterion using equality – let’s see how it works.

In the following example – we’re looking for users named Eric.

Let’s look at our database:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 55
    }
}

Now let’s look at query code:

Query query = new Query();
query.addCriteria(Criteria.where("name").is("Eric"));
List<User> users = mongoTemplate.find(query, User.class);

This logic returns, as expected:

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.2. Regex

A more flexible and powerful type of query is the regex. This creates a criterion using a MongoDB $regex that returns all records suitable for this regexp for this field.

It works similar to startingWith, endingWith operations – let’s look at an example.

We’re now looking for all users that have names starting with A.

Here’s the state of the database:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

Let’s now create the query:

Query query = new Query();
query.addCriteria(Criteria.where("name").regex("^A"));
List<User> users = mongoTemplate.find(query,User.class);

This runs and returns 2 records:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

Here’s another quick example, this time looking for all users that have names ending with c:

Query query = new Query();
query.addCriteria(Criteria.where("name").regex("c$"));
List<User> users = mongoTemplate.find(query, User.class);

So the result will be:

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.3. Lt and gt

These operators create a criterion using the $lt (less than) operator and $gt (greater than).

Let’s have a quick look at an example – we’re looking for all users with age between 20 and 50.

The database is:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 55
    }
}

This query code:

Query query = new Query();
query.addCriteria(Criteria.where("age").lt(50).gt(20));
List<User> users = mongoTemplate.find(query,User.class);

And the result – all user who with an age of greater than 20 and less than 50:

{
    "_id" : ObjectId("55c0e5e5511f0a164a581907"),
    "_class" : "org.baeldung.model.User",
    "name" : "Eric",
    "age" : 45
}

2.4. Sort

Sort is used to specify a sort order for the results.

The example below returns all users sorted by age in ascending order.

First – here’s the existing data:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

After executing sort:

Query query = new Query();
query.with(new Sort(Sort.Direction.ASC, "age"));
List<User> users = mongoTemplate.find(query,User.class);

And here’s the result of the query – nicely sorted by age:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    }
]

2.5. Pageable

Let’s look at a quick example using pagination.

Here’s the state of the database:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

Now, the query logic, simply asking for a page of size 2:

final Pageable pageableRequest = new PageRequest(0, 2);
Query query = new Query();
query.with(pageableRequest);

And the result – the 2 documents, as expected:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581907"),
        "_class" : "org.baeldung.model.User",
        "name" : "Eric",
        "age" : 45
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    }
]

To explore the full details of this API, here is the documentations for the Query and Criteria classes.

3. Generated Query Methods

Let’s now explore the more common type of query that Spring Data usually provides – auto-generated queries out of method names.

The only thing we need to do to leverage these kinds of queries is to declare the method on the repository interface:

public interface UserRepository 
  extends MongoRepository<User, String>, QueryDslPredicateExecutor<User> {
    ...
}

3.1. FindByX

We’ll start simple, by exploring the findBy type of query – in this case, find by name:

List<User> findByName(String name);

Same as in the previous section – 2.1 – the query will have the same results, finding all users with the given name:

List<User> users = userRepository.findByName("Eric");

3.2. StartingWith and endingWith.

In 2.2, we explored a regex based query. Starts and ends with are of course less powerful, but nevertheless quite useful – especially if we don’t have to actually implement them.

Here’s a quick example of how the operations would look like:

List<User> findByNameStartingWith(String regexp);
List<User> findByNameEndingWith(String regexp);

The example of actually using this would, of course, be very simple:

List<User> users = userRepository.findByNameStartingWith("A");
List<User> users = userRepository.findByNameEndingWith("c");

And the results are exactly the same.

3.3. Between

Similar to 2.3, this will return all users with age between ageGT and ageLT:

List<User> findByAgeBetween(int ageGT, int ageLT);

Calling the method will result in exactly the same documents being found:

List<User> users = userRepository.findByAgeBetween(20, 50);

3.4. Like and OrderBy

Let’s have a look at a more advanced example this time – combining two types of modifiers for the generated query.

We’re going to be looking for all users that have names containing the letter A and we’re also going to order the results by age, in ascending order:

List<User> users = userRepository.findByNameLikeOrderByAgeAsc("A");

For the database we used in 2.4 – the result will be:

[
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581908"),
        "_class" : "org.baeldung.model.User",
        "name" : "Antony",
        "age" : 33
    },
    {
        "_id" : ObjectId("55c0e5e5511f0a164a581909"),
        "_class" : "org.baeldung.model.User",
        "name" : "Alice",
        "age" : 35
    }
]

4. JSON Query Methods

If we can’t represent a query with the help of a method name, or criteria, we can do something more low level – use the @Query annotation.

With this annotation, we can specify a raw query – as a Mongo JSON query string.

4.1. FindBy

Let’s start simple and look at how we would represent a find by type of method first:

@Query("{ 'name' : ?0 }")
List<User> findUsersByName(String name);

This method should return users by name – the placeholder ?0 references the first parameter of the method.

List<User> users = userRepository.findUsersByName("Eric");

4.2 $regex

Let’s also look at a regex driven query – which of course produces the same result as in 2.2 and 3.2:

@Query("{ 'name' : { $regex: ?0 } }")
List<User> findUsersByRegexpName(String regexp);

The usage is also exactly the same:

List<User> users = userRepository.findUsersByRegexpName("^A");
List<User> users = userRepository.findUsersByRegexpName("c$");

4.3. $lt and $gt

Let’s now implement the lt and gt query:

@Query("{ 'age' : { $gt: ?0, $lt: ?1 } }")
List<User> findUsersByAgeBetween(int ageGT, int ageLT);

Now how, now that the method has 2 parameters, we’re referencing each of these by index in the raw query: ?0 and ?1.

List<User> users = userRepository.findUsersByAgeBetween(20, 50);

5. QueryDSL Queries

MongoRepository has good support for the QueryDSL project – so we can leverage that nice, type-safe API here as well.

5.1. The Maven Dependencies

First, let’s make sure we have the correct Maven dependencies defined in the pom:

<dependency>
    <groupId>com.mysema.querydsl</groupId>
    <artifactId>querydsl-mongodb</artifactId>
    <version>3.6.6</version>
</dependency>
<dependency>
    <groupId>com.mysema.querydsl</groupId>
    <artifactId>querydsl-apt</artifactId>
    <version>3.6.6</version>
</dependency>

5.2. Q-classes

QueryDSL used Q-classes for creating queries. But, since we don’t really want to create these by hand, we need to generate them somehow.

We’re going to use the apt-maven-plugin to do that:

<plugin>    
    <groupId>com.mysema.maven</groupId>
    <artifactId>apt-maven-plugin</artifactId>
    <version>1.1.3</version>
    <executions>
        <execution>
            <goals>
                <goal>process</goal>
            </goals>
            <configuration>
                <outputDirectory>target/generated-sources/java</outputDirectory>
                <processor>
                  org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor
                </processor>
            </configuration>
        </execution>
     </executions>
</plugin>

Let’s look at the User class – focusing specifically at the @QueryEntity annotation:

@QueryEntity 
@Document
public class User {
 
    @Id
    private String id;
    private String name;
    private Integer age;
 
    // standard getters and setters
}

After running the process goal of the Maven lifecycle (or anything another goal after that one) – the apt plugin will generate the new classes under target/generated-sources/java/{your package structure}:

/**
 * QUser is a Querydsl query type for User
 */
@Generated("com.mysema.query.codegen.EntitySerializer")
public class QUser extends EntityPathBase<User> {

    private static final long serialVersionUID = ...;

    public static final QUser user = new QUser("user");

    public final NumberPath<Integer> age = createNumber("age", Integer.class);

    public final StringPath id = createString("id");

    public final StringPath name = createString("name");

    public QUser(String variable) {
        super(User.class, forVariable(variable));
    }

    public QUser(Path<? extends User> path) {
        super(path.getType(), path.getMetadata());
    }

    public QUser(PathMetadata<?> metadata) {
        super(User.class, metadata);
    }
}

It’s with the help of this class that we’re not going to be creating our queries.

As a side note – if you’re using Eclipse, introducing this plugin will generate the following warning in pom:

You need to run build with JDK or have tools.jar on the classpath. If this occurs during eclipse build make sure you run eclipse under JDK as well (com.mysema.maven:apt-maven-plugin:1.1.3:process:default:generate-sources

Maven install works fine and QUser class is generated, but a plugin is highlighted in the pom.

A quick fix is to manually point to the JDK in eclipse.ini:

...
-vm
{path_to_jdk}\jdk{your_version}\bin\javaw.exe

5.3. The New Repository

Now we need to actually enable QueryDSL support in our repositories – which is done by simply extending the QueryDslPredicateExecutor interface:

public interface UserRepository extends 
  MongoRepository<User, String>, QueryDslPredicateExecutor<User>

5.4. Eq

With support enabled, let’s now implement the same queries as the ones we illustrated before.

We’ll start with simple equality:

QUser qUser = new QUser("user");
Predicate predicate = qUser.name.eq("Eric");
List<User> users = (List<User>) userRepository.findAll(predicate);

5.5. StartingWith and EndingWith

Similarly, let’s implement the previous queries – and find users with names that are starting with A:

QUser qUser = new QUser("user");
Predicate predicate = qUser.name.startsWith("A");
List<User> users = (List<User>) userRepository.findAll(predicate);

And ending with c:

QUser qUser = new QUser("user");
Predicate predicate = qUser.name.endsWith("c");
List<User> users = (List<User>) userRepository.findAll(predicate);

The result with same as in 2.2, 3.2 or 4.2.

5.6. Between

The next one query will return users with age between 20 and 50 – similar to the previous sections:

QUser qUser = new QUser("user");
Predicate predicate = qUser.age.between(20, 50);
List<User> users = (List<User>) userRepository.findAll(predicate);

6. Conclusion

In this article, we explored the many ways we can query using Spring Data MongoDB.

It’s interesting to take a step back and see just how many powerful ways we have to query MongoDB – varying from limited control all the way to full control with raw queries.

The implementation of all these examples and code snippets can be found in the GitHub project – this is an Eclipse based project, so it should be easy to import and run as it is.

I usually post about Persistence on Twitter - you can follow me there:


Sort by:   newest | oldest | most voted
Michael Herb
Guest

lets say I have the following nodeId in my collection
{…
“nodeId” : “denver41.corp.internet”,
…},
{…
“nodeId” : “denver4.corp.internet”,
…},
{…
“nodeId” : “denver41”,
…}

Now I want to use @Query to return all documents that have nodeId equal to “denver41” or starts with “denver41.” In this case I want the first and 3rd document in the collection.

I want to do something like the below, but Spring Mongo doesn’t like the + “.”

@Query(“{‘$or’:[{‘nodeId’ : ?0}, {‘nodeId’ : {$regex:?0 + “.”,$options:’i’}}]}”)

Is there a way to accomplish this query using the @Query?

Thanks,

Mike

Eugen Paraschiv
Guest

Hey Michael,
I’m not sure on this one – you’ll have to try it out and dig through the docs. My suggestion is – post it on StackOverflow – it’s going to be quicker 🙂
Cheers,
Eugen.

Johan Pretorius
Guest

Something I don’t understand (probably because I’m very new to Spring and am missing something on my classpath). When I try to get Eclipse to autocomplete the type Query, I get only javax.management.Query, which is clearly not what you’re talking about.

Help?

Grzegorz Piwowarek
Guest

Seems like the required library is indeed not on classpath

Johan Pretorius
Guest

Hmm – ok, maybe at the beginning of the work day I can be a little more articulate than “Help” 😀

My question is this: what library should be on the classpath for me to get access to the Query class referenced in this post?

Are there any other libraries I’ll need to follow the rest of the post?

Grzegorz Piwowarek
Guest

I assume you are looking for “org.springframework.data.mongodb.core.query.Query” and this is the part of the Spring Data MongoDB. The whole article is about this library so it would be a good idea to include it 😉

https://search.maven.org/#artifactdetails%7Corg.springframework.data%7Cspring-data-mongodb%7C1.10.0.RELEASE%7Cjar

Johan Pretorius
Guest

Thanks, that’s helpful – it looks like I’ve found it

It would be nice if the article said this explicitly for the benefit of newbies like me.

Grzegorz Piwowarek
Guest

Good idea, we’ll put that in the backlog

wpDiscuz