流配置参考文档

本页面适用于 Apigee 和 Apigee Hybrid。

查看 Apigee Edge 文档。

本部分提供有关用于定义 API 代理流的 XML 元素的参考信息。

更多信息

• 使用流控制代理执行
• API 代理配置参考文档

层次结构和语法

以下示例展示了流配置元素的元素层次结构和语法：

元素层次结构

以下示例展示了 <ProxyEndpoint> 和 <TargetEndpoint> 元素中的流配置元素的层次结构：

<ProxyEndpoint | TargetEndpoint>
    <PreFlow>
          <Request>
                <Step>
                    <Condition>
                    <Name>
          <Response>
                <Step>
                    <Condition>
                    <Name>
          <Description>
    <Flows>
          <Flow>
                <Description>
                <Condition>
                <Request>
                      <Step>
                          
                <Response>
                      <Step>
                          
          <Description>
    <PostFlow>
          <Request>
                <Step>
                    
          <Response>
                <Step>
                    
          <Description>
    <PostClientFlow> (<ProxyEndpoint> only)
          <Response>
                
          <Description>

      // Additional configuration elements

</ProxyEndpoint | TargetEndpoint>

语法

以下示例展示了流配置元素的语法。以下各部分详细介绍了各个元素：

<!-- ProxyEndpoint flow configuration file -->
<ProxyEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  <PostClientFlow name="flow_name">
    <Description>flow_description</Description>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

<!-- TargetEndpoint flow configuration file -->
<TargetEndpoint ... >
  ...
  <PreFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PreFlow>
  <Flows name="flow_name">
    <Flow name="conditional_flow_name">
      <Description>flow_description</Description>
      <Condition>property operator "value"</Condition>
      <Request>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Request>
      <Response>
        <Step>
          <Condition>property operator "value"</Condition>
          <Name>policy_name</Name>
        </Step>
        ...
      </Response>
    </Flow>
    ...
  </Flows>
  <PostFlow name="flow_name">
    <Description>flow_description</Description>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </PostFlow>
  ...
</TargetEndpoint>

您可以使用这些元素来定义 PreFlow、Conditional Flow、PostFlow 和 PostClientFlow 执行。

其他配置元素

本部分不会介绍代理配置中使用的以下元素：

• <APIProxy>
• <DefaultFaultRule>
• <FaultRules>
• <HTTPProxyConnection>
• <ProxyEndpoint>
• <RouteRule>
• <TargetEndpoint>

API 代理配置参考 中讨论了定义 代理 配置的元素而不是流。

<Condition>

定义在运行时处理的语句。如果语句的计算结果为 true，则系统会执行与条件关联的步骤或流程。如果语句的计算结果为 false，则系统会忽略步骤或流程。

Type	字符串
父 元素	<Flow> <Step>
子 元素	无

您可以将条件应用于特定步骤或整个流，具体取决于您是将元素放在 <Flow> 还是 <Step> 中元素：

// Condition can apply to just one step:        // Or to the flow:
<Flows>                                         <Flows>
  <Flow>                                          <Flow>
    <Step>                                          <Condition>
      <Condition>                                   <Step>
      <Name>                                          <Name>
      ...                                             ...
    ...                                             ...
  ...                                             ...
</Flows>                                        </Flows>

如果 <Step> 中的条件计算结果为 true，则 Apigee 会执行该步骤。如果条件计算结果为 false，则 Apigee 会跳过此步骤。

如果 <Flow> 中的条件计算结果为 true，则 Apigee 会处理流程中的所有步骤。如果条件计算结果为 false，则 Apigee 会跳过整个流程。

语法

<Condition> 元素使用以下语法：

<Condition>property operator "value"</Condition>

其中：

property

要在条件中使用的流变量属性。例如，request 流变量具有名为 path 和 content 的属性。要在条件中使用它们，您需要指定 flow_variable[dot]property_name：

request.path
request.content

如需查看流变量及其属性的完整列表，请参阅 流变量参考。

operator

一种定义您条件的评估方式。常见运算符包括：

>     greater than           <=    less than or equal to
<     less than              >=    greater than or equal to
=     equals                 &&    and
!=    not equals             ||    or

~~    JavaRegex
~     Matches
/~    MatchesPath

如需完整列表，请参阅条件参考文档中的 运算符。

“value”

流变量属性的值用于评估的值。这通常是基本类型，例如整数或字符串。例如 200 或 /cat。该值可以包含通配符，例如星号和其他用于模式匹配的字符，如 使用条件模式匹配 中所述。

示例 1

以下示例检查 request 流变量的 verb 属性是否为 GET：

<!-- api-platform/reference/examples/flow-segments/condition-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  ...
</ProxyEndpoint>

如果请求是 GET，则此示例执行 Log-Request-OK 政策。

示例 2

以下示例检查响应代码：

<!-- api-platform/reference/examples/flow-segments/condition-2.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

根据代码的值，系统会执行不同的政策。

属性

<Condition> 元素没有属性。

子元素

<Condition> 元素没有子元素。

<Description>

描述直观易懂的流。使用此元素向自己或其他开发者提供流程相关信息。此说明不会在外部显示。

Type	字符串
父 元素	<Flow> <PreFlow> <PostFlow>
子 元素	无

语法

<Description> 元素使用以下语法：

<Description>flow_description</Description>

示例

以下示例展示了 <Description> 元素，用于指定流的目的：

<!-- api-platform/reference/examples/flow-segments/description-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

属性

<Description> 元素没有属性。

子元素

<Description> 元素没有子元素。

<Flow>

定义 Apigee 执行的一组自定义步骤。

类型	复杂对象
父 元素	<Flows>
子 元素	<Condition> <Description> <Request> <Response>

您可以选择在 <Flow> 上指定 <Condition>。在这种情况下，Apigee 仅在条件计算为 true 时执行流程中的步骤。否则，Apigee 会跳过整个流程。

<Flows> 元素可以包含多个 <Flow> 元素，每个元素都有自己的条件和步骤。当有多个 <Flow> 元素时，Apigee 只会执行第一个没有条件或条件计算为 true 的元素。

您可以定义始终执行的默认流程（如果没有其他条件流执行）。您可以根据 API 代理的配置方式，这在 防范恶意攻击 中是一有用的工具。

语法

<Flow> 元素使用以下语法：

<Flow name="conditional_flow_name">
  <Description>flow_description</Description>
  <Condition>property operator "value"</Condition>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</Flow>

<Flow> 的所有子元素都是可选的。

示例 1

以下示例展示了一个简单的 <Flow>，它始终执行“Log-Message-OK”政策：

<!-- api-platform/reference/examples/flow-segments/flow-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-flow">
    <Flow>
      <Request>
        <Step>
          <Name>Log-Message-OK</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

示例 2

以下示例展示了包含多个步骤的 <Flow>：每个步骤都有自己的条件：

<!-- api-platform/reference/examples/flow-segments/flow-2.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

示例 3

以下示例显示了条件流中的多个流：

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Apigee 在细分中只执行一次流；它将执行第一个没有条件或条件被解析为 true 的流。

属性

下表说明了 <Flow> 元素的属性：

特性	类型	说明
name	字符串	（必需） 流程的唯一 ID。例如 My-Conditional-Flow-1。名称不得包含空格或其他特殊字符。

子元素

下表介绍了 <Flow> 的子元素：

子元素	类型	说明
<Condition>	字符串	定义在运行时处理的条件语句。如果语句的计算结果为 true，则执行流（及其所有步骤）。如果语句的计算结果为 false，则忽略流程（及其所有步骤）。
<Description>	字符串	提供流程的简要说明。此说明不会在外部显示。
<Request>	复杂 对象	指定请求细分的步骤和条件。
<Response>	复杂对象	指定响应细分的步骤和条件。

<Flows>

包含零个或多个的 <Flow> 元素。

Type	复杂对象
父 元素	<ProxyEndpoint> <TargetEndpoint>
子 元素	<Flow>

如果 <Flows> 中有多个 <Flow> 元素，则只会执行一个 <Flow>。这将是没有 <Condition> 或条件被解析为 true 的第一个流程。

您可以定义始终执行的默认流程（如果没有其他流执行）。您可以根据 API 代理的配置方式，这在 防范恶意攻击 中是一有用的工具。

语法

<Flows> 元素使用以下语法：

<Flows name="flow_name">
  <Flow name="conditional_flow_name">
    <Description>flow_description</Description>
    <Condition>property operator "value"</Condition>
    <Request>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Request>
    <Response>
      <Step>
        <Condition>property operator "value"</Condition>
        <Name>policy_name</Name>
      </Step>
      ...
    </Response>
  </Flow>
</Flows>

<Flows> 的所有子元素都是可选的。

示例 1

以下示例展示了一个简单的 <Flows> 元素和一个 <Flow>：

<!-- api-platform/reference/examples/flow-segments/flows-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Apigee 会根据它从 proxy 流变量中收集的路径后缀执行其中一项政策。如果路径后缀与上述两个条件都不匹配，则 Apigee 不会执行此流程。

示例 2

以下示例展示了 <Flows> 中的多个 <Flow> 元素，每个元素都有自己的 <Condition>：

<!-- api-platform/reference/examples/flow-segments/flows-2.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-2">
      <Response>
        <Step>
          <Condition>response.status.code >= 400</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-flow-3">
      <Response>
        <Step>
          <Condition>response.status.code >= 300</Condition>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Apigee 仅对细分条件评估为 true 的执行第一个流。然后，Apigee 会跳过细分中的剩余流。

示例 3

以下示例显示了一个“默认”<Flow>：

<!-- api-platform/reference/examples/flow-segments/flows-3.xml -->
<ProxyEndpoint name="default">
  <Flows>
    <Flow name="my-conditional-flow-1">
      <Response>
        <Step>
          <Condition>response.status.code = 200</Condition>
          <Name>Assign-Message-1</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-conditional-flow-2">
      <Response>
        <Step>
          <Condition>response.header.someheader = "42"</Condition>
          <Name>Assign-Message-2</Name>
        </Step>
      </Response>
    </Flow>
    <Flow name="my-default-flow">
      <Response>
        <Step>
          <Name>Assign-Message-3</Name>
        </Step>
      </Response>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

Apigee 仅对细分条件评估为 true 的执行第一个流。如果没有条件执行流，则本示例中的第三个流（无条件）执行。

默认流程是一种有用的 防范恶意攻击。

属性

<Flows> 元素没有属性。

子元素

<Flows> 元素具有以下子元素：

子元素	类型	说明
<Flow>	复杂对象	在条件流中定义一组可能步骤的流程。

<Name>

指定要在 <Flow> 中执行的政策的 ID。

Type	字符串
父 元素	<Step>
子 元素	无

语法

<Name> 元素使用以下语法：

<Name>policy_name</Name>

示例

以下示例显示了按名称添加流中的两个政策：

<!-- api-platform/reference/examples/flow-segments/name-1.xml -->
<ProxyEndpoint name="default">
  <Flows name="my-conditional-flows">
    <Flow name="reports">
      <Request>
        <Description>Based on the path suffix, determine which flow to use</Description>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/reports"</Condition>
          <Name>XML-to-JSON-1</Name>
        </Step>
        <Step>
          <Condition>proxy.pathsuffix MatchesPath "/forecasts"</Condition>
          <Name>Verify-Auth-1</Name>
        </Step>
      </Request>
    </Flow>
  </Flows>
  ...
</ProxyEndpoint>

属性

<Name> 元素没有属性。

子元素

<Name> 元素没有子元素。

<PostFlow>

定义在请求和响应的 PostFlow 中采取的步骤。

Type	复杂对象
父 元素	<ProxyEndpoint> <TargetEndpoint>
子 元素	<Description> <Request> <Response>

<PostFlow> 元素使用以下语法：

语法

<PostFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostFlow>

示例

以下示例展示了同时定义了请求和响应的 PostFlow：

<!-- api-platform/reference/examples/flow-segments/postflow-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Name>Set-Response-Headers</Name>
      </Step>
    </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

属性

下表说明了 <PostFlow> 元素的属性：

特性	类型	说明
name	字符串	流程的唯一 ID（在端点内唯一）。例如 My-PostFlow-1。名称不得包含空格或其他特殊字符。

子元素

下表介绍了 <PostFlow> 的子元素：

子元素	类型	说明
<Description>	字符串	提供流程的简要说明。
<Request>	复杂 对象	定义在请求的 PostFlow 期间要执行的政策。
<Response>	复杂对象	定义在响应的 PostFlow 期间要执行的政策。

<PostClientFlow>

定义 ProxyEndpoint 政策中，仅在响应返回客户端后执行。这些政策通常记录与响应相关的消息。

Type	复杂对象
父 元素	<ProxyEndpoint>
子 元素	<Description> <Response>

语法

<PostClientFlow> 元素使用以下语法：

<PostClientFlow name="flow_name">
  <Description>flow_description</Description>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PostClientFlow>

<PostClientFlow> 的所有子元素都是可选的。

示例

以下示例展示了执行单个政策的简单 PostClientFlow：

<!-- api-platform/reference/examples/flow-segments/postclientflow-1.xml -->
<ProxyEndpoint name="default">
  <PostClientFlow name="my-postclientflows">
    <Description>My first PostClientFlow. Processed after the response is sent back to the client.</Description>
    <Response>
      <Step>
        <Name>Message-Logging-OK</Name>
      </Step>
    </Response>
  </PostClientFlow>
  ...
</ProxyEndpoint>

属性

下表说明了 <PostClientFlow> 元素的属性：

特性	类型	说明
name	字符串	流程的唯一 ID。名称不得包含空格或其他特殊字符。例如 My-PostClientFlow-1。

子元素

下表介绍了 <PostClientFlow> 的子元素：

子元素	类型	说明
<Description>	字符串	提供流程的简要说明。
<Response>	复杂对象	定义在响应的 PostFlow 期间要执行的政策。

<PreFlow>

定义在请求和响应的 PreFlow 中执行的政策。

Type	复杂对象
父 元素	<ProxyEndpoint> <TargetEndpoint>
子 元素	<Description> <Request> <Response>

语法

<PreFlow> 元素使用以下语法：

<PreFlow name="flow_name">
  <Description>flow_description</Description>
  <Request>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Request>
  <Response>
    <Step>
      <Condition>property operator "value"</Condition>
      <Name>policy_name</Name>
    </Step>
    ...
  </Response>
</PreFlow>

<PreFlow> 的所有子元素都是可选的。

示例

以下示例展示了包含请求和响应流的 PreFlow：

<!-- api-platform/reference/examples/flow-segments/preflow-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
    <Response>
      <Step>
        <Condition>response.status.code LesserThanOrEquals 300</Condition>
        <Name>Log-Response-OK</Name>
      </Step>
      <Step>
        <Condition>response.status.code GreaterThan 300</Condition>
        <Name>Log-Response-NOT-OK</Name>
      </Step>
    </Response>
  </PreFlow>
  ...
</ProxyEndpoint>

属性

下表说明了 <PreFlow> 元素的属性：

特性	类型	说明
name	字符串	流程的唯一 ID。名称不得包含空格或其他特殊字符。例如 My-PreFlow-1。

子元素

下表介绍了 <PreFlow> 的子元素：

子元素	类型	说明
<Description>	字符串	提供流程的简要说明。
<Request>	复杂 对象	定义在请求的 PreFlow 期间要执行的政策。
<Response>	复杂对象	定义在响应的 PreFlow 期间要执行的政策。

<Request>

定义在流的请求细分期间执行的政策。

Type	复杂对象
父 元素	<Flow> <PreFlow> <PostFlow>
子 元素	<Condition> <Step>

语法

<Request> 元素使用以下语法：

<Request>
  <Step>
    <Condition>property operator "value"</Condition>
    <Name>policy_name</Name>
  </Step>
  ...
</Request>

<Request> 的所有子元素都是可选的。

示例

以下示例显示了 PreFlow 和 PostFlow 中为请求定义的流程：

<!-- api-platform/reference/examples/flow-segments/request-1.xml -->
<ProxyEndpoint name="default">
  <PreFlow name="my-preFlows">
    <Description>My first PreFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PreFlow>
  <PostFlow name="my-postflows">
    <Description>My first PostFlow</Description>
    <Request>
      <Step>
        <Condition>request.verb = "GET"</Condition>
        <Name>Log-Request-OK</Name>
      </Step>
    </Request>
  </PostFlow>
  ...
</ProxyEndpoint>

属性

<Request> 元素没有属性。

子元素

下表介绍了 <Request> 的子元素：

子元素	类型	说明
<Condition>	复杂 对象	确定是否执行请求细分中的步骤。
<Step>	字符串	指定要在请求细分中执行的政策。

<Response>

定义在流的响应细分期间执行的政策。

Type	复杂对象
父 元素	<Flow> <PreFlow> <PostClientFlow> <PostFlow>
子 元素	<Condition> <Step>

语法

<Response> 元素使用以下语法：

<Response>
  <Step>
    <Condition>property operator "value"</Condition>
    <Name>policy_name</Name>
  </Step>
  ...
</Response>

<Response> 的所有子元素都是可选的。

示例

以下示例显示了 PreFlow 和 PostFlow 中为响应定义的流：

<!-- api-platform/reference/examples/flow-segments/response-1.xml -->
<ProxyEndpoint name="default">
    <PreFlow name="my-preFlows">
        <Description>My first PreFlow</Description>
        <Response>
            <Step>
                <Condition>response.status.code LesserThanOrEquals 300</Condition>
                <Name>Log-Response-OK</Name>
            </Step>
            <Step>
                <Condition>response.status.code GreaterThan 300</Condition>
                <Name>Log-Response-NOT-OK</Name>
            </Step>
        </Response>
    </PreFlow>
    <PostFlow name="my-postflows">
        <Description>My first PostFlow</Description>
        <Response>
            <Step>
                <Name>Set-Response-Headers</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

属性

<Response> 元素没有属性。

子元素

下表介绍了 <Response> 的子元素：

子元素	类型	说明
<Condition>	字符串	确定是否执行响应细分中的步骤。
<Step>	字符串	指定要在响应细分中执行的政策。

<Step>

指定要执行的政策以及（可选）确定执行该政策的条件。

Type	复杂对象
父 元素	<Request> <Response>
子 元素	<Condition> <Name>

您可以在 <Flow> 中定义多个步骤，并且执行这些步骤的顺序都是在流的 XML 中定义的。

不执行条件的步骤始终执行。包含条件的步骤仅在条件计算结果为 true 时执行。如果条件计算结果为 false，则 Apigee 会跳过此步骤。

语法

<Step> 元素使用以下语法：

<Step>
  <Condition>property operator "value"</Condition>
  <Name>policy_name</Name>
</Step>

每个 <Step> 只能有一个 <Condition> 和一个 <Name>，但 <Flow> 可以有多个步骤。

<Step> 的所有子元素都是可选的。

示例 1

以下示例展示了包含条件的一步和没有条件的步骤：

<!-- api-platform/reference/examples/flow-segments/step-1.xml -->
<ProxyEndpoint name="default">
  <PostFlow name="my-postflows">
      <Description>My first PostFlow</Description>
      <Request>
          <Step>
              <Condition>request.verb = "GET"</Condition>
              <Name>Log-Request-OK</Name>
          </Step>
      </Request>
      <Response>
          <Step>
              <Name>Set-Response-Headers</Name>
          </Step>
      </Response>
  </PostFlow>
  ...
</ProxyEndpoint>

无条件的步骤将在每次请求细分期间执行。只有当请求为响应细分中的“GET”状态时，系统才会执行带有条件的步骤。

示例 2

以下示例显示了一个细分中的多个步骤：

<!-- api-platform/reference/examples/flow-segments/step-2.xml -->
<ProxyEndpoint name="default">
    <PostFlow name="PostFlow">
        <Response>
            <Step>
                <Name>Assign-Message-1</Name>
            </Step>
            <Step>
                <Name>Assign-Message-2</Name>
            </Step>
        </Response>
    </PostFlow>
  ...
</ProxyEndpoint>

不执行条件的步骤始终执行。

属性

<Step> 元素没有属性。

子元素

下表介绍了 <Step> 的子元素：

子元素	类型	说明
<Condition>	字符串	定义在运行时处理的步骤的条件语句。如果语句的计算结果为 true，则 Apigee 会执行此步骤。如果语句的计算结果为 false，则 Apigee 会跳过此步骤。
<Name>	字符串	指定要在当前流中执行的政策的 ID。