翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# アクティビティクライアントとワークフロークライアント
<a name="clients"></a>

ワークフロークライアントとアクティビティクライアントは、`@Workflow` インターフフェイスと `@Activities` インターフェイスに基づいて、フレームワークで生成されます。クライアントインターフェイスは、クライアント別のメソッドと設定を反映して個別に生成されます。Eclipse を使用して開発している場合は、該当するインターフェイスを含むファイルを保存するたびに Amazon SWF Eclipse プラグインで生成されます。生成されたコードは、インターフェイスと同じパッケージのプロジェクトの生成されたソースディレクトリに配置されます。

**注記**  
Eclipse で使用されるデフォルトのディレクトリ名は .apt\_generated です。Eclipse' で始まる名前のディレクトリは表示されません。Package Explorer を参照してください。生成されたファイルをプロジェクトエクスプローラで表示するには、別のディレクトリ名を使用してください。Eclipse のパッケージエクスプローラで、パッケージを右クリックし、**[プロパティ]**、**[Java Compiler]** (Java コンパイラ)、**[Annotation processing]** (注釈処理) の順に選択して、**[Generate source directory]** (ソースディレクトリの生成) の設定を変更します。

## ワークフロークライアント
<a name="clients.workflow"></a>

ワークフローの生成されたアーティファクトには、3 つのクライアント側インターフェイスとこれらを実装するクラスが含まれています。生成されたクライアントは以下のとおりです。
+ *非同期クライアント*。ワークフロー実装内からワークフロー実行の開始とシグナルの送信を行うための非同期メソッドを提供します。
+ *外部クライアント*。ワークフロー実装のスコープ外から、実行の開始、シグナルの送信、ワークフロー状態の取得を行うことができます。
+ *セルフクライアント*。継続的なワークフローを作成できます。

たとえば、サンプルの `MyWorkflow` インターフェイスで生成されたクライアントインターフェイスは以下のとおりです。

```
//Client for use from within a workflow
public interface MyWorkflowClient extends WorkflowClient
{
    Promise<Void> startMyWF(
       int a, String b);

    Promise<Void> startMyWF(
       int a, String b,
       Promise<?>... waitFor);

    Promise<Void> startMyWF(
       int a, String b,
       StartWorkflowOptions optionsOverride,
       Promise<?>... waitFor);

    Promise<Void> startMyWF(
       Promise<Integer> a,
       Promise<String> b);

    Promise<Void> startMyWF(
       Promise<Integer> a,
       Promise<String> b,
       Promise<?>... waitFor);

    Promise<Void> startMyWF(
       Promise<Integer> a,
       Promise<String> b,
       StartWorkflowOptions optionsOverride,
       Promise<?>... waitFor);

    void signal1(
      int a, int b, String c);
}

//External client for use outside workflows
public interface MyWorkflowClientExternal extends WorkflowClientExternal
{
    void startMyWF(
       int a, String b);

    void startMyWF(
       int a, String b,
       StartWorkflowOptions optionsOverride);

    void signal1(
       int a, int b, String c);

    MyWorkflowState getState();
}

//self client for creating continuous workflows
public interface MyWorkflowSelfClient extends WorkflowSelfClient
{
    void startMyWF(
       int a, String b);

    void startMyWF(
       int a, String b,
       Promise<?>... waitFor);

    void startMyWF(
       int a, String b,
       StartWorkflowOptions optionsOverride,
       Promise<?>... waitFor);

    void startMyWF(
       Promise<Integer> a,
       Promise<String> b);

    void startMyWF(
       Promise<Integer> a,
       Promise<String> b,
       Promise<?>... waitFor);

    void startMyWF(
       Promise<Integer> a,
       Promise<String> b,
       StartWorkflowOptions optionsOverride,
       Promise<?>... waitFor);
```

これらのインターフェイスには、宣言した `@Workflow` インターフェイスの各メソッドに対応するオーバーロードメソッドがあります。

外部クライアントは、`@Workflow` インターフェイスのメソッドをミラーリングし、`StartWorkflowOptions` を取る `@Execute` メソッドのオーバーロードを 1 つ追加しています。新しいワークフロー実行を開始する場合、このオーバーロードを使用して追加のオプションを渡すことができます。これらのオプションにより、デフォルトのタスクリストやタイムアウト設定を上書きし、ワークフロー実行にタグを関連付けることができます。

一方、非同期クライアントには、`@Execute` メソッドの非同期呼び出しを許可するメソッドがあります。次のメソッドオーバーロードは、ワークフローインターフェイスの `@Execute` メソッドに対して、クライアントインターフェイスで生成されます。

1. 元の引数をそのまま取るオーバーロード。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例:

   元のメソッド:

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド:

   ```
   Promise<Void> startMyWF(int a, String b);
   ```

   ワークフローのすべての引数が使用可能で、待機する必要がない場合は、このオーバーロードを使用します。

1. 元の引数 (そのまま) と追加の `Promise<?>` 型の変数引数を取るオーバーロード。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例: 

   元のメソッド:

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド:

   ```
   Promise<void> startMyWF(int a, String b, Promise<?>...waitFor);
   ```

   ワークフローのすべての引数が使用可能で、待機する必要がないが、他のいくつかの Promise の準備が完了するのを待機する場合は、このオーバーロードを使用します。この変数引数を使用して、引数として宣言されていないが、呼び出しを実行するまで待機する `Promise<?>` オブジェクトを渡すことができます。

1. 元の引数 (そのまま)、追加の `StartWorkflowOptions` 型の引数、および追加の `Promise<?>` 型の変数引数を取るオーバーロード。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例:

   元のメソッド:

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド:

   ```
   Promise<void> startMyWF(
      int a,
      String b,
      StartWorkflowOptions optionOverrides,
      Promise<?>...waitFor);
   ```

   このオーバーロードは、ワークフローのすべての引数が使用可能で待機する必要がない場合、ワークフロー実行のスタート用のデフォルト設定を上書きする場合、または他の Promise の準備が完了するまで待機する場合に使用します。この変数引数を使用して、引数として宣言されていないが、呼び出しを実行するまで待機する `Promise<?>` オブジェクトを渡すことができます。

1. 元のメソッドの各引数が `Promise<>` ラッパーに置き換えられたオーバーロード。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例: 

   元のメソッド: 

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> startMyWF(
      Promise<Integer> a,
      Promise<String> b);
   ```

   このオーバーロードは、ワークフロー実行に渡す引数を非同期的に評価する場合に使用します。このメソッドオーバーロードに対する呼び出しは、オーバーロードに渡したすべての引数の準備が完了するまで、実行されません。

   一部の引数が準備完了済みである場合は、これらを `Promise.asPromise({{value}})` メソッドを通じて準備完了済み状態の `Promise` に変換します。例:

   ```
   Promise<Integer> a = getA();
   String b = getB();
   startMyWF(a, Promise.asPromise(b));
   ```

1. 元のメソッドの各引数が `Promise<>` ラッパーに置き換えられたオーバーロード。このオーバーロードには、追加の `Promise<?>` 型の変数引数もあります。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例:

   元のメソッド: 

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> startMyWF(
      Promise<Integer> a,
      Promise<String> b,
      Promise<?>...waitFor);
   ```

   ワークフロー実行に渡す引数を非同期的に評価する必要があり、他のいくつかの Promise の準備が完了するのを待機する場合は、このオーバーロードを使用します。このメソッドオーバーロードに対する呼び出しは、オーバーロードに渡したすべての引数の準備が完了するまで、実行されません。

1. 元のメソッドの各引数が `Promise<?>` ラッパーに置き換えられたオーバーロード。このオーバーロードには、追加の `StartWorkflowOptions` 型の引数と `Promise<?>` 型の変数引数があります。このオーバーロードの戻り値の型は、元のメソッドから `void` が返された場合は `Promise<Void>` になります。それ以外の場合は、元のメソッドに宣言されている `Promise<>` になります。例: 

   元のメソッド: 

   ```
   void startMyWF(int a, String b);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> startMyWF(
      Promise<Integer> a,
      Promise<String> b,
      StartWorkflowOptions optionOverrides,
      Promise<?>...waitFor);
   ```

   ワークフロー実行に渡す引数を非同期的に評価し、ワークフロー実行をスタートするために使用するデフォルト設定を上書きする場合は、このオーバーロードを使用します。このメソッドオーバーロードに対する呼び出しは、オーバーロードに渡したすべての引数の準備が完了するまで、実行されません。

また、ワークフローインターフェイスの各シグナルに対応するメソッドも生成されます。以下に例を挙げます。

元のメソッド:

```
void signal1(int a, int b, String c);
```

生成されたメソッド:

```
void signal1(int a, int b, String c);
```

この非同期クライアントには、元のインターフェイスの `@GetState` 注釈が設定されたメソッドに対応するメソッドがありません。状態の取得にはウェブサービス呼び出しが必要なため、ワークフロー内での使用は適していません。したがって、これは外部クライアントを通じてのみ提供されます。

セルフクライアントは、現在の実行が完了したときに、ワークフロー内から新しい実行を開始するために使用します。このクライアントのメソッドは、非同期クライアントのものと似ていますが、`void` を返します。このクライアントには、`@Signal` 注釈と `@GetState` 注釈が設定されたメソッドに対応するメソッドがありません。詳細については、「[継続的なワークフロー](continuous.md)」を参照してください。

生成されたクライアントは、基本インターフェイスの `WorkflowClient` と `WorkflowClientExternal` からそれぞれ派生されます。これらのインターフェイスが提供するメソッドを使用して、ワークフロー実行をキャンセルまたは終了できます。これらのインターフェイスの詳細については、 AWS SDK for Java のドキュメントを参照してください。

生成されたクライアントでは、厳密に型指定された形式でワークフロー実行とやり取りできます。生成されたクライアントのインスタンスは、作成後、特定のワークフロー実行に関連付けられ、その実行でのみ使用できます。また、フレームワークは、ワークフローのタイプや実行に固有でない動的クライアントも提供します。生成されたクライアントは、この動的クライアントに表面下で依存します。これらのクライアントを直接使用することもできます。「[動的クライアント](#dynamicclients)」のセクションを参照してください。

フレームワークでは、厳密に型指定されたクライアントを作成するためのファクトリも生成します。`MyWorkflow` インターフェイスの例で生成されたクライアントファクトリは以下のとおりです。

```
//Factory for clients to be used from within a workflow
public interface MyWorkflowClientFactory
   extends WorkflowClientFactory<MyWorkflowClient>
{
}

//Factory for clients to be used outside the scope of a workflow
public interface MyWorkflowClientExternalFactory
{
   GenericWorkflowClientExternal getGenericClient();
   void setGenericClient(GenericWorkflowClientExternal genericClient);
   DataConverter getDataConverter();
   void setDataConverter(DataConverter dataConverter);
   StartWorkflowOptions getStartWorkflowOptions();
   void setStartWorkflowOptions(StartWorkflowOptions startWorkflowOptions);
   MyWorkflowClientExternal getClient();
   MyWorkflowClientExternal getClient(String workflowId);
   MyWorkflowClientExternal getClient(WorkflowExecution workflowExecution);
   MyWorkflowClientExternal getClient(
      WorkflowExecution workflowExecution,
      GenericWorkflowClientExternal genericClient,
      DataConverter dataConverter,
      StartWorkflowOptions options);
}
```

`WorkflowClientFactory`基本インターフェイスは次のとおりです。

```
public interface WorkflowClientFactory<T> {
    GenericWorkflowClient getGenericClient();
    void setGenericClient(GenericWorkflowClient genericClient);
    DataConverter getDataConverter();
    void setDataConverter(DataConverter dataConverter);
    StartWorkflowOptions getStartWorkflowOptions();
    void setStartWorkflowOptions(StartWorkflowOptions startWorkflowOptions);
    T getClient();
    T getClient(String workflowId);
    T getClient(WorkflowExecution execution);
    T getClient(WorkflowExecution execution,
                StartWorkflowOptions options);
    T getClient(WorkflowExecution execution,
                StartWorkflowOptions options,
                DataConverter dataConverter);
}
```

クライアントのインスタンスを作成するには、これらのファクトリを使用する必要があります。ファクトリでは、一般的なクライアント (カスタムクライアント実装を提供するために使用)、`DataConverter` (データをマーシャリングするためにクライアントで使用)、およびオプション (*ワークフロー実行*を開始するために使用) を設定できます。詳細については、「[DataConverters](dataconverters.md)」セクションと「[子ワークフロー実行](childworkflow.md)」セクションを参照してください。`StartWorkflowOptions` には、登録時に指定されたデフォルト (タイムアウトなど) をオーバーライドするために使用できる設定が含まれています。`StartWorkflowOptions` クラスの詳細については、 AWS SDK for Java ドキュメントを参照してください。

非同期クライアントではワークフロー内のコードからワークフロー実行を開始できますが、外部クライアントではワークフローのスコープ外からワークフロー実行を開始できます。実行を開始するには、生成されたクライアントを使用して、ワークフローインターフェイスの `@Execute` 注釈が設定されたメソッドに対応するメソッドを呼び出すだけです。

フレームワークでは、クライアントインターフェイスの実装クラスも生成します。これらのクライアントでは、該当するアクションを実行するためのリクエストを作成して Amazon SWF に送信します。クライアントバージョンの `@Execute` メソッドでは、新しいワークフロー実行をスタートするか、Amazon SWF API を使用して子ワークフロー実行を作成します。同様に、クライアントバージョンの `@Signal` メソッドでは、Amazon SWF API を使用してシグナルを送信します。

**注記**  
外部ワークフロークライアントは、Amazon SWF クライアントとドメインを使用して設定する必要があります。これらをパラメータとして取るクライアントファクトリコンストラクタを使用するか、Amazon SWF クライアントとドメインが設定済みの一般的なクライアント実装を渡すことができます。  
フレームワークでは、ワークフローインターフェイスの型階層を確認し、さらに親ワークフローインターフェイスのクライアントインターフェイスを生成して、これらから子を派生させます。

## アクティビティクライアント
<a name="clients.activity"></a>

ワークフロークライアントと同様に、`@Activities` 注釈が設定されたインターフェイスごとにクライアントを生成します。生成されたアーティファクトには、クライアント側インターフェイスとクライアントクラスが含まれています。上の `@Activities` インターフェイス例 (`MyActivities`) で生成されたインターフェイスは以下のとおりです。

```
public interface MyActivitiesClient extends ActivitiesClient
{
  Promise<Integer> activity1();
  Promise<Integer> activity1(Promise<?>... waitFor);
  Promise<Integer> activity1(ActivitySchedulingOptions optionsOverride,
                             Promise<?>... waitFor);
  Promise<Void> activity2(int a);
  Promise<Void> activity2(int a,
                          Promise<?>... waitFor);
  Promise<Void> activity2(int a,
                          ActivitySchedulingOptions optionsOverride,
                          Promise<?>... waitFor);
  Promise<Void> activity2(Promise<Integer> a);
  Promise<Void> activity2(Promise<Integer> a,
                          Promise<?>... waitFor);
  Promise<Void> activity2(Promise<Integer> a,
                          ActivitySchedulingOptions optionsOverride,
                          Promise<?>... waitFor);
}
```

このインターフェイスには、`@Activities` インターフェイスの各アクティビティメソッドに対応するオーバーロードメソッドのセットが含まれています。これらのオーバーロードは、利便性のために提供されており、アクティビティを非同期的に呼び出すために使用できます。`@Activities` インターフェイスのアクティビティメソッドごとに、以下のメソッドオーバーロードがクライアントインターフェイスに生成されます。

1. 元の引数をそのまま取るオーバーロード。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例: 

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> activity2(int foo);
   ```

   ワークフローのすべての引数が使用可能で、待機する必要がない場合は、このオーバーロードを使用します。

1. 元の引数 (そのまま)、`ActivitySchedulingOptions` 型の引数、および追加の `Promise<?>` 型の変数引数を取るオーバーロード。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例:

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> activity2(
     int foo,
     ActivitySchedulingOptions optionsOverride,
     Promise<?>... waitFor);
   ```

   このオーバーロードを使用するのは、ワークフローのすべての引数が使用可能で待機する必要がない場合、デフォルト設定を上書きする場合、または追加の `Promise` の準備が完了するまで待機する場合です。この変数引数を使用して、引数として宣言されていないが、呼び出しを実行するまで待機する追加の `Promise<?>` オブジェクトを渡すことができます。

1. 元のメソッドの各引数が `Promise<>` ラッパーに置き換えられたオーバーロード。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例:

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> activity2(Promise<Integer> foo);
   ```

   このオーバーロードは、アクティビティに渡す引数を非同期的に評価する場合に使用します。このメソッドオーバーロードに対する呼び出しは、オーバーロードに渡したすべての引数の準備が完了するまで、実行されません。

1. 元のメソッドの各引数が `Promise<>` ラッパーに置き換えられたオーバーロード。このオーバーロードには、追加の `ActivitySchedulingOptions` 型の引数と `Promise<?>` 型の変数引数があります。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例: 

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> activity2(
      Promise<Integer> foo,
      ActivitySchedulingOptions optionsOverride,
      Promise<?>...waitFor);
   ```

   このオーバーロードを使用するのは、アクティビティに渡す引数を非同期的に評価する場合、タイプに登録したデフォルト設定を上書きする場合、または追加の `Promise` の準備が完了するまで待機する場合です。このメソッドオーバーロードに対する呼び出しは、オーバーロードに渡したすべての引数の準備が完了するまで、実行されません。生成されたクライアントクラスでは、このインターフェイスを実装します。各インターフェイスメソッドの実装では、Amazon SWF API を使用した適切な型のアクティビティタスクをスケジュールするためのリクエストを作成し、Amazon SWF に送信します。

1. 元の引数 (そのまま) と追加の `Promise<?>` 型の変数引数を取るオーバーロード。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例: 

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise< Void > activity2(int foo,
                                Promise<?>...waitFor);
   ```

   アクティビティのすべての引数が使用可能で、待機する必要がないが、他の `Promise` オブジェクトの準備が完了するのを待機する場合は、このオーバーロードを使用します。

1. 元のメソッドの各引数が `Promise` ラッパーに置き換えられ、さらに追加の `Promise<?>` 型の変数引数を取るオーバーロード。このオーバーロードの戻り値の型は `Promise<{{T}}>` であり、ここで `{{T}}` は元のメソッドの戻り値の型です。例: 

   元のメソッド: 

   ```
   void activity2(int foo);
   ```

   生成されたメソッド: 

   ```
   Promise<Void> activity2(
     Promise<Integer> foo,
     Promise<?>... waitFor);
   ```

   アクティビティのすべての引数を非同期的に待機し、さらに他のいくつかの `Promise` の準備が完了するのを待機する場合は、このオーバーロードを使用します。このメソッドオーバーロードに対する呼び出しは、渡したすべての `Promise` オブジェクトが準備完了状態になると、非同期的に実行されます。

また、生成されたアクティビティクライアントには、各アクティビティメソッドに対応する保護されたメソッド (`{{{activity method name}}}Impl()`) があり、すべてのアクティビティオーバーロードから呼び出されます。このメソッドを上書きして、モッククライアント実装を作成できます。このメソッドは引数として、`ActivitySchedulingOptions` ラッパーの元のメソッドに対するすべての引数、`Promise<>`、および `Promise<?>` 型の変数引数を取ります。例:

元のメソッド: 

```
void activity2(int foo);
```

生成されたメソッド: 

```
Promise<Void> activity2Impl(
   Promise<Integer> foo,
   ActivitySchedulingOptions optionsOverride,
   Promise<?>...waitFor);
```

## スケジュールオプション
<a name="schedulingoptions"></a>

生成されたアクティビティクライアントでは、`ActivitySchedulingOptions` を引数として渡すことができます。`ActivitySchedulingOptions` 構造内の設定により、Amazon SWF でフレームワークがスケジュールするアクティビティタスクの構成を決定します。これらの設定は、登録オプションで指定したデフォルトを上書きします。スケジュールオプションを動的に指定するには、`ActivitySchedulingOptions` オブジェクトを作成し、必要に応じて設定した上で、アクティビティメソッドに渡します。次の例では、アクティビティタスク用のタスクリストを指定しています。これにより、このアクティビティの呼び出し用に登録時に設定したデフォルトのタスクリストが上書きされます。

```
public class OrderProcessingWorkflowImpl implements OrderProcessingWorkflow {

    OrderProcessingActivitiesClient activitiesClient
            = new OrderProcessingActivitiesClientImpl();

    // Workflow entry point
    @Override
    public void processOrder(Order order) {
        Promise<Void> paymentProcessed = activitiesClient.processPayment(order);
        ActivitySchedulingOptions schedulingOptions
             = new ActivitySchedulingOptions();
        if (order.getLocation() == "Japan") {
            schedulingOptions.setTaskList("TasklistAsia");
        } else {
            schedulingOptions.setTaskList("TasklistNorthAmerica");
        }

        activitiesClient.shipOrder(order,
                                   schedulingOptions,
                                   paymentProcessed);
    }
}
```

## 動的クライアント
<a name="dynamicclients"></a>

生成されたクライアントに加えて、フレームワークには、汎用クライアントとして `DynamicWorkflowClient` と `DynamicActivityClient` もあります。これらを使用してワークフロー実行の動的なスタート、シグナルの送信、アクティビティのスケジュールなどを行うことができます。たとえば、設計時には未知である型のアクティビティをスケジュールできます。このようなアクティビティタスクは、`DynamicActivityClient` を使用してスケジュールできます。同様に、`DynamicWorkflowClient` を使用して子ワークフロー実行を動的にスケジュールできます。次の例では、ワークフローでデータベースからアクティビティを探し、これを動的アクティビティクライアントを使用してスケジュールします。

```
//Workflow entrypoint
@Override
public void start() {
   MyActivitiesClient client = new MyActivitiesClientImpl();
  Promise<ActivityType> activityType
      = client.lookUpActivityFromDB();
  Promise<String> input = client.getInput(activityType);
  scheduleDynamicActivity(activityType,
                          input);
}
@Asynchronous
void scheduleDynamicActivity(Promise<ActivityType> type,
                             Promise<String> input){
  Promise<?>[] args = new Promise<?>[1];
   args[0] = input;
   DynamicActivitiesClient activityClient
       = new DynamicActivitiesClientImpl();
   activityClient.scheduleActivity(type.get(),
                                   args,
                                   null,
                                   Void.class);
}
```

詳細については、 AWS SDK for Java ドキュメントを参照してください。

### ワークフロー実行のシグナル送信とキャンセル
<a name="executioncontext.signal"></a>

生成されたワークフロークライアントには、ワークフローに送信できる各シグナルに対応するメソッドがあります。これらのメソッドをワークフロー内から使用して、他のワークフロー実行にシグナルを送信できます。これにより、シグナル信号の型指定された機構が提供されます。ただし、シグナル名をメッセージで受信した場合など、シグナル名を動的に決定する必要がある場合があります。動的ワークフロークライアントを使用すると、任意のワークフロー実行にシグナルを動的に送信できます。同様に、このクライアントを使用して、別のワークフロー実行の取り消しをリクエストできます。

次の例では、ワークフローはデータベースからシグナルを送信する先の実行を見つけ、動的ワークフロークライアントを使ってシグナルを動的に送信します。

```
//Workflow entrypoint
public void start()
{
  MyActivitiesClient client = new MyActivitiesClientImpl();
  Promise<WorkflowExecution> execution = client.lookUpExecutionInDB();
  Promise<String> signalName = client.getSignalToSend();
  Promise<String> input = client.getInput(signalName);
  sendDynamicSignal(execution, signalName, input);
}

@Asynchronous
void sendDynamicSignal(
   Promise<WorkflowExecution> execution,
   Promise<String> signalName,
   Promise<String> input)
{
   DynamicWorkflowClient workflowClient
      = new DynamicWorkflowClientImpl(execution.get());
   Object[] args = new Promise<?>[1];
   args[0] = input.get();
   workflowClient.signalWorkflowExecution(signalName.get(), args);
}
```