snicoll / gs-accessing-data-mongodb

Accessing Data with MongoDB :: Learn how to persist data in MongoDB.

tags	projects
spring-data mongodb	spring-data-mongodb

Table of Contents

• What you’ll build
• What you’ll need
• Set up the project
• Install and launch MongoDB
• Define a simple entity
• Create simple queries
• Create an Application class
• Summary

This guide walks you through the process of using Spring Data MongoDB to build an application that stores data in and retrieves it from MongoDB, a document-based database.

What you’ll build

You will store Person POJOs in a MongoDB database using Spring Data MongoDB.

What you’ll need

https://raw.github.com/spring-guides/getting-started-macros/master/prereq_editor_jdk_buildtools.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/how_to_complete_this_guide.adoc

Set up the project

https://raw.github.com/spring-guides/getting-started-macros/master/build_system_intro.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_directory_structure_hello.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_both_builds.adoc build.gradle

link:initial/build.gradle[role=include]

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

With MacPorts:

$ 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.

$ mongod

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 Customer objects.

src/main/java/hello/Customer.java

link:complete/src/main/java/hello/Customer.java[role=include]

Here you have a Customer class with three attributes, id, firstName, and lastName. The id is mostly for internal use by MongoDB. You also have a single constructor to populate the entities when creating a new instance.

Note	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, firstName and lastName, are left unannotated. It is assumed that they’ll be mapped to columns that share the same name as the properties themselves.

The convenient toString() method will print out the details about a customer.

Note	MongoDB stores data in collections. Spring Data MongoDB will map the class Customer into a collection called customer. If you want to change the name of the collection, you can use Spring Data MongoDB’s @Document annotation on 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 Customer documents.

src/main/java/hello/CustomerRepository.java

link:complete/src/main/java/hello/CustomerRepository.java[role=include]

CustomerRepository extends the MongoRepository interface and plugs in the type of values and id it works with: Customer and 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 firstName.

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.

src/main/java/hello/Application.java

link:complete/src/main/java/hello/Application.java[role=include]

In the configuration, you need to add the @EnableMongoRepositories annotation. This annotation tells Spring Data MongoDB to seek out any interface that extends org.springframework.data.repository.Repository and to automatically generate an implementation. By extending MongoRepository, your CustomerRepository interface transitively extends Repository. Therefore, Spring Data MongoDB will find it and create an implementation for you.

• The Mongo connection links the application to your MongoDB server

• 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.

• Finally, you autowire an instance of CustomerRepository. Spring Data MongoDB dynamically creates a proxy and injects it there.

Application includes a main() method that puts the CustomerRepository through a few tests. First, it fetches the CustomerRepository from the Spring application context. Then 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".

https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_mainhead.adoc https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/run_the_application_with_both.adoc

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']

Summary

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.

Note	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.