从 JSON 创建 dynamodb 表

Question

我正在尝试通过包含我的表结构的 JSON 文件在我的代码中创建一个发电机表。 现在我正在使用以下代码创建表：

amazonClient.createTable(
        CreateTableRequest()
            .withTableName(tableName)
            .withKeySchema(KeySchemaElement("id", KeyType.HASH))
            .withAttributeDefinitions(...)
            .withProvisionedThroughput(...)
            .withGlobalSecondaryIndexes(...))

是否可以通过 JSON 创建它？

Answer 1

我也试图实现类似的东西，但我没有找到任何用于这个目的的库，因此我花了几分钟自己编写代码。

提供了一个 json 文件，其结构与文档示例中的结构相同：

{
    TableName : "Music",
    KeySchema: [
        {
            AttributeName: "Artist",
            KeyType: "HASH", 
        },
        {
            AttributeName: "SongTitle",
            KeyType: "RANGE" 
        }
    ],
    AttributeDefinitions: [
        {
            AttributeName: "Artist",
            AttributeType: "S"
        },
        {
            AttributeName: "SongTitle",
            AttributeType: "S"
        }
    ],
    ProvisionedThroughput: {       
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1
    }
} 

下面的代码有效。 注意：

• createTable 方法需要一个 json 字符串，您可以使用类似Files.readString(Path.of("path/to/your/file.json"))
• 如果您不使用Lombok ，则必须自己创建构造函数/getter/setter
• 仅当类字段名称与 json 字段名称不完全匹配时才需要@JsonProperty注释（在这种情况下，第一个字母为大写），解释here 。

---

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.model.*;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@RequiredArgsConstructor
    public class CreateTable {
        private final AmazonDynamoDB amazonDynamoDB;
    
        public void createTable(String json) throws JsonProcessingException {
            Table table = readTable(json);
            amazonDynamoDB.createTable(getTableRequest(table));
        }
    
        private CreateTableRequest getTableRequest(Table table) {
            return new CreateTableRequest()
                    .withTableName(table.getTableName())
                    .withKeySchema(toKeySchemaElement(table.getKeySchema()))
                    .withAttributeDefinitions(toAttributeDefinition(table.getAttributeDefinitions()))
                    .withProvisionedThroughput(toProvisionedThroughput(table.getProvisionedThroughput()));
        }
    
        private Table readTable(String json) throws JsonProcessingException {
            return new ObjectMapper().readValue(json, Table.class);
        }
    
        private ProvisionedThroughput toProvisionedThroughput(ProvisionedTp provisionedTp) {
            log.info("creating provisioned throughput read: {} write: {}", provisionedTp.getReadCapacityUnits(), provisionedTp.getWriteCapacityUnits());
            return new ProvisionedThroughput(provisionedTp.getReadCapacityUnits(), provisionedTp.getWriteCapacityUnits());
        }
    
        private Collection<AttributeDefinition> toAttributeDefinition(Collection<AttributeDef> attributeDefs) {
            return attributeDefs.stream().map(this::toAttributeDefinition).collect(Collectors.toList());
        }
        
        private AttributeDefinition toAttributeDefinition(AttributeDef attributeDef) {
            log.info("creating new attribute definition {}: {}", attributeDef.getAttributeName(), attributeDef.getAttributeType());
            return new AttributeDefinition().withAttributeName(attributeDef.getAttributeName()).withAttributeType(attributeDef.getAttributeType());
        }
    
        private Collection<KeySchemaElement> toKeySchemaElement(Collection<KeySchema> keySchemas) {
            return keySchemas.stream().map(this::toKeySchemaElement).collect(Collectors.toList());
        }
    
        private KeySchemaElement toKeySchemaElement(KeySchema keySchema) {
            log.info("creating new key schema element {}: {}", keySchema.getAttributeName(), keySchema.getKeyType());
            return new KeySchemaElement().withAttributeName(keySchema.getAttributeName()).withKeyType(keySchema.getKeyType());
        }
    
        @Data
        @NoArgsConstructor
        public static class Table {
            @JsonProperty("TableName")
            private String tableName;
            @JsonProperty("KeySchema")
            private List<KeySchema> keySchema;
            @JsonProperty("AttributeDefinitions")
            private List<AttributeDef> attributeDefinitions;
            @JsonProperty("ProvisionedThroughput")
            private ProvisionedTp provisionedThroughput;
        }
    
        @Data
        @NoArgsConstructor
        public static class KeySchema {
            @JsonProperty("AttributeName")
            private String attributeName;
            @JsonProperty("KeyType")
            private String keyType;
        }
    
        @Data
        @NoArgsConstructor
        public static class AttributeDef {
            @JsonProperty("AttributeName")
            private String attributeName;
            @JsonProperty("AttributeType")
            private String attributeType;
        }
    
        @Data
        @NoArgsConstructor
        public static class ProvisionedTp {
            @JsonProperty("ReadCapacityUnits")
            private long readCapacityUnits;
            @JsonProperty("WriteCapacityUnits")
            private long writeCapacityUnits;
        }
    
    }
    

  

Answer 2

我现在已经回答了这个问题，但是您可以使用提供的 class CreateTableRequest和 object 映射器，例如 Gson。

import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.google.gson.FieldNamingPolicy;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class InitTables {

    private AmazonDynamoDB dynamoDB;

    private static String musicTable = "{\n" +
        "  \"TableName\" : \"Music\",\n" +
        "  \"KeySchema\": [\n" +
        "    {\n" +
        "      \"AttributeName\": \"Artist\",\n" +
        "      \"KeyType\": \"HASH\"\n" +
        "    },\n" +
        "    {\n" +
        "      \"AttributeName\": \"SongTitle\",\n" +
        "      \"KeyType\": \"RANGE\"\n" +
        "    }\n" +
        "  ],\n" +
        "  \"AttributeDefinitions\": [\n" +
        "    {\n" +
        "      \"AttributeName\": \"Artist\",\n" +
        "      \"AttributeType\": \"S\"\n" +
        "    },\n" +
        "    {\n" +
        "      \"AttributeName\": \"SongTitle\",\n" +
        "      \"AttributeType\": \"S\"\n" +
        "    }\n" +
        "  ],\n" +
        "  \"ProvisionedThroughput\": {\n" +
        "    \"ReadCapacityUnits\": 1,\n" +
        "    \"WriteCapacityUnits\": 1\n" +
        "  }\n" +
        "}";


    public InitTables(AmazonDynamoDB dynamoDB) {
        this.dynamoDB = dynamoDB;
        init();
    }

    public void init() {
        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
                .create();
        CreateTableRequest createTableRequest = gson.fromJson(musicTable, CreateTableRequest.class);
        dynamoDB.createTable(createTableRequest);
    }
}