Spring Data MongoDB : Query document

In this tutorial we will discuss about the querying the document to the mongoDB. Document is same as a row in the table of relational database. In the our example we will fire query ti access a document from "dojCollection" of "dineshonjavaDB".

Querying Documents-
You can express your queries using the Query and Criteria classes which have method names that mirror the native MongoDB operator names such as lt, lte, is, and others. The Query and Criteria classes follow a fluent API style so that you can easily chain together multiple method criteria and queries while having easy to understand code. Static imports in Java are used to help remove the need to see the 'new' keyword for creating Query and Criteria instances so as to improve readability.

1. Querying documents in a collection-

We saw how to retrieve a single document using the findOne and findById methods on MongoTemplate in previous sections which return a single domain object. We can also query for a collection of documents to be returned as a list of domain objects. Assuming that we have a number of Person objects with name and age stored as documents in a collection and that each person has an embedded account document with a balance. We can now run a query using the following code.
For Example-

import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;
    ...
List<Employee> result = 
mongoTemplate.find(query(where("age").lt(50).and("salary").gt(50000))
,Employee.class);

All find methods take a Query object as a parameter. This object defines the criteria and options used to perform the query. The criteria is specified using a Criteria object that has a static factory method named where used to instantiate a new Criteria object. We recommend using a static import for org.springframework.data.mongodb.core.query.Criteria.where and Query.query to make the query more readable.

This query should return a list of Employee objects that meet the specified criteria. The Criteria class has the following methods that correspond to the operators provided in MongoDB.

As you can see most methods return the Criteria object to provide a fluent style for the API.

Methods for the Criteria class

• Criteria all (Object o)Creates a criterion using the $all operator
• Criteria and (String key) Adds a chained Criteria with the specified key to the current Criteria and retuns the newly created one
• Criteria andOperator (Criteria... criteria)Creates an and query using the $and operator for all of the provided criteria (requires MongoDB 2.0 or later)
• Criteria elemMatch (Criteria c) Creates a criterion using the $elemMatch operator
• Criteria exists (boolean b) Creates a criterion using the $exists operator
• Criteria gt (Object o)Creates a criterion using the $gt operator
• Criteria gte (Object o)Creates a criterion using the $gte operator
• Criteria in (Object... o) Creates a criterion using the $in operator for a varargs argument.
• Criteria in (Collection<?> collection) Creates a criterion using the $in operator using a collection
• Criteria is (Object o)Creates a criterion using the $is operator
• Criteria lt (Object o)Creates a criterion using the $lt operator
• Criteria lte (Object o)Creates a criterion using the $lte operator
• Criteria mod (Number value, Number remainder)Creates a criterion using the $mod operator
• Criteria ne (Object o)Creates a criterion using the $ne operator
• Criteria nin (Object... o) Creates a criterion using the $nin operator
• Criteria norOperator (Criteria... criteria)Creates an nor query using the $nor operator for all of the provided criteria
• Criteria not ()Creates a criterion using the $not meta operator which affects the clause directly following
• Criteria orOperator (Criteria... criteria)Creates an or query using the $or operator for all of the provided criteria
• Criteria regex (String re) Creates a criterion using a $regex
• Criteria size (int s)Creates a criterion using the $size operator
• Criteria type (int t)Creates a criterion using the $type operator

Methods for the Query class

• Query addCriteria (Criteria criteria) used to add additional criteria to the query
• Field fields () used to define fields to be included in the query results
• Query limit (int limit) used to limit the size of the returned results to the provided limit (used for paging)
• Query skip (int skip) used to skip the provided number of documents in the results (used for paging)
• Sort sort () used to provide sort definition for the results

2. Methods for querying for documents-

The query methods need to specify the target type T that will be returned and they are also overloaded with an explicit collection name for queries that should operate on a collection other than the one indicated by the return type.

• findAll Query for a list of objects of type T from the collection.
• findOne Map the results of an ad-hoc query on the collection to a single instance of an object of the specified type.
• findById Return an object of the given id and target class.
• find Map the results of an ad-hoc query on the collection to a List of the specified type.
• findAndRemove Map the results of an ad-hoc query on the collection to a single instance of an object of the specified type. The first document that matches the query is returned and also removed from the collection in the database.

In Spring data for MongoDB, you can use findOne(), find() and getCollection() to get / query documents from mongoDB. See some of the common ways :

Employee employee = new Employee();
 
 //get first found record, from "dojCollection" collection, where empId = 10001
 Employee employee = mongoOperation.findOne(new Query(Criteria
  .where("empId").is(10001)),"dojCollection", Employee.class);
 
 //get all found records, from "dojCollection" collection, where empId <= 10001 abs empAge = 21
 List<Employee> employees = mongoOperation.find(new Query(Criteria
  .where("empId").lte(10001).and("empAge").is(21)), "dojCollection", Employee.class);
 
 //get all records from "dojCollection" collection
 List<Employee> employees = mongoOperation.getCollection("dojCollection", Employee.class);

See the full example to query a document from the "dojCollection" of the "dineshonjavaDB"

Step 1: Creating the domain class Employee
Employee.java  

package com.dineshonjava.mongo.dto;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

/**
 * @author Dinesh Rajput
 *
 */
@Document
public class Employee {
 @Id
 private int empId;
 private String empName;
 private long salary;
 private int empAge;
 public int getEmpId() {
  return empId;
 }
 public void setEmpId(int empId) {
  this.empId = empId;
 }
 public String getEmpName() {
  return empName;
 }
 public void setEmpName(String empName) {
  this.empName = empName;
 }
 public long getSalary() {
  return salary;
 }
 public void setSalary(long salary) {
  this.salary = salary;
 }
 public int getEmpAge() {
  return empAge;
 }
 public void setEmpAge(int empAge) {
  this.empAge = empAge;
 }
 @Override
 public String toString() {
  return "Employee [age=" + empAge + ", empName=" + empName + ", empId="
    + empId + ", salary=" + salary + "]";
 }
}

Step 2: Creating configuration file
mongo-config.xml

<beans xmlns:context="http://www.springframework.org/schema/context" xmlns:mongo="http://www.springframework.org/schema/data/mongo" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
      http://www.springframework.org/schema/data/mongo
      http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">
  
 <!-- Default bean name is 'mongo' -->
 <mongo:mongo host="localhost" port="27017"/>
  <!-- Default bean name is 'mongo' -->
 <mongo:mongo>
  <mongo:options connections-per-host="100"
   threads-allowed-to-block-for-connection-multiplier="5"
            max-wait-time="120000000"
            connect-timeout="10000000"
            socket-keep-alive="true"
            socket-timeout="15000000"
            auto-connect-retry="true"/>
 <context:annotation-config/>
     
    <context:component-scan base-package="com.dineshonjava.mongo">
      <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration"/>
    </context:component-scan>
    
 <!-- Offers convenience methods and automatic mapping between MongoDB JSON documents and your domain classes. -->
   <bean class="org.springframework.data.mongodb.core.MongoTemplate" id="mongoTemplate">
       <constructor-arg ref="mongo"/>
 <constructor-arg name="databaseName" value="dineshonjavaDB"/>
   </bean>
  
</beans>           
 

package com.dineshonjava.mongo.main;

import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import com.dineshonjava.mongo.dto.Employee;

/**
 * @author Dinesh Rajput
 *
 */
@Repository
public class HelloMongoDB {
 
 @Autowired
 MongoOperations mongoOperations;
 
 public void execute() {
  if (mongoOperations.collectionExists("dojCollection")) {
   mongoOperations.dropCollection("dojCollection");
   }
    Employee employee3 = new Employee();  
    employee3.setEmpId(1001);  
    employee3.setEmpName("Dinesh Rajput");  
    employee3.setSalary(70000);  
    employee3.setEmpAge(26);  
  
    Employee employee4 = new Employee();  
    employee4.setEmpId(1002);  
    employee4.setEmpName("Adesh Rajput");  
    employee4.setSalary(30000);  
    employee4.setEmpAge(23);  
      
    Employee employee5 = new Employee();  
    employee5.setEmpId(1003);  
    employee5.setEmpName("Vinesh Rajput");  
    employee5.setSalary(32000);  
    employee5.setEmpAge(23);  
      
    Employee employee6 = new Employee();  
    employee6.setEmpId(1004);  
    employee6.setEmpName("Sweety Rajput");  
    employee6.setSalary(50000);  
    employee6.setEmpAge(22);  
      
    List<Employee> empList = new ArrayList<Employee>();
    empList.add(employee3);  
    empList.add(employee4);  
    empList.add(employee5);  
    empList.add(employee6);  
     
    mongoOperations.insert(empList, "dojCollection");  
    System.out.println("***********************CASE 1************************");
  // Case 1 ... where empId = 1001
  // find
  Employee employee1 = mongoOperations.findOne(query(where("empId").is(1001)), Employee.class,"dojCollection");
  System.out.println(employee1);
   System.out.println("***********************CASE 2************************");
  // Case 2 ... where empAge >= 23 and salary = 70000
  // find
  List<Employee> employee2 = mongoOperations.find(query(where("salary").is(70000).and("empAge").gte(23)), Employee.class,"dojCollection");
  System.out.println(employee2);
  System.out.println("***********************CASE 3************************");   
  // Case 3 ... where empId <= 10002 and age = 23
  // find
  List<Employee> employee = mongoOperations.find(query(where("empId").lte(10002).and("empAge").is(23)), Employee.class,"dojCollection");
  System.out.println(employee);
 }
}

package com.dineshonjava.mongo.main;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Dinesh Rajput
 *
 */
public class HelloMongoTestApp {

 /**
  * @param args
  */
 public static void main(String[] args) {
   ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("mongo-config.xml");
   
   HelloMongoDB hello = (HelloMongoDB) context.getBean("helloMongoDB");
   hello.execute();
   System.out.println( "DONE!" );
 }

}