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.
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.
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.
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”
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 + "]";
}
}
<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);
}
}
Following code shows how to run this example
HelloMongoTestApp.java
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!" );
}
}
If everything is fine then run the above main application as Java Application we will get the following
References
You must read this Spring’s mongodb query documentation, to study more overloaded methods and criteria examples.
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…