{"id":59786,"date":"2020-08-17T14:00:47","date_gmt":"2020-08-17T14:00:47","guid":{"rendered":"https:\/\/www.baeldung.com\/?p=85811"},"modified":"2020-08-17T14:00:47","modified_gmt":"2020-08-17T14:00:47","slug":"introduction-to-spring-data-azure-cosmos-db","status":"publish","type":"post","link":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/2020\/08\/17\/introduction-to-spring-data-azure-cosmos-db\/","title":{"rendered":"Introduction to Spring Data Azure Cosmos DB"},"content":{"rendered":"

<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

In this tutorial, we’ll learn about Azure Cosmos DB and how we can interact with it using Spring Data.<\/p>\n

2. Azure Cosmos DB<\/h2>\n
<\/div>\n

Azure Cosmos DB<\/a> is Microsoft’s globally distributed database service.<\/strong><\/p>\n

It’s a NoSQL database<\/strong>, which\u00a0provides comprehensive service level agreements for throughput, latency, availability, and consistency guarantees. Also, it assures 99.999% availability<\/a> for both reads and writes.<\/p>\n

Azure Cosmos DB does not give only two consistency choices i.e. either consistent or not consistent. Instead, we get five consistency choices: strong<\/em>, bounded staleness<\/em>, session<\/em>, consistent prefix<\/em>, and eventual<\/em>.<\/strong><\/p>\n

We can elastically scale both the throughput and storage of Azure Cosmos DB.<\/p>\n

Additionally, it’s available in all Azure regions and offers turnkey global distribution\u00a0as we can replicate our data in any Azure regions just by clicking a button. This helps us in having our data closer to our users so that we can serve their requests faster.<\/p>\n

It’s schema-agnostic<\/strong> as it has no schema<\/strong>. Furthermore, we don’t need to do any index management for Azure Cosmos Db. It automatically does indexing of data for us.<\/p>\n

We can work with Azure CosmosDb using different standard APIs such as SQL, MongoDB, Cassandra, etc.<\/p>\n

3. Spring Data Azure Cosmos DB<\/h2>\n
<\/div>\n

Microsoft also provides a module that allows us to work with Cosmos DB using Spring Data<\/strong>. In the next section, we’ll see how we can use Azure Cosmos DB in a Spring Boot application.<\/p>\n

In our example, we’ll create a Spring web application that stores a product entity in an Azure Cosmos database and performs basic CRUD operations on it. First, we need to configure an account and database in the Azure portal, following the instructions in the documentation<\/a>.<\/p>\n

If we don’t want to create an account on the Azure portal, Azure also provides the Azure Cosmos Emulator.<\/strong> Even though this doesn’t contain all the functionalities of Azure Cosmos Service and there are some differences, we can use it for local development and testing.<\/p>\n

We can use the Emulator in our local environment in two ways: either by downloading the Azure Cosmos Emulator on our machine or running the Emulator<\/a> on Docker for Windows.<\/p>\n

We’ll choose the option to run it on Docker<\/strong> for Windows. Let’s pull the Docker image by running the following command:<\/p>\n

docker pull microsoft\/azure-cosmosdb-emulator<\/code><\/pre>\n
Then we can run the Docker image and start the container by running the following commands:<\/p>\n
set containerName=azure-cosmosdb-emulator\r\nset hostDirectory=%LOCALAPPDATA%\\azure-cosmosdb-emulator.hostd\r\nmd %hostDirectory% 2>nul\r\ndocker run --name %containerName% --memory 2GB --mount \"type=bind,source=%hostDirectory%,destination=C:\\CosmosDB.Emulator\\bind-mount\" -P --interactive --tty microsoft\/azure-cosmosdb-emulator<\/code><\/pre>\n
Once we’ve configured the Azure Cosmos DB account and database in the Azure portal or in Docker, we can continue to configure it in our Spring Boot application.<\/p>\n
4. Using Azure Cosmos DB in Spring<\/h2>\n
<\/div>\n
4.1. Configuring Spring Data Azure Cosmos DB with Spring<\/h3>\n
<\/div>\n
We start by adding the spring-data-cosmosdb<\/a> dependency in our pom.xml<\/em>:<\/p>\n
<dependency> \r\n    <groupId>com.microsoft.azure<\/groupId> \r\n    <artifactId>spring-data-cosmosdb<\/artifactId> \r\n    <version>2.3.0<\/version> \r\n<\/dependency>\r\n<\/code><\/pre>\n
To access Azure Cosmos DB from our Spring application we’ll need the URI of our database, it’s access keys<\/a> and database name.<\/strong> \u00a0Then we’all add the connection properties in our application.properties<\/em>:<\/p>\n
azure.cosmosdb.uri=cosmodb-uri\r\nazure.cosmosdb.key=cosmodb-primary-key\r\nazure.cosmosdb.secondaryKey=cosmodb-secondary-key\r\nazure.cosmosdb.database=cosmodb-name\r\n<\/code><\/pre>\n
We can find the values of the above properties from the Azure portal. The URI, primary key, and the secondary key will be available in the keys section of our Azure Cosmos DB in the Azure portal.<\/p>\n
To connect to Azure Cosmos DB from our application we need to create a client. For that, we need to extend AbstractCosmosConfiguration<\/em> class in our configuration class and add the @EnableCosmosRepositories\u00a0<\/em>annotation.<\/strong><\/p>\n
This annotation will scan for interfaces that extend Spring Data’s repository interfaces in the specified package.<\/p>\n
We also need to configure a bean of type CosmosDBConfig<\/em><\/strong>:<\/p>\n
@Configuration\r\n@EnableCosmosRepositories(basePackages = \"com.baeldung.spring.data.cosmosdb.repository\")\r\npublic class AzureCosmosDbConfiguration extends AbstractCosmosConfiguration {\r\n    @Value(\"${azure.cosmosdb.uri}\")\r\n    private String uri;\r\n    @Value(\"${azure.cosmosdb.key}\")\r\n    private String key;\r\n    @Value(\"${azure.cosmosdb.database}\")\r\n    private String dbName;\r\n    private CosmosKeyCredential cosmosKeyCredential;\r\n    @Bean\r\n    public CosmosDBConfig getConfig() {\r\n        this.cosmosKeyCredential = new CosmosKeyCredential(key);\r\n        CosmosDBConfig cosmosdbConfig = CosmosDBConfig.builder(uri, this.cosmosKeyCredential, dbName)\r\n            .build();\r\n        return cosmosdbConfig;\r\n    }\r\n}<\/code><\/pre>\n
4.2. Creating an Entity for Azure Cosmos DB<\/h3>\n
<\/div>\n
In order to interact with Azure Cosmos DB, we make use of entities. So, let’s create an entity that we will store in Azure Cosmos DB. To make our Product<\/em> class an entity, we’ll use the @Document<\/em> annotation:<\/strong><\/p>\n
@Document(collection = \"products\")\r\npublic class Product {\r\n    @Id\r\n    private String productid;\r\n    private String productName;\r\n    private double price;\r\n    @PartitionKey\r\n    private String productCategory;\r\n}<\/code><\/pre>\n
In this example, we’ve used the collection<\/em> attribute with the value products<\/em>, to indicate this will be the name of our container in the database<\/strong>. If we don’t provide any value for the collection<\/em> parameter, then the class name will be used as the container name in the database.<\/p>\n
We’ve also defined an id for our document. We can either create a field with the name id<\/em> in our class or we can annotate a field with the @Id <\/em>annotation.\u00a0Here we have used the productid<\/em> field as the document id.<\/p>\n
We can logically partition our data in our container by using a partition key by annotating a field with @PartitionKey. <\/em><\/strong>In our class, we’ve used the productCategory<\/em> field as the partition key.<\/p>\n
By default, the indexing policy is defined by Azure, but we can also customize it by using @DocumentIndexingPolicy\u00a0<\/em>annotation on our entity Class.<\/p>\n
We can also enable Optimistic locking for our entity container by creating a field named _etag<\/em> and annotating it with @Version.<\/em><\/p>\n
4.3. Defining the Repository<\/h3>\n
<\/div>\n
Now let’s create a ProductRepository<\/em> interface that extends CosmosRepository<\/em><\/strong>. Using this interface, we can perform CRUD operations on our Azure Cosmos DB:<\/p>\n
@Repository\r\npublic interface ProductRepository extends CosmosRepository<Product, String> {\r\n    List findByProductName(String productName);\r\n}<\/code><\/pre>\n
As we can see, this is defined in a similar way to other Spring Data modules.<\/p>\n
4.4. Testing the Connection<\/h3>\n
<\/div>\n
Now we can create a Junit Test to save a Product<\/em> entity in Azure Cosmos DB using our ProductRepository<\/em>:<\/p>\n
@SpringBootTest\r\npublic class AzureCosmosDbApplicationManualTest {\r\n    @Autowired\r\n    ProductRepository productRepository;\r\n    @Test\r\n    public void givenProductIsCreated_whenCallFindById_thenProductIsFound() {\r\n        Product product = new Product();\r\n        product.setProductid(\"1001\");\r\n        product.setProductCategory(\"Shirt\");\r\n        product.setPrice(110.0);\r\n        product.setProductName(\"Blue Shirt\");\r\n        productRepository.save(product);\r\n        Product retrievedProduct = productRepository.findById(\"1001\", new PartitionKey(\"Shirt\"))\r\n            .orElse(null);\r\n        Assert.notNull(retrievedProduct, \"Retrieved Product is Null\");\r\n    }\r\n}<\/code><\/pre>\n
By running this Junit test we can test our connection with Azure Cosmos DB from our Spring application.<\/p>\n
5. Conclusion<\/h2>\n
<\/div>\n
In this tutorial, we learned about Azure Cosmos DB. Further, we learned how to access Azure Cosmos DB from a Spring Boot application, how to create entities and configure a Repository by extending CosmosRepository<\/em> to interact with it.<\/p>\n
The code for the above example is available over on GitHub<\/a>.<\/p>\n
\"\"<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n\n
\\\"IT\u96fb\u8166\u88dc\u7fd2
\u7acb\u523b\u8a3b\u518a\u53ca\u5831\u540d\u96fb\u8166\u88dc\u7fd2\u8ab2\u7a0b\u5427!<\/figcaption><\/figure>\r\n<\/br>Find A Teacher Form:\r\n<\/br>https:\/\/docs.google.com\/forms\/d\/1vREBnX5n262umf4wU5U2pyTwvk9O-JrAgblA-wH9GFQ\/viewform?edit_requested=true#responses\r\n<\/br><\/br>Email:\r\n<\/br>public1989two@gmail.com






\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"
Learn how to interact with Azure Cosmos DB using Spring Data.<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n<\/div>","protected":false},"author":214,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Introduction to Spring Data Azure Cosmos DB - ITTeacherITFreelance.hk","description":"Learn how to interact with Azure Cosmos DB using Spring Data.                "},"footnotes":""},"categories":[6],"tags":[4793],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/59786"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/214"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=59786"}],"version-history":[{"count":1,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/59786\/revisions"}],"predecessor-version":[{"id":59787,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/59786\/revisions\/59787"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=59786"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=59786"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=59786"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}