

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.

# AWS AppSync Übersicht über Resolver-Mapping-Vorlagen
<a name="resolver-mapping-template-reference-overview"></a>

**Anmerkung**  
Wir unterstützen jetzt hauptsächlich die APPSYNC\_JS-Laufzeit und ihre Dokumentation. Bitte erwägen Sie, die APPSYNC\_JS-Laufzeit und ihre Anleitungen hier zu verwenden. [https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync ermöglicht es Ihnen, auf GraphQL-Anfragen zu antworten, indem Sie Operationen an Ihren Ressourcen ausführen. Für jedes GraphQL-Feld, für das Sie eine Abfrage oder Mutation ausführen möchten, muss ein Resolver angehängt werden, um mit einer Datenquelle kommunizieren zu können. Die Kommunikation erfolgt in der Regel über Parameter oder Operationen, die für die Datenquelle spezifisch sind.

Resolver sind die Konnektoren zwischen GraphQL und einer Datenquelle. Sie erklären, AWS AppSync wie Sie eine eingehende GraphQL-Anfrage in Anweisungen für Ihre Backend-Datenquelle übersetzen und wie Sie die Antwort von dieser Datenquelle zurück in eine GraphQL-Antwort übersetzen. Sie sind in der [ Apache Velocity Template Language (VTL) geschrieben](https://velocity.apache.org/engine/1.7/user-guide.html), die Ihre Anfrage als Eingabe verwendet und ein JSON-Dokument ausgibt, das die Anweisungen für den Resolver enthält. Sie können Mapping-Vorlagen für einfache Anweisungen verwenden, z. B. das Übergeben von Argumenten aus GraphQL-Feldern, oder für komplexere Anweisungen, z. B. das Durchlaufen von Argumenten, um ein Element zu erstellen, bevor Sie das Element in DynamoDB einfügen. 

Es gibt zwei Arten von Resolvern, die Mapping-Vorlagen auf AWS AppSync leicht unterschiedliche Weise nutzen:
+ Resolver für Einheiten
+ Resolver für Pipelines

## Resolver für Einheiten
<a name="unit-resolvers"></a>

Unit-Resolver sind eigenständige Entitäten, die nur eine Anfrage- und eine Antwortvorlage enthalten. Verwenden Sie diese für einfache, einzelne Operationen, wie das Auflisten von Elementen aus einer einzelnen Datenquelle.
+ Anforderungsvorlagen: Nehmen Sie die eingehende Anfrage, nachdem eine GraphQL-Operation analysiert wurde, und konvertieren Sie sie in eine Anforderungskonfiguration für den ausgewählten Datenquellenvorgang.
+ Antwortvorlagen: Interpretieren Sie die Antworten aus Ihrer Datenquelle und ordnen Sie sie der Form des GraphQL-Feld-Ausgabetyps zu.

## Pipeline-Resolver
<a name="pipeline-resolvers"></a>

Pipeline-Resolver enthalten eine oder mehrere * Funktionen*, die in sequentieller Reihenfolge ausgeführt werden. Jede Funktion umfasst eine Anforderungsvorlage und eine Antwortvorlage. Ein Pipeline-Resolver hat auch eine * * Vorher- und eine * * Nachvorlage, die die Abfolge der Funktionen umgeben, die die Vorlage enthält. Die * * After-Vorlage ist dem GraphQL-Feld-Ausgabetyp zugeordnet. Pipeline-Resolver unterscheiden sich von Unit-Resolvern in der Art und Weise, wie die Antwortvorlage die Ausgabe zuordnet. Ein Pipeline-Resolver kann jeder beliebigen Ausgabe zugeordnet werden, einschließlich der Eingabe für eine andere Funktion oder der * * After-Vorlage des Pipeline-Resolvers. 

 *Pipeline-Resolver-Funktionen * ermöglichen es Ihnen, allgemeine Logik zu schreiben, die Sie für mehrere Resolver in Ihrem Schema wiederverwenden können. Funktionen werden direkt an eine Datenquelle angehängt und enthalten wie ein Unit-Resolver dasselbe Vorlagenformat für die Zuordnung von Anfragen und Antworten.

Das folgende Diagramm zeigt den Prozessablauf eines Unit-Resolvers auf der linken Seite und eines Pipeline-Resolvers auf der rechten Seite.

![Ein Diagramm eines Unit-Resolvers, der mit einer einzelnen Datenquelle kommuniziert, und ein Diagramm eines Pipeline-Resolvers, der mit mehreren Datenquellen kommuniziert.](https://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/unit-pipeline-resolver.png)


Pipeline-Resolver enthalten einen Großteil der Funktionen, die Unit-Resolver unterstützen, und noch mehr, allerdings auf Kosten einer etwas höheren Komplexität.

### Aufbau eines Pipeline-Resolvers
<a name="anatomy-of-a-pipeline-resolver"></a>

Ein Pipeline-Resolver besteht aus einer Vorlage für das ** ** Before-Mapping, einer ** After ** Mapping-Vorlage und einer Liste von Funktionen. Jede Funktion hat eine Vorlage ** für die ** Zuordnung von Anforderungen ** und ** Antworten, die sie für eine Datenquelle ausführt. Da ein Pipeline-Resolver die Ausführung an eine Liste von Funktionen delegiert, ist er mit keiner Datenquelle verknüpft. Unit-Resolver und -Funktionen sind Primitive, die Operation auf Datenquellen auszuführen. Weitere Informationen finden Sie in der Übersicht über [ die ](#aws-appsync-resolver-mapping-template-reference-overview) Resolver-Mapping-Vorlage.

#### Vor dem Zuordnen der Vorlage
<a name="before-mapping-template"></a>

Mit der Vorlage für die Anforderungszuweisung eines Pipeline-Resolvers oder im ** ** Schritt „Before“ können Sie einige Vorbereitungslogik ausführen, bevor Sie die definierten Funktionen ausführen.

#### Funktionsliste
<a name="functions-list"></a>

Die Liste der Funktionen eines Pipeline-Resolvers wird nacheinander ausgeführt. Das von der Zuweisungsvorlage für Anforderungen des Pipeline-Resolvers ausgewertete Ergebnis wird der ersten Funktion als `$ctx.prev.result` zur Verfügung gestellt. Alle Funktionsausgaben werden der jeweils nächsten Funktion als `$ctx.prev.result` zur Verfügung gestellt.

#### Nachher-Zuweisungsvorlage
<a name="after-mapping-template"></a>

Die Response-Mapping-Vorlage eines Pipeline-Resolvers oder der ** Schritt „**Nach“ ermöglicht es Ihnen, die endgültige Mapping-Logik von der Ausgabe der letzten Funktion bis zum erwarteten GraphQL-Feldtyp auszuführen. Die Ausgabe der letzten Funktion in der Funktionsliste ist in der Zuweisungsvorlage des Pipeline-Resolvers als `$ctx.prev.result` oder `$ctx.result` verfügbar.

#### Ablauf der Ausführung
<a name="execution-flow"></a>

Bei einem Pipeline-Resolver, der aus zwei Funktionen besteht, stellt die folgende Liste den Ausführungsablauf dar, wenn der Resolver aufgerufen wird:

![Die GraphQL-Anfrage durchläuft die BEFORE-Vorlage, zwei Funktionen mit Anfrage- und Antwortvorlagen, die auf Datenquellen zugreifen, die AFTER-Template und dann die GraphQL-Antwort.](https://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/PipelineResolver.jpg)


1. Pipeline-Resolver Vor ** dem Zuordnen der Vorlage **

1. Funktion 1: Zuweisungsvorlage für Anforderungen der Funktion

1. Funktion 1: Aufruf der Datenquelle

1. Funktion 1: Zuweisungsvorlage für Antworten der Funktion

1. Funktion 2: Zuweisungsvorlage für Anforderungen der Funktion

1. Funktion 2: Aufruf der Datenquelle

1. Funktion 2: Zuweisungsvorlage für Antworten der Funktion

1. Pipeline-Resolver ** Nach dem Zuordnen der Vorlage **

**Anmerkung**  
Der Ausführungsablauf des Pipeline-Resolvers ist unidirektional und statisch im Resolver definiert.

#### Nützliche Dienstprogramme für die Apache Velocity Template Language (VTL)
<a name="useful-apache-velocity-template-language-vtl-utilities"></a>

Wenn die Komplexität einer Anwendung steigt, verbessern VTL-Dienstprogramme und -Richtlinien die Produktivität der Entwicklung. Die folgenden Dienstprogramme unterstützen die Arbeit mit Pipeline-Resolvern.

##### $ctx.stash
<a name="ctx-stash"></a>

Der Stash ist ein Stash`Map`, der in jedem Resolver und jeder Funktionszuordnungsvorlage zur Verfügung gestellt wird. Eine Stash-Instanz bleibt während einer einzigen Resolver-Instance bestehen. Daher können Sie den Stash nutzen, um beliebige Daten zwischen Zuweisungsvorlagen für Anforderungen und Antworten und Funktionen in einem Pipeline-Resolver zu übergeben. Der Stash bietet dieselben Methoden wie die [ Java-Map-Datenstruktur. ](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html)

##### $ctx.prev.result
<a name="ctx-prev-result"></a>

Das `$ctx.prev.result` stellt das Ergebnis der vorherigen Operation dar, die im Pipeline-Resolver ausgeführt wurde.

Wenn der vorherige Vorgang die Before-Mapping-Vorlage des Pipeline-Resolvers war, `$ctx.prev.result` stellt es die Ausgabe der Auswertung der Vorlage dar und wird der ersten Funktion in der Pipeline zur Verfügung gestellt. Wenn die vorherige Operation die erste Funktion betraf, steht `$ctx.prev.result` für die Ausgabe der ersten Funktion und wird der zweiten Funktion in der Pipeline zur Verfügung gestellt. Wenn die vorherige Operation die letzte Funktion war, stellt dies die Ausgabe der letzten Funktion `$ctx.prev.result` dar und wird der After-Mapping-Vorlage des Pipeline-Resolvers zur Verfügung gestellt.

##### \#return(data: Object)
<a name="return-data-object"></a>

Die Richtlinie `#return(data: Object)` ist hilfreich, wenn Sie vorzeitig aus einer beliebigen Zuweisungsvorlage zurückspringen müssen. `#return(data: Object)` entspricht in Programmiersprachen dem Schlüsselwort *return*, da es aus dem nächsten Logikblock-Scope zurückspringt. Wenn Sie daher in einer Resolver-Zuweisungsvorlage `#return` verwenden, erfolgt ein Rücksprung vom Resolver. Wenn `#return(data: Object)` in einer Resolver-Zuweisungsvorlage verwendet wird, wird für das GraphQL-Feld `data` festgelegt. Wenn Sie `#return(data: Object)` in einer Funktionszuweisungsvorlage verwenden, erfolgt ein Rücksprung aus der Funktion und es wird entweder die nächste Funktion in der Pipeline oder die Resolver-Zuweisungsvorlage für Antworten ausgeführt.

##### \#return
<a name="return"></a>

Dies ist dasselbe wie`#return(data: Object)`, `null` wird aber stattdessen zurückgegeben.

##### $util.error
<a name="util-error"></a>

Das Dienstprogramm `$util.error` ist nützlich, um ein Feldfehler auszulösen. Wenn Sie `$util.error` in einer Funktionszuweisungsvorlage verwenden, wird sofort ein Feldfehler ausgelöst, der verhindert, dass nachfolgende Funktionen ausgeführt werden. Weitere Informationen und andere `$util.error` Signaturen finden Sie in der Referenz [ zum Hilfsprogramm ](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference) Resolver Mapping Template.

##### $util.appendError
<a name="util-appenderror"></a>

`$util.appendError` lässt sich mit `$util.error()` vergleichen, mit dem großen Unterschied, dass die Auswertung der Zuweisungsvorlage nicht unterbrochen wird. Stattdessen wird signalisiert, dass das Feld zwar eine Fehlermeldung hervorrief, die Beurteilung der Vorlage jedoch abgeschlossen wurde und infolgedessen Daten zurückgegeben wurden. Die Verwendung von `$util.appendError` in einer Funktion hat keine Auswirkungen auf die Ausführung des Pipeline-Ablaufs. Weitere Informationen und andere `$util.error` Signaturen finden Sie in der Referenz zum Tool für [ Resolver-Mapping-Vorlagen. ](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference)

## -Beispielvorlage
<a name="example-template"></a>

Angenommen, Sie haben eine DynamoDB-Datenquelle und einen ** ** Unit-Resolver für ein Feld namens`getPost(id:ID!)`, das einen `Post` Typ mit der folgenden GraphQL-Abfrage zurückgibt:

```
getPost(id:1){
    id
    title
    content
}
```

Ihre Resolver-Vorlage sieht möglicherweise folgendermaßen aus:

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}
```

Hierdurch würde der Wert des `id`-Eingabeparameters von `1` durch `${ctx.args.id}` ersetzt und die folgende JSON-Vorlage generiert:

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "1" }
    }
}
```

AWS AppSync verwendet diese Vorlage, um Anweisungen für die Kommunikation mit DynamoDB und das Abrufen von Daten (oder gegebenenfalls für die Ausführung anderer Operationen) zu generieren. Nachdem die Daten zurückgegeben wurden, führt AWS AppSync sie durch eine optionale Antwortzuweisungsvorlage, über die Sie die Datengestaltung oder Logik vornehmen können. Wenn wir beispielsweise die Ergebnisse von DynamoDB zurückerhalten, könnten sie so aussehen:

```
{
        "id" : 1,
        "theTitle" : "AWS AppSync works offline!",
        "theContent-part1" : "It also has realtime functionality",
        "theContent-part2" : "using GraphQL"
}
```

Sie können auch mithilfe der folgenden Antwortzuweisungsvorlage zwei der Felder in einem einzelnen Feld zusammenlegen:

```
{
        "id" : $util.toJson($context.data.id),
        "title" : $util.toJson($context.data.theTitle),
        "content" : $util.toJson("${context.data.theContent-part1} ${context.data.theContent-part2}")
}
```

Hier sehen Sie, wie die Daten strukturiert sind, nachdem die Vorlage auf die Daten angewendet wurde:

```
{
        "id" : 1,
        "title" : "AWS AppSync works offline!",
        "content" : "It also has realtime functionality using GraphQL"
}
```

Die Daten werden als Antwort folgendermaßen an den Client zurückgegeben:

```
{
        "data": {
                "getPost":      {
                        "id" : 1,
                        "title" : "AWS AppSync works offline!",
                        "content" : "It also has realtime functionality using GraphQL"
                }
        }
}
```

Beachten Sie, dass in den meisten Situationen Antwort-Zuweisungsvorlagen einfach der Durchleitung von Daten dienen und der größte Unterschied darin besteht, ob ein einzelnes Element oder eine Liste von Elementen zurückgegeben wird. Für ein einzelnes Element lautet der Pass-Through:

```
$util.toJson($context.result)
```

Für Listen lautet der Pass-Through üblicherweise:

```
$util.toJson($context.result.items)
```

Weitere Beispiele für Unit- und Pipeline-Resolver finden Sie [ in den Resolver-Tutorials. ](tutorials.md#aws-appsync-tutorials)

## Die Regeln für die Deserialisierung von Mapping-Vorlagen wurden evaluiert
<a name="evaluated-mapping-template-deserialization-rules"></a>

Zuweisungsvorlagen werden zu einer Zeichenfolge ausgewertet. In muss AWS AppSync die Ausgabezeichenfolge einer JSON-Struktur folgen, um gültig zu sein.

Darüber hinaus werden die folgenden Deserialisierungsregeln erzwungen.

### Doppelte Schlüssel sind in JSON-Objekten nicht zulässig
<a name="duplicate-keys-are-not-allowed-in-json-objects"></a>

Wenn die ausgewertete Zuweisungsvorlagenzeichenfolge ein JSON-Objekt darstellt oder ein Objekt mit doppelten Schlüsseln enthält, gibt die Zuweisungsvorlage die folgende Fehlermeldung zurück:

 `Duplicate field 'aField' detected on Object. Duplicate JSON keys are not allowed.` 

Beispiel für einen doppelten Schlüssel in einer ausgewerteten Anforderungszuweisungsvorlage:

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
        "field": "getPost" ## key 'field' has been redefined
    }
}
```

Um diesen Fehler zu beheben, definieren Sie Schlüssel in JSON-Objekten nicht neu.

### Nachgestellte Zeichen sind in JSON-Objekten nicht zulässig
<a name="trailing-characters-are-not-allowed-in-json-objects"></a>

Wenn die ausgewertete Zuweisungsvorlagenzeichenfolge ein JSON-Objekt darstellt und nachgestellte Fremdzeichen enthält, gibt die Zuweisungsvorlage die folgende Fehlermeldung zurück:

 `Trailing characters at the end of the JSON string are not allowed.` 

Beispiel für nachgestellte Zeichen in einer ausgewerteten Anforderungszuweisungsvorlage:

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
    }
}extraneouschars
```

Um diesen Fehler zu beheben, stellen Sie sicher, dass die evaluierten Vorlagen ausschließlich nach JSON ausgewertet werden.