Like with any database, you'll routinely make calls to read, write or update data stored in the document store. In many cases, retrieving data isn't as simple as just writing a single query (even though queries can get pretty complex). Show
With MongoDB - Aggregations are used to process many documents, and return some computed result. This is achieved by creating a Pipeline of operations, where each operation takes in a set of documents, and filters them given some criteria. Spring Data MongoDB is Spring's module that acts as an interface between a Spring Boot application and MongoDB. Naturally, it offers a set of annotations that allow us to easily "switch" features on and off, as well as let the module itself know when it should take care of things for us.
In this guide, we'll take a look at how to leverage the Domain Model and RepositoryLet's start out with our domain model and a simple repository. We'll create a And with it, a simple associated Reminder: Through aggregations, you can, naturally, sort and paginate the results as well, taking advantage of the fact that it's extending the Understanding the @Aggregation AnnotationThe Various stages exist, and they allow you to perform a wide variety of operations. Some of the more commonly used ones are:
Some of these are terminal operations (applied at the end), such as In our case, to add an Or, you can keep them inline: Depending on the number of stages you have, the latter option might get illegible fairly quickly. In general, it helps to break the stages down in new lines for readability. That being said, let's add some operations to the pipeline! Let's, for instance, search for properties that have a field that matches a given value, such as properties whose Though, having a single match like this beats the point of aggregation. Let's add some more matching conditions. Don't forget, you can supply any number of matching conditions here, including selectors/operators such as Now, we'd be searching for properties that match the Additionally, it's no fun when you deal with fixed values. Who's to say this is an expensive property? It would be much more useful to be able to supply a lower mark to the method call, and use that with the This is where named and positional method parameters come in. Referencing Named and Positional Method ParametersWe rarely deal with just static numbers, since they're, well, not flexible. We want to offer flexibility both to end-users, but also to developers. In the example before, we've used two fixed values - Using named or positional arguments doesn't change the code functionally, and it's generally up to the engineer/team to decide which option to go with, based on their preferences. It's worth being consistent with one type, once you've chosen it: Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it! The former is more concise, but it does require you to enforce the order of the arguments coming in. Additionally, if the field in the database itself isn't indicative of the type/expected value (which is bad design, but sometimes is out of your control) - using positional arguments might add to the confusion, as there's a small amount of ambiguity as to what value you can expect. The latter is, admittedly, more verbose, but it does allow you to mix the order of parameters. There's no need to enforce their position, as they're matched by the There's no objectively better option here, nor one that's widely accepted in the industry. Choose the one you feel more comfortable with yourself. Tip: If you've turned on Now, you can supply values to the method calls, and they'll be used in the When you're dealing with larger corpora of data, it's worth looking into sorting and paging, as well. End-users shouldn't be expected to sort through the data themselves. Sorting and PagingSorting is typically done at the end, since sorting beforehand might end up being redundant. You can either apply sorting methods after the aggregation takes place, or during the aggregation. Here, we'll explore the prospect of applying sorting methods inside the aggregation itself. We'll sample some number of properties, and sort them, say, by Here, we've sorted the properties by area, in descending order - meaning, the properties with the largest area will show up first in the sort. The transaction type, price and sample size are all variable and can be dynamically set. If you'd like to incorporate Pagination into this, the standard Spring Boot pagination approach is applied - you just add a When calling the method from a controller, you'll want to construct a The Note: Since we've already sorted the properties in the aggregation, there's no need to include any additional sorting configuration there. Alternatively, you can skip the Creating a REST APILet's quickly spin up a REST API that exposes the results of these methods to an end user, and send a
We'll firstly want to add a few properties to the database: Now, let's Note: For a pretty-print response, remember to turn Jackson's And now, let's define a This should return up to 5 randomly selected properties from a set of properties that are for sale, over 100k in price, sorted by their area. If there are no 5 samples to choose from - all of the fitting properties are returned: Works like a charm! ConclusionIn this guide, we've gone over the We've overviewed some of the common operations in an aggregation pipeline, before writing our own pipelines with static and dynamic arguments. We've explored positional and named parameters for the aggregations, and finally, spun up a simple REST API to serve the results. |
Cara menggunakan spring boot mongodb sum
Pos Terkait
Copyright © 2024 apacode Inc.
