终止支持通知：2025年9月15日， AWS 我们将停止对Amazon Lex V1的支持。2025 年 9 月 15 日之后，您将无法再访问 Amazon Lex V1 控制台或 Amazon Lex V1 资源。如果您使用的是 Amazon Lex V2，请改为参阅 [Amazon Lex V2 指南](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 步骤 5 (可选)：查看信息流的详细信息 (控制台)
<a name="gs-bp-details-after-lambda"></a>

本节介绍每个用户输入的客户端与 Amazon Lex 之间的信息流，包括 Lambda 函数的集成。

**注意**  
本节假定客户端使用 `PostText` 运行时 API 向 Amazon Lex 发送请求，并显示相应的请求和响应详细信息。有关客户端和 Amazon Lex（客户端在其中使用 `PostContent` API）之间的信息流示例，请参阅[步骤 2a (可选)：查看语音信息流的详细信息 (控制台)](gs-bp-details-postcontent-flow.md)。

如需关于 `PostText` 运行时 API 的更多信息以及关于以下步骤中所示的请求和响应的更多详情，请参阅 [PostText](API_runtime_PostText.md)。

1. 用户：我想要订些花。

   1. 客户端 (控制台) 将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "I would like to order some flowers",
          "sessionAttributes": {}
      }
      ```

      请求 URI 和正文都将向 Amazon Lex 提供信息：
      + 请求 URI — 提供机器人名称 (`OrderFlowers`)、机器人别名 (`$LATEST`) 和用户名称（用于标识用户的随机字符串）。后面的 `text` 表示它是一个 `PostText` API 请求 (而不是 `PostContent`)。
      + 请求正文 – 包括用户输入 (`inputText`) 和空 `sessionAttributes`。在客户端发出第一个请求时，没有会话属性。稍后，Lambda 函数会启动这些属性。

   1. 在 `inputText` 中，Amazon Lex 可检测意图 (`OrderFlowers`)。此意图配置有 Lambda 函数作为代码挂钩，以用于用户数据初始化和验证。因此，Amazon Lex 将通过传递以下信息作为事件数据来调用该 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {},
          "bot": {
              "name": "OrderFlowers",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": null,
                  "PickupDate": null
              },
              "confirmationStatus": "None"
          }
      }
      ```

      有关更多信息，请参阅 [输入事件格式](lambda-input-response-format.md#using-lambda-input-event-format)。

      除了客户端发送的信息以外，Amazon Lex 还包含以下额外数据：
      + `messageVersion` — Amazon Lex 当前只支持 1.0 版。
      + `invocationSource` — 表明 Lambda 函数调用的目的。在本例中，它将执行用户数据初始化和验证。此时，Amazon Lex 知道用户没有提供所有插槽数据以履行意图。
      + 将所有槽值设置为空值的 `currentIntent` 信息。

   1. 此时，所有槽值均为空值。Lambda 函数没有任何内容需要验证。Lambda 函数会向 Amazon Lex 返回以下响应：

      ```
      {
          "sessionAttributes": {},
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": null,
                  "PickupDate": null
              }
          }
      }
      ```

      有关响应格式的信息，请参阅 [响应格式](lambda-input-response-format.md#using-lambda-response-format)。

      注意以下几点：
      + `dialogAction.type` — 通过将此值设置为 `Delegate`，Lambda 函数会将决定下一个操作的责任委派给 Amazon Lex。
**注意**  
如果 Lambda 函数在用户数据验证中检测到任何内容，它会指示 Amazon Lex 下一步操作，如接下来的几个步骤所示。

   1. 根据 `dialogAction.type`，Amazon Lex 将决定下一步操作。由于没有一个槽得到填充，它将决定引出 `FlowerType` 槽的值。它将选择此槽的其中一个值引出提示（“您想要订哪种类型的花？”），并将以下响应发送回客户端：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-10.png)

      客户端将显示响应中的消息。

1. 用户：玫瑰

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "roses",
          "sessionAttributes": {}
      }
      ```

      在请求正文中，`inputText` 将提供用户输入。`sessionAttributes` 将保留为空。

   1. Amazon Lex 解读当前意图的上下文中的 `inputText`。服务会记住它已经向特定用户询问了关于 `FlowerType` 槽的信息。它将更新当前意图中的插槽值，并调用具有以下事件数据的 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {},
          "bot": {
              "name": "OrderFlowers",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": null
              },
              "confirmationStatus": "None"
          }
      }
      ```

      注意以下几点：
      + `invocationSource` – 继续为 `DialogCodeHook` (我们只验证用户数据)。
      + `currentIntent.slots` — Amazon Lex 已将 `FlowerType` 插槽更新为“玫瑰”。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数会执行用户数据验证。它会将 `roses` 识别为有效的插槽值（并将 `Price` 设置为会话属性），然后向 Amazon Lex 返回以下响应。

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": null
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` — Lambda 函数已经将（玫瑰的）`Price` 添加为会话属性。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

       

   1. 根据 `dialogAction.type`，Amazon Lex 选择下一步操作。Amazon Lex 知道它需要更多插槽数据，因此它将根据意图配置选择下一个具有最高优先级的未填充插槽 (`PickupDate`)。Amazon Lex 会根据意图配置，针对这个插槽选择一个值引发提示消息（“您想要在哪天收到玫瑰？”），然后向客户端发送回以下响应：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-20.png)

      客户端在响应中显示消息 –“What day do you want the roses to be picked up?”。

1. 用户：明天

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "tomorrow",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

      在请求正文中，`inputText` 将提供用户输入，然后客户端会将会话属性传递回服务。

   1. Amazon Lex 会记住上下文（它正引发 `PickupDate` 插槽的数据）。在这个上下文中，它知道 `inputText` 值用于 `PickupDate` 槽。然后，Amazon Lex 将通过发送以下事件调用 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "None"
          }
      }
      ```

      Amazon Lex 已经通过设置 `PickupDate` 值更新了 `currentIntent.slots`。另请注意，该服务会将 `sessionAttributes` 传递到 Lambda 函数。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数将执行用户数据验证。它会将 `PickupDate` 插槽值识别为有效值，并向 Amazon Lex 返回以下响应：

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": null,
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` – 无更改。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

   1. 根据 `dialogAction.type`，Amazon Lex 选择下一步操作。Amazon Lex 知道它需要更多插槽数据，因此它将根据意图配置选择下一个具有最高优先级的未填充插槽 (`PickupTime`)。Amazon Lex 会根据意图配置，针对这个插槽选择一项提示消息（“在 2017 年 1 月 5 日的什么时间配送玫瑰？”），并将以下响应发送回客户端：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-30.png)

      客户端会显示响应中的消息（“在 2017 年 1 月 5 日的什么时间配送玫瑰？”）

1. 用户：下午 4 点

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "4 pm",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

      在请求正文中，`inputText` 将提供用户输入。客户端将在请求中传递 `sessionAttributes`。

   1. Amazon Lex 了解上下文。它了解它正在引出 `PickupTime` 槽的数据。在此上下文中，它知道 `inputText` 值用于 `PickupTime` 插槽。然后，Amazon Lex 将通过发送以下事件调用 Lambda 函数：

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "DialogCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "None"
          }
      }
      ```

      Amazon Lex 已经通过设置 `PickupTime` 值更新了 `currentIntent.slots`。

   1. 根据 `DialogCodeHook` 的 `invocationSource` 值，Lambda 函数会执行用户数据验证。它会将 `PickupDate` 插槽值识别为有效值，并向 Amazon Lex 返回以下响应。

      ```
      {
          "sessionAttributes": {
              "Price": 25
          },
          "dialogAction": {
              "type": "Delegate",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `sessionAttributes` – 会话属性无更改。
      + `dialogAction.type` – 设置为 `Delegate`。用户数据是有效的，因此 Lambda 函数会指示 Amazon Lex 选择下一步操作。

   1. 此时，Amazon Lex 知道它具有所有插槽数据。此目的配置有确认提示。因此，在履行意图之前，Amazon Lex 将向用户发送以下响应来请求确认：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-45.png)

      客户端只显示响应中的消息并等待用户响应。

1. 用户：是

   1. 客户端将向 Amazon Lex 发送以下 [PostText](API_runtime_PostText.md) 请求：

      ```
      POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
          "inputText": "yes",
          "sessionAttributes": {
              "Price": "25"
          }
      }
      ```

   1. Amazon Lex 将解释确认当前意图的上下文中的 `inputText`。Amazon Lex 了解用户希望继续完成订单。此时，Amazon Lex 将通过发送以下事件来调用 Lambda 函数以履行意图，这会在它发送给 Lambda 函数的事件中将 `invocationSource` 设置为 `FulfillmentCodeHook`。Amazon Lex 也将 `confirmationStatus` 设置为 `Confirmed`。

      ```
      {
          "messageVersion": "1.0",
          "invocationSource": "FulfillmentCodeHook",
          "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
          "sessionAttributes": {
              "Price": "25"
          },
          "bot": {
              "name": "OrderFlowersCustomWithRespCard",
              "alias": null,
              "version": "$LATEST"
          },
          "outputDialogMode": "Text",
          "currentIntent": {
              "name": "OrderFlowers",
              "slots": {
                  "PickupTime": "16:00",
                  "FlowerType": "roses",
                  "PickupDate": "2017-01-05"
              },
              "confirmationStatus": "Confirmed"
          }
      }
      ```

      注意以下几点：
      + `invocationSource` — 此时，Amazon Lex 将此值设置为 `FulfillmentCodeHook`，指示 Lambda 函数履行意图。
      + `confirmationStatus` – 设置为 `Confirmed`。

   1. 此时，Lambda 函数履行 `OrderFlowers` 意图，并返回以下响应：

      ```
      {
          "sessionAttributes": {
              "Price": "25"
          },
          "dialogAction": {
              "type": "Close",
              "fulfillmentState": "Fulfilled",
              "message": {
                  "contentType": "PlainText",
                  "content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
              }
          }
      }
      ```

      注意以下几点：
      + `dialogAction.type` – Lambda 函数将该值设置为 `Close`，指示 Amazon Lex 不要期待用户响应。
      + `dialogAction.fulfillmentState` – 设置为“已完成”，并且包含要传达给用户的适当 `message`。

   1. Amazon Lex 将查看 `fulfillmentState`，并将以下响应发送回客户端。

      然后，Amazon Lex 将向客户端返回以下信息：  
![\[\]](http://docs.aws.amazon.com/zh_cn/lex/latest/dg/images/gs-1-details-48.png)

      请注意：
      + `dialogState` — Amazon Lex 将此值设置为 `fulfilled`。
      + `message` — 与 Lambda 函数提供的消息相同。

      客户端将显示消息。

1. 现在，再次测试自动程序。要建立新的 (用户) 上下文，请选择测试窗口中的 **Clear** 链接。现在提供 `OrderFlowers` 目的的无效槽数据。此时，Lambda 函数将执行数据验证，将无效的插槽数据值重置为空值，并要求 Amazon Lex 提示用户提供有效数据。例如，请尝试以下操作：
   + “茉莉花”作为鲜花类型 (它不是一种受支持的鲜花类型)。
   + “昨天”作为您想要取花的日期。
   + 下单后，输入另一种鲜花类型，而不是回复“yes”来确认订单。作为响应，Lambda 函数将更新会话属性中的 `Price`，以维护鲜花订单的滚动合计。

   Lambda 函数还将执行履行活动。

**下一个步骤**  
[步骤 6：更新目的配置以添加表达 (控制台)](gs-bp-utterance.md)