Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Generieren Sie `TableSchema` aus einer Datenklasse eine
<a name="ddb-en-client-gs-tableschema"></a>

A `[TableSchema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/TableSchema.html)` ermöglicht es dem erweiterten Client, DynamoDB-Attributwerte Ihren clientseitigen Klassen zuzuordnen. In diesem Tutorial erfahren Sie mehr über `TableSchema` s, die von einer statischen Datenklasse abgeleitet und mithilfe eines Builders aus Code generiert wurden.

## Verwenden Sie eine Datenklasse mit Anmerkungen
<a name="ddb-en-client-gs-tableschema-anno-bean"></a>

Das SDK for Java 2.x enthält eine [Reihe von Anmerkungen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html), die Sie mit einer Datenklasse verwenden können, um schnell eine `TableSchema` für die Zuordnung Ihrer Klassen zu Tabellen zu generieren.

[Erstellen Sie zunächst eine Datenklasse, die der Spezifikation entspricht. JavaBean ](https://download.oracle.com/otn-pub/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/beans.101.pdf) Die Spezifikation erfordert, dass eine Klasse einen öffentlichen Konstruktor ohne Argumente und Getter und Setter für jedes Attribut in der Klasse hat. Fügen Sie eine Anmerkung auf Klassenebene hinzu, um anzugeben, dass es sich bei der Datenklasse um eine handelt. `DynamoDbBean` Fügen Sie außerdem mindestens eine `DynamoDbPartitionKey` Anmerkung zum Getter- oder Setter-Wert für das Primärschlüsselattribut hinzu. 

Sie können [Anmerkungen auf Attributebene auf](ddb-en-client-anno-index.md) Getter oder Setter anwenden, aber nicht auf beide.

**Anmerkung**  
Der Begriff `property` wird normalerweise für einen Wert verwendet, der in a gekapselt ist. JavaBean In diesem Handbuch wird der Begriff jedoch `attribute` stattdessen verwendet, um mit der von DynamoDB verwendeten Terminologie konsistent zu sein.

Die folgende `Customer` Klasse zeigt Anmerkungen, die die Klassendefinition mit einer DynamoDB-Tabelle verknüpfen.

### `Customer`-Klasse
<a name="ddb-en-client-gs-tableschema-anno-bean-cust"></a>

```
package org.example.tests.model;

import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey;

import java.time.Instant;

@DynamoDbBean
public class Customer {

    private String id;
    private String name;
    private String email;
    private Instant regDate;

    @DynamoDbPartitionKey
    public String getId() { return this.id; }

    public void setId(String id) { this.id = id; }

    public String getCustName() { return this.name; }

    public void setCustName(String name) { this.name = name; }

    @DynamoDbSortKey
    public String getEmail() { return this.email; }

    public void setEmail(String email) { this.email = email; }

    public Instant getRegistrationDate() { return this.regDate; }

    public void setRegistrationDate(Instant registrationDate) { this.regDate = registrationDate; }

    @Override
    public String toString() {
        return "Customer [id=" + id + ", name=" + name + ", email=" + email
                + ", regDate=" + regDate + "]";
    }
}
```

Nachdem Sie eine annotierte Datenklasse erstellt haben, verwenden Sie sie, um die zu erstellen`TableSchema`, wie im folgenden Codeausschnitt gezeigt.

```
static final TableSchema<Customer> customerTableSchema = TableSchema.fromBean(Customer.class);
```

A `TableSchema` ist so konzipiert, dass es statisch und unveränderlich ist. Sie können es normalerweise beim Laden der Klasse instanziieren.

Die statische `TableSchema.fromBean()` Factory-Methode untersucht die Bean, um die Zuordnung von Datenklassenattributen (Eigenschaften) zu und von DynamoDB-Attributen zu generieren.

Ein Beispiel für die Arbeit mit einem Datenmodell, das aus mehreren Datenklassen besteht, finden Sie in der `Person` Klasse im Abschnitt. [Arbeiten Sie mit Attributen wie Beans, Maps, Listen und Sets](ddb-en-client-adv-features-nested.md)

## Verwenden Sie einen Builder
<a name="ddb-en-client-gs-tableschema-builder"></a>

Sie können die Kosten für die Bean-Introspektion überspringen, wenn Sie das Tabellenschema im Code definieren. Wenn Sie das Schema codieren, muss Ihre Klasse weder den JavaBean Benennungsstandards entsprechen noch muss sie mit Anmerkungen versehen werden. Das folgende Beispiel verwendet einen Builder und entspricht dem `Customer` Klassenbeispiel, das Anmerkungen verwendet.

```
static final TableSchema<Customer> customerTableSchema =
                TableSchema.builder(Customer.class)
                        .newItemSupplier(Customer::new)
                        .addAttribute(String.class, a -> a.name("id")
                                .getter(Customer::getId)
                                .setter(Customer::setId)
                                .tags(StaticAttributeTags.primaryPartitionKey()))
                        .addAttribute(String.class, a -> a.name("email")
                                .getter(Customer::getEmail)
                                .setter(Customer::setEmail)
                                .tags(StaticAttributeTags.primarySortKey()))
                        .addAttribute(String.class, a -> a.name("name")
                                .getter(Customer::getCustName)
                                .setter(Customer::setCustName))
                        .addAttribute(Instant.class, a -> a.name("registrationDate")
                                .getter(Customer::getRegistrationDate)
                                .setter(Customer::setRegistrationDate))
                        .build();
```