DynamoDB in a Spring Boot Application Using Spring Data – 在Spring Boot应用中使用Spring Data的DynamoDB

最后修改: 2016年 10月 31日

1. Overview


In this article, we’ll explore the basics of integrating DynamoDB into a Spring Boot Application with a hands-on, practical example project.

在本文中,我们将通过一个实践性强的实例项目来探讨将DynamoDB集成到Spring Boot应用中的基本知识

We’ll demonstrate how to configure an application to use a local DynamoDB instance using Spring Data. We’ll also create an example data model and repository class as well as perform actual database operations using an integration test.

我们将演示如何使用Spring Data配置一个应用程序来使用本地DynamoDB实例。我们还将创建一个数据模型和存储库类的例子,并使用集成测试执行实际的数据库操作。

2. DynamoDB


DynamoDB is a fully-managed hosted NoSQL database on AWS, similar to other NoSQL databases such as Cassandra or MongoDB. DynamoDB offers fast, consistent and predictable performance and is massively scalable.


You can learn more about DynamoDB on the AWS Documentation.

您可以在AWS 文档上了解有关DynamoDB的更多信息。

Let’s install a local instance of DynamoDB to avoid incurring the cost of running a live instance.


For development, running DynamoDB locally makes more sense than running on AWS; the local instance will be run as an executable JAR file.


You can find instructions on how to run DynamoDB locally here.


3. Maven Dependencies


Add the following dependencies to start working with DynamoDB using Spring Data:

添加以下依赖项,以开始使用Spring Data的DynamoDB工作。


Check out Spring Data Release TrainAWS Java SDK For Amazon DynamoDB, and Spring Data DynamoDB for the latest versions of the above.

查看Spring Data Release Train, AWS Java SDK For Amazon DynamoDB,以及Spring Data DynamoDB的上述最新版本。

4. Configuration


Next, let’s define the following properties in the application.properties file:



The access and secret keys listed above are just arbitrary values for your local config. When accessing a local instance of DynamoDB these fields need to be populated by some values but are not needed to actually authenticate.


The properties will be dynamically pulled out of the application.properties file in the Spring config:

The properties will be dynamically pulled out of the application.properties file in the Spring config:

  (basePackages = "com.baeldung.spring.data.dynamodb.repositories")
public class DynamoDBConfig {

    private String amazonDynamoDBEndpoint;

    private String amazonAWSAccessKey;

    private String amazonAWSSecretKey;

    public AmazonDynamoDB amazonDynamoDB() {
        AmazonDynamoDB amazonDynamoDB 
          = new AmazonDynamoDBClient(amazonAWSCredentials());
        if (!StringUtils.isEmpty(amazonDynamoDBEndpoint)) {
        return amazonDynamoDB;

    public AWSCredentials amazonAWSCredentials() {
        return new BasicAWSCredentials(
          amazonAWSAccessKey, amazonAWSSecretKey);

5. The Data Model


Let’s now create a POJO model to represent the data stored in DynamoDB.


This POJO will use annotations similar to those used in Hibernate to define the table name, attributes, keys and other aspects of the table.


5.1. Data Model Attributes


The following class, ProductInfo, represents a table with items that contains 3 attributes:


  1. ID
  2. MSRP
  3. Cost

5.2. Java Data Model Class


Let’s create a file called ProductInfo.java in your data model folder:


@DynamoDBTable(tableName = "ProductInfo")
public class ProductInfo {
    private String id;
    private String msrp;
    private String cost;

    public String getId() {
        return id;

    public String getMsrp() {
        return msrp;

    public String getCost() {
        return cost;

    // standard setters/constructors

6. CRUD Repository


Next, we need to create a ProductRepository interface to define the CRUD functionality we want to build out. Repositories used to read and persist data to and from DynamoDB will implement this interface:


public interface ProductInfoRepository extends 
  CrudRepository<ProductInfo, String> {
    Optional<ProductInfo> findById(String id);

7. Integration Test


Next, let’s create an integration test to ensure we can successfully connect to the local instance of DynamoDB:


@SpringBootTest(classes = Application.class)
@TestPropertySource(properties = { 
  "amazon.aws.secretkey=test231" })
public class ProductInfoRepositoryIntegrationTest {

    private DynamoDBMapper dynamoDBMapper;

    private AmazonDynamoDB amazonDynamoDB;

    ProductInfoRepository repository;

    private static final String EXPECTED_COST = "20";
    private static final String EXPECTED_PRICE = "50";

    public void setup() throws Exception {
        dynamoDBMapper = new DynamoDBMapper(amazonDynamoDB);
        CreateTableRequest tableRequest = dynamoDBMapper
          new ProvisionedThroughput(1L, 1L));


    public void givenItemWithExpectedCost_whenRunFindAll_thenItemIsFound() { 
        ProductInfo productInfo = new ProductInfo(EXPECTED_COST, EXPECTED_PRICE);
        List<ProductInfo> result = (List<ProductInfo>) repository.findAll();

        assertThat(result.size(), is(greaterThan(0)));
        assertThat(result.get(0).getCost(), is(equalTo(EXPECTED_COST))); 

8. Conclusion


And we’re done – we can now connect to DynamoDB from a Spring Boot Application.

我们已经完成了 – 我们现在可以从Spring Boot应用程序连接到DynamoDB

Of course, after completing testing locally, we should be able to transparently use a live instance of DynamoDB on AWS and run the deployed code with only minor configuration changes.


As always, the example used in this article is available as a sample project over on GitHub.