{"id":89011,"date":"2019-03-04T09:00:32","date_gmt":"2019-03-04T07:00:32","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=89011"},"modified":"2019-03-11T09:24:51","modified_gmt":"2019-03-11T07:24:51","slug":"build-reactive-app-spring-boot-mongodb","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/03\/build-reactive-app-spring-boot-mongodb.html","title":{"rendered":"Build a Reactive App with Spring Boot and MongoDB"},"content":{"rendered":"

\u201cI love writing authentication and authorization code.\u201d ~ No Java Developer Ever.<\/b> Tired of building the same login screens over and over? Try the Okta API for hosted authentication, authorization, and multi-factor auth.<\/a><\/span><\/p>\n

Reactive apps allow you to scale better if you\u2019re dealing with lots of streaming data. They\u2019re non-blocking and tend to be more efficient because they\u2019re not tying up processing while waiting for stuff to happen.<\/p>\n

Reactive systems embrace asynchronous I\/O. The concept behind asynchronous I\/O is straightforward: alleviate inefficient resource utilization by reclaiming resources that would otherwise be idle as they waited for I\/O activity. Asynchronous I\/O inverts the normal design of I\/O processing: the clients are notified of new data instead of asking for it; this frees the client to do other things while waiting.<\/p>\n

If you\u2019re going to build a reactive app, you\u2019ll need it to be reactive all the way down to your database. Use a blocking JDBC driver with Spring WebFlux, and you\u2019ll be disappointed in its performance. Use a reactive NoSQL database like Cassandra, MongoDB, Couchbase and Redis \u2013 and you\u2019ll be impressed by its performance.<\/p>\n

In this tutorial, you\u2019ll learn how to use Spring Boot, Spring WebFlux, and Spring Data to create a reactive web service that talks to a NoSQL database backend (MongoDB, in this case).<\/p>\n

I just threw a handful of terms at you. Let\u2019s go over them.<\/p>\n

If you already understand NoSQL and Reactive programming and just want to see some code, feel free to skip the first two sections and start with \u201cBuild a Spring Boot Resource Server\u201d.<\/em><\/p>\n

NOTE:<\/strong> The first part of this series demonstrated how to use Spring Boot and Spring Data with a relational database, PostgreSQL. You can check out that post here<\/a>.<\/p>\n

What is NoSQL and Why MongoDB?<\/h2>\n

NoSQL<\/strong> is a term for any non-relational database. In relational databases (think SQL, MySQL, etc\u2026), data is stored in tables with strong typing and well-defined relationships between table columns. The tight, well-defined structure of relational databases is both their strength and their weakness. It\u2019s a trade-off. NoSQL databases explode this model and provide other models that allow for more flexibility and ease of scaling.<\/p>\n

The microservice\/cluster model of scaling created lots of problems for relational databases. They just weren\u2019t built to run and stay in sync across multiple machines. NoSQL databases were developed, in part, to address this problem. Often, they were built with clustering and horizontal scaling in mind. To present this another way, classically with SQL databases, if you needed more power, you had to resize the server that the database was running on; it was pretty monolithic, and this is hard to do dynamically, even with all the modern virtual server snazziness available these days. At internet scale, a far better model is to have a flexible cluster of databases that automatically sync between them and that allow you to spin up instances as demand requires (and spin them down when demand lessens). This means that adding more power doesn\u2019t require ever more expensive machines; you can simply add more, relatively cheap machines as needed.<\/p>\n

Another potential benefit of NoSQL databases is their flexibility. A document-based NoSQL database like MongoDB can store arbitrary data in documents. Fields can be added to the stored documents on the fly, without the overhead of table migrations and what not. Of course, this doesn\u2019t solve the problem of versioning and it\u2019s still up to the app to deal with the changing data structure (not always trivial), but at least you\u2019re not fighting the database.<\/p>\n

All that said, keep in mind that SQL\/relational databases aren\u2019t going anywhere. They\u2019re proven, fast, and super reliable. In some use cases, they\u2019re cheaper and easier. MySQL is hard to beat for a simple website or blog, for example. But even in an enterprise setting, sometimes you want the structure that a relational database enforces.<\/em> If you have a fairly static data model and don\u2019t need to scale to internet scale, SQL may be the best choice. These types of design considerations are worth pondering before you dive into a database choice simply because it\u2019s new and flashy.<\/p>\n

I\u2019m using MongoDB in this tutorial because it\u2019s a breeze to start with. If you use Spring Data MongoDB, it\u2019s even easier!<\/p>\n

Get Reactive!<\/h2>\n

Reactive is another great bit of jargon. It feels like the kind of word that people like to throw around at parties and conferences with only vague ideas of what it actually means. Like \u201cexistential\u201d or \u201cennui.\u201d Let\u2019s define it.<\/p>\n

If you take a look at the Spring WebFlux documentation<\/a>, they give a pretty good overview of what reactive<\/strong> means.<\/p>\n

\n

The term, \u201creactive,\u201d refers to programming models that are built around reacting to change\u2009\u2014\u2009network components reacting to I\/O events, UI controllers reacting to mouse events, and others. In that sense, non-blocking is reactive, because, instead of being blocked, we are now in the mode of reacting to notifications as operations complete or data becomes available.<\/p>\n<\/blockquote>\n

So reactive means: non-blocking, asynchronous, and centered around stream processing.<\/p>\n

Build a Spring Boot Resource Server<\/h2>\n

Clone the starter project from the GitHub repository and check out the start<\/strong> branch:<\/p>\n

git clone -b start https:\/\/github.com\/oktadeveloper\/okta-spring-boot-mongo-webflux-example.git\n<\/pre>\n
The starter project is a simple Spring Boot starter project with the necessary dependencies already in the build.gradle<\/code> file.<\/p>\n
Let\u2019s take a quick look at the dependencies:<\/p>\n
compile('org.springframework.boot:spring-boot-starter-webflux')  \ncompile('org.springframework.boot:spring-boot-starter-data-mongodb-reactive')  \ncompileOnly('org.projectlombok:lombok')  \ncompile('de.flapdoodle.embed:de.flapdoodle.embed.mongo')\n<\/pre>\n
The first is for Spring WebFlux, the reactive version of Spring MVC. The second brings in the reactive MongoDB dependencies that Spring needs. The third is a project called Lombok that saves us from typing a bunch of constructors, getters, and setters in our Java code (you can check out the project on their webpage<\/a>). The last dependency is an embedded, in-memory MongoDB database. This database is great for testing, simple tutorials like this, and isn\u2019t persisted.<\/p>\n
The application can be run using a simple Gradle command:<\/p>\n
.\/gradlew bootRun<\/pre>\n
Of course, if you run the app at this point it\u2019s not going to do much. Spring Boot will load, but there aren\u2019t any controllers, resources, or repositories defined yet, so nothing much happens.<\/p>\n
Define a Model Class for MongoDB<\/h2>\n
For clarity, this tutorial is going to parallel the first part of this series<\/a> that I mentioned earlier. You\u2019re going to build a simple server that stores types of kayaks. I always suggest starting any project by defining the data structure first.<\/p>\n
Create a Kayak.java<\/code> class file in the com.okta.springbootmongo<\/code> package:<\/p>\n
package com.okta.springbootmongo;  \n\nimport lombok.AllArgsConstructor;  \nimport lombok.Data;  \nimport lombok.NoArgsConstructor;  \nimport org.springframework.data.mongodb.core.mapping.Document;  \n\n@Document\n@Data  \n@AllArgsConstructor  \n@NoArgsConstructor  \npublic class Kayak {  \n    private String name;  \n    private String owner;  \n    private Number value;  \n    private String makeModel;  \n}\n<\/pre>\n
The @Document<\/code> annotation is the NoSQL equivalent of @Entity<\/code>. It tells Spring Boot that this class is defining a data model. In the NoSQL world, this means creating a document instead of a table entry. The other three annotations are Lombok helpers that autogenerate getters, setters, and constructors.<\/p>\n
The kayak document has five properties: name, owner, value, and type. These are automatically mapped to appropriate BSON types for MongoDB. What\u2019s a BSON type? Take a look at the MongoDB docs on the subject<\/a>. They are the binary serialization types used to persist data in MongoDB documents. They define the primitive types that can be stored in a MongoDB database.<\/p>\n
Add a ReactiveMongoRepository to Your Spring Boot App<\/h2>\n
Defining the Kayak class with the @Document<\/code> annotation tells Spring Boot about the structure of the data, but doesn\u2019t actually give us any way of saving or loading data from the database. In order to do that, you need to define a Repository.<\/p>\n
The code for that is beguilingly simple. Create a KayakRepository.java<\/code> class file in the com.okta.springbootmongo<\/code>package:<\/p>\n
package com.okta.springbootmongo;  \n  \nimport org.springframework.data.mongodb.repository.ReactiveMongoRepository;  \n\npublic interface KayakRepository extends ReactiveMongoRepository<Kayak, Long> {  \n}\n<\/pre>\n
This actually gives you all of the basic methods you need to create, update, read, and delete documents from the database. To understand how, dig into the ReactiveMongoRepository<\/code> class and the various other superclasses, particularly ReactiveCrudRepository<\/code>. Take a look at the docs<\/a> for ReactiveCrudRepository<\/code> to see the implemented methods.
 
<\/div> <\/div><\/p>\n
ReactiveCrudRepository<\/code> actually provides a basic and complete set of CRUD methods. ReactiveMongoRepository<\/code>builds on top of that to provide some MongoDB-specific querying features.<\/p>\n
Implement a Controller with Spring WebFlux<\/h2>\n
With the repository added, you have enough to manipulate the data programmatically. However, there are no web endpoints defined. In the previous tutorial, to add REST endpoints, all that was required was to add the @RepositoryRestResource<\/code>annotation to the KayakRepository<\/code> class. This autogenerated a fully functioning REST resource for us with all of the CRUD methods. This shortcut does not work with Spring WebFlux, however. Any public web endpoints will have to be explicitly defined.<\/p>\n
Add the following KayakController.java<\/code> class<\/p>\n
package com.okta.springbootmongo;  \n  \nimport org.springframework.beans.factory.annotation.Autowired;  \nimport org.springframework.stereotype.Controller;  \nimport org.springframework.web.bind.annotation.*;  \nimport reactor.core.publisher.Flux;  \n\n@Controller  \n@RequestMapping(path = \"\/kayaks\")  \npublic class KayakController {  \n  \n    private KayakRepository kayakRepository;  \n    \n    public KayakController(KayakRepository kayakRepository) {\n        this.kayakRepository = kayakRepository;\n    }\n  \n    @PostMapping()  \n    public @ResponseBody  \n    Mono<Kayak> addKayak(@RequestBody Kayak kayak) {  \n        return kayakRepository.save(kayak);  \n    }  \n  \n    @GetMapping()  \n    public @ResponseBody  \n    Flux<Kayak> getAllKayaks() {  \n        return kayakRepository.findAll();  \n    }\n}\n<\/pre>\n
This controller adds two endpoints:<\/p>\n