What you’ll build
You will store
Customer POJOs in a MongoDB database using Spring Data MongoDB.
What you’ll need
Install and launch MongoDB
With your project set up, you can install and launch the MongoDB database.
If you are using a Mac with homebrew, this is as simple as:
$ brew install mongodb
$ port install mongodb
For other systems with package management, such as Redhat, Ubuntu, Debian, CentOS, and Windows, see instructions at http://docs.mongodb.org/manual/installation/.
After you install MongoDB, launch it in a console window. This command also starts up a server process.
You probably won’t see much more than this:
all output going to: /usr/local/var/log/mongodb/mongo.log
Define a simple entity
MongoDB is a NoSQL document store. In this example, you store
Here you have a
Customer class with three attributes,
id is mostly for internal use by MongoDB. You also have a single constructor to populate the entities when creating a new instance.
|In this guide, the typical getters and setters have been left out for brevity.|
id fits the standard name for a MongoDB id so it doesn’t require any special annotation to tag it for Spring Data MongoDB.
The other two properties,
lastName, are left unannotated. It is assumed that they’ll be mapped to fields that share the same name as the properties themselves.
toString() method will print out the details about a customer.
MongoDB stores data in collections. Spring Data MongoDB will map the class
Create simple queries
Spring Data MongoDB focuses on storing data in MongoDB. It also inherits functionality from the Spring Data Commons project, such as the ability to derive queries. Essentially, you don’t have to learn the query language of MongoDB; you can simply write a handful of methods and the queries are written for you.
To see how this works, create a repository interface that queries
CustomerRepository extends the
MongoRepository interface and plugs in the type of values and id it works with:
String. Out-of-the-box, this interface comes with many operations, including standard CRUD operations (create-read-update-delete).
You can define other queries as needed by simply declaring their method signature. In this case, you add
findByFirstName, which essentially seeks documents of type
Customer and finds the one that matches on
You also have
findByLastName to find a list of people by last name.
In a typical Java application, you write a class that implements
CustomerRepository and craft the queries yourself. What makes Spring Data MongoDB so useful is the fact that you don’t have to create this implementation. Spring Data MongoDB creates it on the fly when you run the application.
Let’s wire this up and see what it looks like!
Create an Application class
Here you create an Application class with all the components.
Spring Boot will handle those repositories automatically as long as they are included
in the same package (or a sub-package) of your
@SpringBootApplication class. For more control over the
registration process, you can use the
Spring Data MongoDB uses the
MongoTemplate to execute the queries behind your
find* methods. You can
use the template yourself for more complex queries, but this guide doesn’t cover that.
Application includes a
main() method that autowires an instance of
CustomerRepository: Spring Data
MongoDB dynamically creates a proxy and injects it there. We use the
CustomerRepository through a few
tests. First, it saves a handful of
Customer objects, demonstrating the
save() method and setting
up some data to work with. Next, it calls
findAll() to fetch all
Customer objects from the database.
Then it calls
findByFirstName() to fetch a single
Customer by her first name. Finally, it calls
findByLastName() to find all customers whose last name is "Smith".
|Spring Boot by default attempts to connect to a locally hosted instance of MongoDB. Read the reference docs for details on pointing your app to an instance of MongoDB hosted elsewhere.|
run method is invoked automatically when boot
starts. You should see something like this (with other stuff like queries as well):
== Customers found with findAll(): Customer[id=51df1b0a3004cb49c50210f8, firstName='Alice', lastName='Smith'] Customer[id=51df1b0a3004cb49c50210f9, firstName='Bob', lastName='Smith'] == Customer found with findByFirstName('Alice'): Customer[id=51df1b0a3004cb49c50210f8, firstName='Alice', lastName='Smith'] == Customers found with findByLastName('Smith'): Customer[id=51df1b0a3004cb49c50210f8, firstName='Alice', lastName='Smith'] Customer[id=51df1b0a3004cb49c50210f9, firstName='Bob', lastName='Smith']
Congratulations! You set up a MongoDB server and wrote a simple application that uses Spring Data MongoDB to save objects to and fetch them from a database — all without writing a concrete repository implementation.
|If you’re interesting in exposing MongoDB repositories with a hypermedia-based RESTful front end with little effort, you might want to read Accessing MongoDB Data with REST.|